文章目录
1.参数配置模块设计
- 配置项变量及说明
配置项变量 说明
int tunable_pasv_enable = 1; 是否开启被动模式，开关型的配置项：真或假；
int tunable_port_enable = 1; 是否开启主动模式
unsigned int tunable_listen_port = 21; FTP服务器端口，整数参数的配置项；
unsigned int tunable_max_clients = 2000; 最大连接数
unsigned int tunable_max_per_ip = 50; 每IP最大连接数
unsigned int tunable_accept_timeout = 60; accept超时间
unsigned int tunable_connect_timeout = 60; connect超时间
unsigned int tunable_idle_session_timeout = 300; 控制连接超时时间
unsigned int tunable_data_connection_timeout = 300; 数据连接超时时间
unsigned int tunable_local_umask = 077; 掩码
unsigned int tunable_upload_max_rate = 0; 最大上传速度
unsigned int tunable_download_max_rate = 0; 最大下载速度
const char *tunable_listen_address; FTP服务器IP地址，字符串类型参数的配置项；
- 三张表格：配置文件中的配置项与配置项变量对应关系表
Bool型变量的配置项
static struct parseconf_bool_setting
{
const char *p_setting_name;//配置项的字符串
int *p_variable;//配置项所要保存的变量的地址，bool类型的变量可以用int类型来接收，改变量的地址就是int*
}
parseconf_bool_array[] =
{
{ "pasv_enable", &tunable_pasv_enable },//在读取文件时发现pasv_enable配置项，会将其值读取到tunable_pasv_enable变量中。
{ "port_enable", &tunable_port_enable },
{ NULL, NULL }
};
//整型参数配置项
static struct parseconf_uint_setting
{
const char *p_setting_name;
unsigned int *p_variable;//用无符号int类型指针来接收整型变量的参数
}
parseconf_uint_array[] =
{
{ "listen_port", &tunable_listen_port },
{ "max_clients", &tunable_max_clients },
{ "max_per_ip", &tunable_max_per_ip },
{ "accept_timeout", &tunable_accept_timeout },
{ "connect_timeout", &tunable_connect_timeout },
{ "idle_session_timeout", &tunable_idle_session_timeout },
{ "data_connection_timeout", &tunable_data_connection_timeout },
{ "local_umask", &tunable_local_umask },
{ "upload_max_rate", &tunable_upload_max_rate },
{ "download_max_rate", &tunable_download_max_rate },
{ NULL, NULL }//空指针结束
};
//字符串参数的配置项
static struct parseconf_str_setting
{
const char *p_setting_name;
const char **p_variable;//字符串指针变量的地址：const char *
}
parseconf_str_array[] =
{
{ "listen_address", &tunable_listen_address },
{ NULL, NULL }
};
- 相关函数
函数 说明
void parseconf_load_file(const char *path); 加载配置文件
void parseconf_load_setting(const char *setting); 将配置项加载到相应的变量
-
实现的基本思路是：
配置项信息与所对应的变量要有一一对应的关系，有：开关型配置项信息，整型参数配置项信息，字符串配置项信息，与之对应的，还设计了3张表格，eg：pasv_enable配置项与配置项变量tunable_pasv_enable相对应 -
eg：
tunable.h
#ifndef _TUNABLE_H_
#define _TUNABLE_H_
//配置项变量声明
extern int tunable_pasv_enable;
extern int tunable_port_enable;
extern unsigned int tunable_listen_port;
extern unsigned int tunable_max_clients;
extern unsigned int tunable_max_per_ip;
extern unsigned int tunable_accept_timeout;
extern unsigned int tunable_connect_timeout;
extern unsigned int tunable_idle_session_timeout;
extern unsigned int tunable_data_connection_timeout;
extern unsigned int tunable_local_umask;
extern unsigned int tunable_upload_max_rate;
extern unsigned int tunable_download_max_rate;
extern const char *tunable_listen_address;
#endif /* _TUNABLE_H_ */
tunable.c
#include "tunable.h"
int tunable_pasv_enable = 1;
int tunable_port_enable = 1;
unsigned int tunable_listen_port = 21;
unsigned int tunable_max_clients = 2000;
unsigned int tunable_max_per_ip = 50;
unsigned int tunable_accept_timeout = 60;
unsigned int tunable_connect_timeout = 60;
unsigned int tunable_idle_session_timeout = 300;
unsigned int tunable_data_connection_timeout = 300;
unsigned int tunable_local_umask = 077;
unsigned int tunable_upload_max_rate = 0;
unsigned int tunable_download_max_rate = 0;
const char *tunable_listen_address;
parseconf.h
#ifndef _PARSE_CONF_H_
#define _PARSE_CONF_H_
void parseconf_load_file(const char *path);
void parseconf_load_setting(const char *setting);
#endif /* _PARSE_CONF_H_ */
parseconf.c
#include "parseconf.h"
#include "common.h"
#include "tunable.h"
#include "str.h"
static struct parseconf_bool_setting
{
const char *p_setting_name;
int *p_variable;
}
parseconf_bool_array[] =
{
{ "pasv_enable", &tunable_pasv_enable },
{ "port_enable", &tunable_port_enable },
{ NULL, NULL }
};
static struct parseconf_uint_setting
{
const char *p_setting_name;
unsigned int *p_variable;
}
parseconf_uint_array[] =
{
{ "listen_port", &tunable_listen_port },
{ "max_clients", &tunable_max_clients },
{ "max_per_ip", &tunable_max_per_ip },
{ "accept_timeout", &tunable_accept_timeout },
{ "connect_timeout", &tunable_connect_timeout },
{ "idle_session_timeout", &tunable_idle_session_timeout },
{ "data_connection_timeout", &tunable_data_connection_timeout },
{ "local_umask", &tunable_local_umask },
{ "upload_max_rate", &tunable_upload_max_rate },
{ "download_max_rate", &tunable_download_max_rate },
{ NULL, NULL }
};
//结构体数组
static struct parseconf_str_setting
{
const char *p_setting_name;
const char **p_variable;
}
parseconf_str_array[] =
{
{ "listen_address", &tunable_listen_address },
{ NULL, NULL }
};
void parseconf_load_file(const char *path)
{
FILE *fp = fopen(path, "r");
if (fp == NULL)
ERR_EXIT("fopen");
char setting_line[1024] = {0};
while (fgets(setting_line, sizeof(setting_line), fp) != NULL)
{
//判断是否是合法的配置行
if (strlen(setting_line) == 0
|| setting_line[0] == '#'
|| str_all_space(setting_line))
continue;
str_trim_crlf(setting_line);//去除\r\n
parseconf_load_setting(setting_line);
memset(setting_line, 0, sizeof(setting_line));
}
fclose(fp);
}
void parseconf_load_setting(const char *setting)//仅仅代表字符串指针指向的内容不能被改变，不代表setting指针不能偏移
{
//去除左空格
while (isspace(*setting))
setting++;
char key[128] ={0};
char value[128] = {0};
str_split(setting, key, value, '=');
if (strlen(value) == 0)
{
fprintf(stderr, "mising value in config file for: %s\n", key);
exit(EXIT_FAILURE);
}
//字符串类型的配置项
{
const struct parseconf_str_setting *p_str_setting = parseconf_str_array;
while (p_str_setting->p_setting_name != NULL)
{
if (strcmp(key, p_str_setting->p_setting_name) == 0)
{
const char **p_cur_setting = p_str_setting->p_variable;
//变量的地址：p_cur_setting，*p_cur_setting取出变量的内容
if (*p_cur_setting)//判断指针是否是空的，如果已经有数据了，先free
free((char*)*p_cur_setting);//char* 可以隐式的转换为void*，因为free(void* str)
//而*p_cur_setting是const char*类型的，它转换成void*会有警告
//因为value是局部变量，若指针指向局部变量，那么局部变量销毁掉时，该指针会成为野指针
//strdup内部先申请内存，然后将value字符串拷贝到这块内存中，指针指向这块内存
*p_cur_setting = strdup(value);
return;//找到配置项，就return
}
p_str_setting++;//直到找到配置项即可
}
}
//bool类型的配置项
{
const struct parseconf_bool_setting *p_bool_setting = parseconf_bool_array;
while (p_bool_setting->p_setting_name != NULL)
{
if (strcmp(key, p_bool_setting->p_setting_name) == 0)
{
str_upper(value);
if (strcmp(value, "YES") == 0
|| strcmp(value, "TRUE") == 0
|| strcmp(value, "1") == 0)
*(p_bool_setting->p_variable) = 1;
else if (strcmp(value, "NO") == 0
|| strcmp(value, "FALSE") == 0
|| strcmp(value, "0") == 0)
*(p_bool_setting->p_variable) = 0;
else
{
fprintf(stderr, "bad bool value in config file for: %s\n", key);
exit(EXIT_FAILURE);
}
return;
}
p_bool_setting++;
}
}
//整数类型的配置项
{
const struct parseconf_uint_setting *p_uint_setting = parseconf_uint_array;
while (p_uint_setting->p_setting_name != NULL)
{
if (strcmp(key, p_uint_setting->p_setting_name) == 0)
{
if (value[0] == '0')//说明是0开头的8进制
*(p_uint_setting->p_variable) = str_octal_to_uint(value);
else
*(p_uint_setting->p_variable) = atoi(value);
return;
}
p_uint_setting++;
}
}
}
miniftpd.conf
pasv_enable=YES
port_enable=YES
listen_port=5188
max_clients=2000
max_per_ip=50
accept_timeout=60
connect_timeout=60
idle_session_timeout=300
data_connection_timeout=900
local_umask=077
upload_max_rate=0
download_max_rate=0
listen_address=192.168.244.100
main.c
#include "common.h"
#include "sysutil.h"
#include "session.h"
#include "str.h"
#include "tunable.h"
#include "parseconf.h"
/*
typedef struct session
{
// 控制连接
char cmdline[MAX_COMMAND_LINE];
char cmd[MAX_COMMAND];
char arg[MAX_ARG];
// 父子进程通道
int parent_fd;
int child_fd;
} session_t;
*/
int main(void)
{
// 字符串测试
/*
char *str1 = " a b";
char *str2 = " ";
if (str_all_space(str1))
printf("str1 all space\n");
else
printf("str1 not all space\n");
if (str_all_space(str2))
printf("str2 all space\n");
else
printf("str2 not all space\n");
//char *str3 = "abcDef"; // 指针指向一个字符串常量，常量不能被修改
char str3[] = "abcDef";
str_upper(str3);
printf("str3=%s\n", str3);
long long result = str_to_longlong("12345678901234");
printf("result = %lld\n", result);
int n = str_octal_to_uint("711");
printf("n=%d\n", n);
*/
//加载配置项的test程序
parseconf_load_file(MINIFTP_CONF);
printf("tunable_pasv_enable=%d\n", tunable_pasv_enable);
printf("tunable_port_enable=%d\n", tunable_port_enable);
printf("tunable_listen_port=%u\n", tunable_listen_port);//无符号int用%u
printf("tunable_max_clients=%u\n", tunable_max_clients);
printf("tunable_max_per_ip=%u\n", tunable_max_per_ip);
printf("tunable_accept_timeout=%u\n", tunable_accept_timeout);
printf("tunable_connect_timeout=%u\n", tunable_connect_timeout);
printf("tunable_idle_session_timeout=%u\n", tunable_idle_session_timeout);
printf("tunable_data_connection_timeout=%u\n", tunable_data_connection_timeout);
printf("tunable_local_umask=0%o\n", tunable_local_umask);
printf("tunable_upload_max_rate=%u\n", tunable_upload_max_rate);
printf("tunable_download_max_rate=%u\n", tunable_download_max_rate);
if (tunable_listen_address == NULL)
printf("tunable_listen_address=NULL\n");
else
printf("tunable_listen_address=%s\n", tunable_listen_address);
if (getuid() != 0)
{
fprintf(stderr, "miniftpd: must be started as root\n");
exit(EXIT_FAILURE);
}
session_t sess =
{
/* 控制连接 */
-1, "", "", "",
/* 父子进程通道 */
-1, -1
};
int listenfd = tcp_server(tunable_listen_address, tunable_listen_port);
int conn;
pid_t pid;
while (1)
{
conn = accept_timeout(listenfd, NULL, 0);
if (conn == -1)
ERR_EXIT("accept_tinmeout");
pid = fork();
if (pid == -1)
ERR_EXIT("fork");
if (pid == 0)
{
close(listenfd);
sess.ctrl_fd = conn;
begin_session(&sess);
}
else
close(conn);
}
return 0;
}
common.h
#ifndef _COMMON_H_
#define _COMMON_H_
#include <unistd.h>
#include <sys/types.h>
#include <pwd.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#define ERR_EXIT(m) \
do \
{ \
perror(m); \
exit(EXIT_FAILURE); \
} \
while (0)
#define MAX_COMMAND_LINE 1024
#define MAX_COMMAND 32
#define MAX_ARG 1024
#define MINIFTP_CONF "miniftpd.conf"
#endif /* _COMMON_H_ */
ftpproto.h
#ifndef _FTP_PROTO_H_
#define _FTP_PROTO_H_
#include "session.h"
void handle_child(session_t *sess);
#endif /* _FTP_PROTO_H_ */
ftpproto.c
#include "ftpproto.h"
#include "sysutil.h"
#include "str.h"
void handle_child(session_t *sess)
{
writen(sess->ctrl_fd, "220 (miniftpd 0.1)\r\n", strlen("220 (miniftpd 0.1)\r\n"));
int ret;
while (1)
{
memset(sess->cmdline, 0, sizeof(sess->cmdline));
memset(sess->cmd, 0, sizeof(sess->cmd));
memset(sess->arg, 0, sizeof(sess->arg));
ret = readline(sess->ctrl_fd, sess->cmdline, MAX_COMMAND_LINE);
if (ret == -1)
ERR_EXIT("readline");
else if (ret == 0)
exit(EXIT_SUCCESS);
printf("cmdline=[%s]\n", sess->cmdline);
// 去除\r\n
str_trim_crlf(sess->cmdline);
printf("cmdline=[%s]\n", sess->cmdline);
// 解析FTP命令与参数
str_split(sess->cmdline, sess->cmd, sess->arg, ' ');
printf("cmd=[%s] arg=[%s]\n", sess->cmd, sess->arg);
// 将命令转换为大写
str_upper(sess->cmd);
// 处理FTP命令
}
}
Makefile
.PHONY:clean
CC=gcc
CFLAGS=-Wall -g
BIN=miniftpd
OBJS=main.o sysutil.o session.o ftpproto.o privparent.o str.o tunable.o parseconf.o
$(BIN):$(OBJS)
$(CC) $(CFLAGS) $^ -o $@
%.o:%.c
$(CC) $(CFLAGS) -c $< -o $@
clean:
rm -f *.o $(BIN)
没有变化的有：
privparent.h
#ifndef _PARSE_CONF_H_
#define _PARSE_CONF_H_
void parseconf_load_file(const char *path);
void parseconf_load_setting(const char *setting);
#endif /* _PARSE_CONF_H_ */
privparent.c
#include "privparent.h"
void handle_parent(session_t *sess)
{
char cmd;
while (1)
{
read(sess->parent_fd, &cmd, 1);
// 解析内部命令
// 处理内部命令
}
}
session.h
#ifndef _SESSION_H_
#define _SESSION_H_
#include "common.h"
typedef struct session
{
// 控制连接
int ctrl_fd;
char cmdline[MAX_COMMAND_LINE];
char cmd[MAX_COMMAND];
char arg[MAX_ARG];
// 父子进程通道
int parent_fd;
int child_fd;
} session_t;
void begin_session(session_t *sess);
#endif /* _SESSION_H_ */
session.c
#include "common.h"
#include "session.h"
#include "ftpproto.h"
#include "privparent.h"
void begin_session(session_t *sess)
{
struct passwd *pw = getpwnam("nobody");
if (pw == NULL)
return;
if (setegid(pw->pw_gid) < 0)
ERR_EXIT("setegid");
if (seteuid(pw->pw_uid) < 0)
ERR_EXIT("seteuid");
int sockfds[2];
if (socketpair(PF_UNIX, SOCK_STREAM, 0, sockfds) < 0)
ERR_EXIT("socketpair");
pid_t pid;
pid = fork();
if (pid < 0)
ERR_EXIT("fork");
if (pid == 0)
{
// ftp服务进程
close(sockfds[0]);
sess->child_fd = sockfds[1];
handle_child(sess);
}
else
{
// nobody进程
close(sockfds[1]);
sess->parent_fd = sockfds[0];
handle_parent(sess);
}
}
str.h
#ifndef _STR_H_
#define _STR_H_
void str_trim_crlf(char *str);
void str_split(const char *str , char *left, char *right, char c);
int str_all_space(const char *str);
void str_upper(char *str);
long long str_to_longlong(const char *str);
unsigned int str_octal_to_uint(const char *str);
#endif /* _STR_H_ */
str.c
#include "str.h"
#include "common.h"
void str_trim_crlf(char *str)
{
char *p = &str[strlen(str)-1];
while (*p == '\r' || *p == '\n')
*p-- = '\0';
}
void str_split(const char *str , char *left, char *right, char c)
{
char *p = strchr(str, c);
if (p == NULL)
strcpy(left, str);
else
{
strncpy(left, str, p-str);
strcpy(right, p+1);
}
}
int str_all_space(const char *str)
{
while (*str)
{
if (!isspace(*str))
return 0;
str++;
}
return 1;
}
void str_upper(char *str)
{
while (*str)
{
*str = toupper(*str);
str++;
}
}
long long str_to_longlong(const char *str)
{
//return atoll(str);
/* long long result = 0;
long long mult = 1;
unsigned int len = strlen(str);
unsigned int i;
if (len > 15)
return 0;
for (i=0; i<len; i++)
{
char ch = str[len-(i+1)];
long long val;
if (ch < '0' || ch > '9')
return 0;
val = ch - '0';
val *= mult;
result += val;
mult *= 10;
}
*/
long long result = 0;
long long mult = 1;
unsigned int len = strlen(str);
int i;
if (len > 15)
return 0;
for (i=len-1; i>=0; i--)
{
char ch = str[i];
long long val;
if (ch < '0' || ch > '9')
return 0;
val = ch - '0';
val *= mult;
result += val;
mult *= 10;
}
return result;
}
unsigned int str_octal_to_uint(const char *str)
{
unsigned int result = 0;
int seen_non_zero_digit = 0;
while (*str)
{
int digit = *str;
if (!isdigit(digit) || digit > '7')
break;
if (digit != '0')
seen_non_zero_digit = 1;
if (seen_non_zero_digit)
{
result <<= 3;
result += (digit - '0');
}
str++;
}
return result;
}
sysutil.h
#ifndef _SYS_UTIL_H_
#define _SYS_UTIL_H_
#include "common.h"
int tcp_server(const char *host, unsigned short port);
int getlocalip(char *ip);
void activate_nonblock(int fd);
void deactivate_nonblock(int fd);
int read_timeout(int fd, unsigned int wait_seconds);
int write_timeout(int fd, unsigned int wait_seconds);
int accept_timeout(int fd, struct sockaddr_in *addr, unsigned int wait_seconds);
int connect_timeout(int fd, struct sockaddr_in *addr, unsigned int wait_seconds);
ssize_t readn(int fd, void *buf, size_t count);
ssize_t writen(int fd, const void *buf, size_t count);
ssize_t recv_peek(int sockfd, void *buf, size_t len);
ssize_t readline(int sockfd, void *buf, size_t maxline);
void send_fd(int sock_fd, int fd);
int recv_fd(const int sock_fd);
#endif /* _SYS_UTIL_H_ */
sysutil.c
#include "sysutil.h"
/**
* tcp_server - 启动tcp服务器
* @host: 服务器IP地址或者服务器主机名
* @port: 服务器端口
* 成功返回监听套接字
*/
int tcp_server(const char *host, unsigned short port)
{
int listenfd;
if ((listenfd = socket(PF_INET, SOCK_STREAM, 0)) < 0)
ERR_EXIT("tcp_server");
struct sockaddr_in servaddr;
memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
if (host != NULL)
{
if (inet_aton(host, &servaddr.sin_addr) == 0)
{
struct hostent *hp;
hp = gethostbyname(host);
if (hp == NULL)
ERR_EXIT("gethostbyname");
servaddr.sin_addr = *(struct in_addr*)hp->h_addr;
}
}
else
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(port);
int on = 1;
if ((setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, (const char*)&on, sizeof(on))) < 0)
ERR_EXIT("gethostbyname");
if (bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0)
ERR_EXIT("bind");
if (listen(listenfd, SOMAXCONN) < 0)
ERR_EXIT("listen");
return listenfd;
}
int getlocalip(char *ip)
{
char host[100] = {0};
if (gethostname(host, sizeof(host)) < 0)
return -1;
struct hostent *hp;
if ((hp = gethostbyname(host)) == NULL)
return -1;
strcpy(ip, inet_ntoa(*(struct in_addr*)hp->h_addr));
return 0;
}
/**
* activate_noblock - 设置I/O为非阻塞模式
* @fd: 文件描符符
*/
void activate_nonblock(int fd)
{
int ret;
int flags = fcntl(fd, F_GETFL);
if (flags == -1)
ERR_EXIT("fcntl");
flags |= O_NONBLOCK;
ret = fcntl(fd, F_SETFL, flags);
if (ret == -1)
ERR_EXIT("fcntl");
}
/**
* deactivate_nonblock - 设置I/O为阻塞模式
* @fd: 文件描符符
*/
void deactivate_nonblock(int fd)
{
int ret;
int flags = fcntl(fd, F_GETFL);
if (flags == -1)
ERR_EXIT("fcntl");
flags &= ~O_NONBLOCK;
ret = fcntl(fd, F_SETFL, flags);
if (ret == -1)
ERR_EXIT("fcntl");
}
/**
* read_timeout - 读超时检测函数，不含读操作
* @fd: 文件描述符
* @wait_seconds: 等待超时秒数，如果为0表示不检测超时
* 成功（未超时）返回0，失败返回-1，超时返回-1并且errno = ETIMEDOUT
*/
int read_timeout(int fd, unsigned int wait_seconds)
{
int ret = 0;
if (wait_seconds > 0)
{
fd_set read_fdset;
struct timeval timeout;
FD_ZERO(&read_fdset);
FD_SET(fd, &read_fdset);
timeout.tv_sec = wait_seconds;
timeout.tv_usec = 0;
do
{
ret = select(fd + 1, &read_fdset, NULL, NULL, &timeout);
} while (ret < 0 && errno == EINTR);
if (ret == 0)
{
ret = -1;
errno = ETIMEDOUT;
}
else if (ret == 1)
ret = 0;
}
return ret;
}
/**
* write_timeout - 读超时检测函数，不含写操作
* @fd: 文件描述符
* @wait_seconds: 等待超时秒数，如果为0表示不检测超时
* 成功（未超时）返回0，失败返回-1，超时返回-1并且errno = ETIMEDOUT
*/
int write_timeout(int fd, unsigned int wait_seconds)
{
int ret = 0;
if (wait_seconds > 0)
{
fd_set write_fdset;
struct timeval timeout;
FD_ZERO(&write_fdset);
FD_SET(fd, &write_fdset);
timeout.tv_sec = wait_seconds;
timeout.tv_usec = 0;
do
{
ret = select(fd + 1, NULL, NULL, &write_fdset, &timeout);
} while (ret < 0 && errno == EINTR);
if (ret == 0)
{
ret = -1;
errno = ETIMEDOUT;
}
else if (ret == 1)
ret = 0;
}
return ret;
}
/**
* accept_timeout - 带超时的accept
* @fd: 套接字
* @addr: 输出参数，返回对方地址
* @wait_seconds: 等待超时秒数，如果为0表示正常模式
* 成功（未超时）返回已连接套接字，超时返回-1并且errno = ETIMEDOUT
*/
int accept_timeout(int fd, struct sockaddr_in *addr, unsigned int wait_seconds)
{
int ret;
socklen_t addrlen = sizeof(struct sockaddr_in);
if (wait_seconds > 0)
{
fd_set accept_fdset;
struct timeval timeout;
FD_ZERO(&accept_fdset);
FD_SET(fd, &accept_fdset);
timeout.tv_sec = wait_seconds;
timeout.tv_usec = 0;
do
{
ret = select(fd + 1, &accept_fdset, NULL, NULL, &timeout);
} while (ret < 0 && errno == EINTR);
if (ret == -1)
return -1;
else if (ret == 0)
{
errno = ETIMEDOUT;
return -1;
}
}
if (addr != NULL)
ret = accept(fd, (struct sockaddr*)addr, &addrlen);
else
ret = accept(fd, NULL, NULL);
/* if (ret == -1)
ERR_EXIT("accept");
*/
return ret;
}
/**
* connect_timeout - connect
* @fd: 套接字
* @addr: 要连接的对方地址
* @wait_seconds: 等待超时秒数，如果为0表示正常模式
* 成功（未超时）返回0，失败返回-1，超时返回-1并且errno = ETIMEDOUT
*/
int connect_timeout(int fd, struct sockaddr_in *addr, unsigned int wait_seconds)
{
int ret;
socklen_t addrlen = sizeof(struct sockaddr_in);
if (wait_seconds > 0)
activate_nonblock(fd);
ret = connect(fd, (struct sockaddr*)addr, addrlen);
if (ret < 0 && errno == EINPROGRESS)
{
printf("AAAAA\n");
fd_set connect_fdset;
struct timeval timeout;
FD_ZERO(&connect_fdset);
FD_SET(fd, &connect_fdset);
timeout.tv_sec = wait_seconds;
timeout.tv_usec = 0;
do
{
/* 一量连接建立，套接字就可写 */
ret = select(fd + 1, NULL, &connect_fdset, NULL, &timeout);
} while (ret < 0 && errno == EINTR);
if (ret == 0)
{
ret = -1;
errno = ETIMEDOUT;
}
else if (ret < 0)
return -1;
else if (ret == 1)
{
printf("BBBBB\n");
/* ret返回为1，可能有两种情况，一种是连接建立成功，一种是套接字产生错误，*/
/* 此时错误信息不会保存至errno变量中，因此，需要调用getsockopt来获取。 */
int err;
socklen_t socklen = sizeof(err);
int sockoptret = getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &socklen);
if (sockoptret == -1)
{
return -1;
}
if (err == 0)
{
printf("DDDDDDD\n");
ret = 0;
}
else
{
printf("CCCCCC\n");
errno = err;
ret = -1;
}
}
}
if (wait_seconds > 0)
{
deactivate_nonblock(fd);
}
return ret;
}
/**
* readn - 读取固定字节数
* @fd: 文件描述符
* @buf: 接收缓冲区
* @count: 要读取的字节数
* 成功返回count，失败返回-1，读到EOF返回<count
*/
ssize_t readn(int fd, void *buf, size_t count)
{
size_t nleft = count;
ssize_t nread;
char *bufp = (char*)buf;
while (nleft > 0)
{
if ((nread = read(fd, bufp, nleft)) < 0)
{
if (errno == EINTR)
continue;
return -1;
}
else if (nread == 0)
return count - nleft;
bufp += nread;
nleft -= nread;
}
return count;
}
/**
* writen - 发送固定字节数
* @fd: 文件描述符
* @buf: 发送缓冲区
* @count: 要读取的字节数
* 成功返回count，失败返回-1
*/
ssize_t writen(int fd, const void *buf, size_t count)
{
size_t nleft = count;
ssize_t nwritten;
char *bufp = (char*)buf;
while (nleft > 0)
{
if ((nwritten = write(fd, bufp, nleft)) < 0)
{
if (errno == EINTR)
continue;
return -1;
}
else if (nwritten == 0)
continue;
bufp += nwritten;
nleft -= nwritten;
}
return count;
}
/**
* recv_peek - 仅仅查看套接字缓冲区数据，但不移除数据
* @sockfd: 套接字
* @buf: 接收缓冲区
* @len: 长度
* 成功返回>=0，失败返回-1
*/
ssize_t recv_peek(int sockfd, void *buf, size_t len)
{
while (1)
{
int ret = recv(sockfd, buf, len, MSG_PEEK);
if (ret == -1 && errno == EINTR)
continue;
return ret;
}
}
/**
* readline - 按行读取数据
* @sockfd: 套接字
* @buf: 接收缓冲区
* @maxline: 每行最大长度
* 成功返回>=0，失败返回-1
*/
ssize_t readline(int sockfd, void *buf, size_t maxline)
{
int ret;
int nread;
char *bufp = buf;
int nleft = maxline;
while (1)
{
ret = recv_peek(sockfd, bufp, nleft);
if (ret < 0)
return ret;
else if (ret == 0)
return ret;
nread = ret;
int i;
for (i=0; i<nread; i++)
{
if (bufp[i] == '\n')
{
ret = readn(sockfd, bufp, i+1);
if (ret != i+1)
exit(EXIT_FAILURE);
return ret;
}
}
if (nread > nleft)
exit(EXIT_FAILURE);
nleft -= nread;
ret = readn(sockfd, bufp, nread);
if (ret != nread)
exit(EXIT_FAILURE);
bufp += nread;
}
return -1;
}
void send_fd(int sock_fd, int fd)
{
int ret;
struct msghdr msg;
struct cmsghdr *p_cmsg;
struct iovec vec;
char cmsgbuf[CMSG_SPACE(sizeof(fd))];
int *p_fds;
char sendchar = 0;
msg.msg_control = cmsgbuf;
msg.msg_controllen = sizeof(cmsgbuf);
p_cmsg = CMSG_FIRSTHDR(&msg);
p_cmsg->cmsg_level = SOL_SOCKET;
p_cmsg->cmsg_type = SCM_RIGHTS;
p_cmsg->cmsg_len = CMSG_LEN(sizeof(fd));
p_fds = (int*)CMSG_DATA(p_cmsg);
*p_fds = fd;
msg.msg_name = NULL;
msg.msg_namelen = 0;
msg.msg_iov = &vec;
msg.msg_iovlen = 1;
msg.msg_flags = 0;
vec.iov_base = &sendchar;
vec.iov_len = sizeof(sendchar);
ret = sendmsg(sock_fd, &msg, 0);
if (ret != 1)
ERR_EXIT("sendmsg");
}
int recv_fd(const int sock_fd)
{
int ret;
struct msghdr msg;
char recvchar;
struct iovec vec;
int recv_fd;
char cmsgbuf[CMSG_SPACE(sizeof(recv_fd))];
struct cmsghdr *p_cmsg;
int *p_fd;
vec.iov_base = &recvchar;
vec.iov_len = sizeof(recvchar);
msg.msg_name = NULL;
msg.msg_namelen = 0;
msg.msg_iov = &vec;
msg.msg_iovlen = 1;
msg.msg_control = cmsgbuf;
msg.msg_controllen = sizeof(cmsgbuf);
msg.msg_flags = 0;
p_fd = (int*)CMSG_DATA(CMSG_FIRSTHDR(&msg));
*p_fd = -1;
ret = recvmsg(sock_fd, &msg, 0);
if (ret != 1)
ERR_EXIT("recvmsg");
p_cmsg = CMSG_FIRSTHDR(&msg);
if (p_cmsg == NULL)
ERR_EXIT("no passed fd");
p_fd = (int*)CMSG_DATA(p_cmsg);
recv_fd = *p_fd;
if (recv_fd == -1)
ERR_EXIT("no passed fd");
return recv_fd;
}
- 测试1：
//加载配置项的test程序
parseconf_load_file(MINIFTP_CONF);
printf("tunable_pasv_enable=%d\n", tunable_pasv_enable);
printf("tunable_port_enable=%d\n", tunable_port_enable);
printf("tunable_listen_port=%u\n", tunable_listen_port);//无符号int用%u
printf("tunable_max_clients=%u\n", tunable_max_clients);
printf("tunable_max_per_ip=%u\n", tunable_max_per_ip);
printf("tunable_accept_timeout=%u\n", tunable_accept_timeout);
printf("tunable_connect_timeout=%u\n", tunable_connect_timeout);
printf("tunable_idle_session_timeout=%u\n", tunable_idle_session_timeout);
printf("tunable_data_connection_timeout=%u\n", tunable_data_connection_timeout);
printf("tunable_local_umask=0%o\n", tunable_local_umask);
printf("tunable_upload_max_rate=%u\n", tunable_upload_max_rate);
printf("tunable_download_max_rate=%u\n", tunable_download_max_rate);
if (tunable_listen_address == NULL)
printf("tunable_listen_address=NULL\n");
else
printf("tunable_listen_address=%s\n", tunable_listen_address);
配置项可以成功读取到
- 测试2：
通过ftp客户端连接测试一下
连接测试成功
服务端看看
扫一扫
716
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
