miniFTP项目实战三

项目简介：
在Linux环境下用C语言开发的Vsftpd的简化版本，拥有部分Vsftpd功能和相同的FTP协议，系统的主要架构采用多进程模型，每当有一个新的客户连接到达，主进程就会派生出一个ftp服务进程来为客户提供服务。同时每个ftp服务进程配套了nobody进程（内部私有进程），主要是为了做权限提升和控制。
实现功能：
除了基本的文件上传和下载功能，还实现模式选择、断点续传、限制连接数、空闲断开、限速等功能。
用到的技术：
socket、I/O复用、进程间通信、HashTable
欢迎技术交流q：2723808286
项目开源！！！

miniFTP项目实战一
miniFTP项目实战二
miniFTP项目实战三
miniFTP项目实战四
miniFTP项目实战五
miniFTP项目实战六

3.1 服务进程处理FTP命令

服务进程负责处理FTP命令，包括对FTP命令的解析和调用对应的操作函数，服务进程在会话创建之后进入handle_child函数，在这个函数中，不断接收来自客户端的命令，并且解析命令，根据命令调用相关操作函数：

/*
* 循环从客户端接收数据，并解析命令和参数
*/
void handle_child(session_t *sess)
{
    int ret, i = 0;
    //连接成功时，向客户端发送220命令主要是命令的格式：220后面加一个空格
    ftp_relply(sess, FTP_GREET, "(GQ_miniFTP 0.1)");
    while (1) {
        //只初始化命令相关信息
        memset(sess->cmdline, 0, MAX_COMMAND_LINE);
        memset(sess->cmd, 0, MAX_COMMAND);
        memset(sess->arg, 0, MAX_ARG);

        start_cmdio_alarm();  //处理完之后 重新设置闹钟，进行下一次计时
        ret = readline(sess->ctl_fd, sess->cmdline, MAX_COMMAND_LINE); //读取命令
        if (ret == -1) {  //出错
            ERR_EXIT("readline");  
        } else if (ret == 0) {  //客户端断开连接，关闭服务进程，nobody进程暂时没有关闭
            exit(EXIT_SUCCESS);
        }
        
        //解析处理FTP标准命令参数 开头是命令，空格之后的是参数， 所以要分割字符串
        str_trim_crlf(sess->cmdline);                        //去除\r\n
        str_split(sess->cmdline, sess->cmd, sess->arg, ' '); //分隔字符串提取cmd arg
        str_upper(sess->cmd);                                //统一为大写字母
        printf("%s=%s\n", sess->cmd, sess->arg);

        //遍历命令映射 处理命令
        int size = sizeof(ctrl_cmds_map) / sizeof(ctrl_cmds_map[0]);
        for (i = 0; i < size; ++i) {
            if (strcmp(ctrl_cmds_map[i].cmd, sess->cmd) == 0) {
                if (ctrl_cmds_map[i].cmd_func != NULL) {
                    ctrl_cmds_map[i].cmd_func(sess);  //调用相应操作函数
                } else {
                    ftp_relply(sess, FTP_COMMANDNOTIMPL, "command Unimplement.");
                }  
                break;
            }
        }
        if (i == size) ftp_relply(sess, FTP_BADCMD, "command Unkonwn.");
    }
}

3.2 配置文件读取

vsftp都有一个配置文件，用来设置FTP服务器在连接过程中的各项参数。如下：

pasv_enable=true
port_enable=yes
listen_port=5021
max_clients=3
max_per_ip=2
accept_timeout=60
connect_timeout=60
idle_session_timeout=300
data_connection_timeout=900
local_umask=077
upload_max_rate=10240
download_max_rate=102400
listen_address=192.168.3.15

配置文件中读取配置配置项的值，代码中通过读取配置项的值来判断，配置项分为三类：

• 开关型的配置项可以用int来表示

• 整数参数的配置项可以用unsigned int

• 字符串类型配置项目 可以const char*

所以我们要分别建立三种对应关系，每种关系都用一个表格来表示，如下：

static struct parseconf_bool_setting
{
    const char *p_setting_name;
    int *p_variable;
};
struct parseconf_bool_setting 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;
};
struct parseconf_uint_setting 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;
};
struct parseconf_str_setting parseconf_str_array[] = {
    { "listen_address", &tunable_listen_address },
    { NULL, NULL }
};

将配置项名称（字符串）与配置项的值放在一个结构体中，每种数据类型的配置项都建立一个结构体数组来存储，配置文件的相关配置项。

在初始化的时候，就将配置选项字符串写进去

配置 配置文件的时候，使用两个接口：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MqCfLGHQ-1613482775198)(F:\destop\m笔记\图\image-20210205084817145.png)]

实现

先定义配置项名称，都是以字符串的形式放在tunable中，.c定义 .h声明，这些配置项都是要有初始值的。

然后我们自己创建一个配置文件。

然后编写代码去读取这个配置文件，读取相应的配置项。配置文件中配置项前后不要有空格和分号以方便读取，然后将此文件暂时放在程序目录下。

void parseconf_load_file(const char *path); //加载配置文件，读出每一项配置

void parseconf_load_setting(const char *setting); //对配置项进行解析，写入配置变量

如下：

//加载配置文件，逐行读取配置信息，对文件的解析
void parseconf_load_file(const char *path)
{
    FILE *fp;
    char setting_line[1024] = {0};

    fp = fopen(path, "r");
    if (fp == NULL) {
        ERR_EXIT("confg open filed");
    }

    //循环读取配置文件中选项，写入相应变量
    while (fgets(setting_line, 1023, fp) != NULL) {
        if (strlen(setting_line) == 0        //未读取到
            || setting_line[0] == '#'        //注释的指令
            || str_all_space(setting_line) == 1) //全是空格
            continue;

        str_trim_crlf(setting_line); //去除\r\n

        parseconf_load_setting(setting_line);  //将配置文件中的选项加载到相应变量中

        // memset(setting_line, 0, strlen(setting_line));  strlen不行，因为strlen是以结束符\0为标志的，上面去除\r\n没了
        memset(setting_line, 0, sizeof(setting_line));
    }
    fclose(fp);
}   

//将配置文件加载到相应的配置项，对配置项的解析
//遍历三张配置信息表，将配置信息放入相应的变量中
void parseconf_load_setting(const char *setting)
{
    char key[128] = {0};
    char val[128] = {0};

    while (isspace(*setting)) {  //去除左边可能存在的空格
        ++setting;
    }
    str_split(setting, key, val, '=');
    if (strlen(val) == 0) {  //无配置内容，出错提示
        fprintf(stderr, "missing value in config file for:%s", 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(p_str_setting->p_setting_name, key) == 0) {
            const char **p_cur_setting = p_str_setting->p_variable; //
            if (*p_cur_setting != NULL) {
                free((char*)p_cur_setting);
            }
            //申请一块内存用来存放字符串，因为之前只是一个二级指针
            *p_cur_setting = strdup(val);  //malloc+strcpy
            return ;
        }
        ++p_str_setting;
    }
    free(*(char*)p_str_setting);

    //布尔值配置选项读取
    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(val);
            if (strcmp(val, "TRUE") == 0
                || strcmp(val, "YES") == 0
                || strcmp(val, "1") == 0   ) {
                *p_bool_setting->p_variable = true;
            } 
            else if (strcmp(val, "FALSE") == 0
                    || strcmp(val, "NO") == 0
                    || strcmp(val, "0") == 0   ) {
                *p_bool_setting->p_variable = false;
            } else {
                fprintf(stderr, "bad bool value in config file for: %s\n", key);
                exit(EXIT_FAILURE);
            }
            return ;
        }
        ++p_bool_setting;
    }


    //整数配置选项读取
    //遍历unint表中的配置选项
    const struct parseconf_uint_setting *p_uint_setting = parseconf_uint_array;

    while (p_uint_setting->p_setting_name != NULL) {
        if (strcmp(p_uint_setting->p_setting_name, key) == 0) {
            if (val[0] == '0')
                *(p_uint_setting->p_variable) = str_octal_to_uint(val);
            else
                *(p_uint_setting->p_variable) = atoi(val);
            return ;
        }
        ++p_uint_setting;
    }
    
}

3.3用户登录验证

当客户端建立控制连接后，要进行用户登录验证，先确定用户是否存在，然后确定密码是否正确，流程如下：

服务进程在接收到USER命令之后解析出用户名，根据用户名，通过getpwnam获取用户的相关信息，如果用户不存在getpwnam返回NULL，如果用户存在，保存uid，以便下面进行密码验证：

static void do_user(session_t *sess)
{
    //命令响应  后面记得加上\r\n   330后面记得加上空格
    struct passwd *pw;
    pw = getpwnam(sess->arg); //根据用户名获取密码信息结构体 与/etc/passwd对应
    if (pw == NULL) {  //用户不存在
        ftp_relply(sess, FTP_LOGINERR, "user not exist.");
        return ;
    }
    sess->uid = pw->pw_uid;
    ftp_relply(sess, FTP_GIVEPWORD, "Please specify the password");
}

接下来就是密码的验证了！！！

用户存在后，客户端会发送密码，此时进入do_pass操作函数，但是！！！这里解析出来的只是密码，并没有说明是哪一个用户的！！！

这时候就用到上面放在sess中的uid了，通过sess的uid就可以锁定用户，进行密码验证了。getpwuid函数可以通过uid获取passwd结构体，在passwd结构体中包含如下信息：

struct passwd {
               char   *pw_name;       /* username */
               char   *pw_passwd;     /* user password */
               uid_t   pw_uid;        /* user ID */
               gid_t   pw_gid;        /* group ID */
               char   *pw_gecos;      /* user information */
               char   *pw_dir;        /* home directory */
               char   *pw_shell;      /* shell program */
           };

可以看到结构体中有pw_passwd，那意味着直接比较解析出来的密码与pw_passwd吗？？？

不是的，实际密码是经过加密放在影子文件中的，可以通过getspnam来获取影子文件的相关信息（root用户），其函数声明如下：

#include <shadow.h>
struct spwd *getspnam(const char *name);
struct spwd {
    char *sp_namp;     /* Login name */
    char *sp_pwdp;     /* Encrypted password */
    long  sp_lstchg;   /* Date of last change(measured in days since1970-01-01 00:00:00 +0000 (UTC)) */
    long  sp_min;      /* Min # of days between changes */
    long  sp_max;      /* Max # of days between changes */
    long  sp_warn;     /* # of days before password expires to warn user to change it */
    long  sp_inact;    /* # of days after password expires until account is disabled */
    long  sp_expire;   /* Date when account expires (measured in days since 970-01-01 00:00:00 +0000 (UTC)) */
    unsigned long sp_flag;  /* Reserved */
};

加密后的密码放在sp_pwdp中，我们只需要将解析出来的密码进行加密，然后与sp_pwdp比较就可以知道密码是否正确了，通过crypt函数对密码进行加密，函数原型如下，使用crypt函数之后要在链接的时候加上-lcrypt：

char *crypt(const char *key, const char *salt);
//crypt()算法会接受一个最长可达8字符的密钥(即key)，并施以数据加密算法(DES)的一种变体。salt参数指向一个两个字符的字符串，
//用来改变DES算法。该函数返回一个指针，指向长度13个字符的字符串

char* encrypted_pass = crypt(sess->arg, sp->sp_pwdp); //获取加密后的密码

通过比较加密获得的密码，与影子文件中的密码，就可以知道密码是否正确。

完整的验证过程如下：

static void do_pass(session_t *sess)
{
    struct passwd *pw; 
    struct spwd *sp;
    pw = getpwuid(sess->uid);
    if (pw == NULL) {  //用户不存在
        ftp_relply(sess, FTP_LOGINERR, "user not exist.");
        return ;
    }
    //实际密码是保存在影子文件中，getspnam 可以根据用户名获取影子文件信息
    //如下的操作只有root才可以，一般用户会返回NULL，所以在session中只将nobody进程中才设置uid
    sp = getspnam(pw->pw_name);
    if (sp == NULL) {
        ftp_relply(sess, FTP_LOGINERR, "user not exist.");  //首次运行的时候出错
        return ;
    }

    //影子文件中的密码是加密之后的，所以要将明文密码进行加密，与影子文件中加密密码比较使用crypt()函数
    //char *crypt(const char *key, const char *salt); 第一个参数是明文，第二个参数是种子(也就是加密过的密码)
    char* encrypted_pass = crypt(sess->arg, sp->sp_pwdp);  //链接的时候-lcrypt
    if (strcmp(encrypted_pass, sp->sp_pwdp) == 0)  {  //密码正确
        signal(SIGURG, handle_sigurg);
        activate_sigurg(sess->ctl_fd);  //开启接收信号

        //验证之后，此时进程拥有者是root 要将进程转交给登录的用户
        umask(tunable_local_umask);
        setegid(pw->pw_gid);
        seteuid(pw->pw_uid);
        chdir(pw->pw_dir);
        ftp_relply(sess, FTP_LOGINOK, "Login successful.");
    } else {
        ftp_relply(sess, FTP_LOGINERR, "err password.");
    }
}

验证成功之后，此时的服务进程还是属于root用户，我们需要将进程转交给登录的用户，即改变进程的uid、gid，将工作目录移动到当前用户目录。

3.4 nobody进程与服务进程的内部通信

nobody进程与服务进程之间通过socketpair产生的socket进行通信，如下：

// 内部进程自定义协议
// 用于FTP服务进程和nobody进程进行通信
//主要用于PASV模式下绑定20端口  和PORT模式下获取数据连接套接字

// FTP服务进程向nobody进程请求的命令
#define PRIV_SOCK_GET_DATA_SOCK    1
#define PRIV_SOCK_PASV_ACTIVE    2
#define PRIV_SOCK_PASV_LISTEN    3
#define PRIV_SOCK_PASV_ACCEPT    4

// nobody进程对FTP服务进程的应答
#define PRIV_SOCK_RESULT_OK    1
#define PRIV_SOCK_RESULT_BAD    2

void priv_sock_init(session_t *sess);
void priv_sock_close(session_t *sess);
void priv_sock_set_parent_context(session_t *sess);
void priv_sock_set_child_context(session_t *sess);

//其中cmd就是上面的宏定义 nobody进程与服务进程之间就通过下面的函数通信 
void priv_sock_send_cmd(int fd, char cmd);    
char priv_sock_get_cmd(int fd);               
void priv_sock_send_result(int fd, char res);  
char priv_sock_get_result(int fd);           

void priv_sock_send_int(int fd, int the_int);
int priv_sock_get_int(int fd);
void priv_sock_send_buf(int fd, const char *buf, unsigned int len);
void priv_sock_recv_buf(int fd, char *buf, unsigned int len);
void priv_sock_send_fd(int sock_fd, int fd);
int priv_sock_recv_fd(int sock_fd);

内部通信初始化就是创建一对socket然后分配给sess，父子进程要分别关闭对方的socket：

void priv_sock_init(session_t *sess)
{
    int sockfds[2];  //分别是父、子进程用到的socketfd

    if (socketpair(AF_UNIX, SOCK_STREAM, 0, sockfds) < 0)
        ERR_EXIT("session socketpair");
    sess->parent_fd = sockfds[0];
    sess->child_fd = sockfds[1];
}

nobody进程执行handle_parent函数来不断接收服务进程的消息：

void handle_parent(session_t *sess)
{
    char cmd;

    /* 以root用户启动的时候 gid、uid都是0，所以要获取用户登录相关信息 */
    struct passwd *pw = getpwnam("nobody");  //获取用户登录相关信息
    if (setegid(pw->pw_gid) < 0) ERR_EXIT("session setegid");  //先设置组ID，然后设置用户ID
    if (seteuid(pw->pw_uid) < 0) ERR_EXIT("session seteuid");

    minimize_privilege();  //获取绑定20端口权限

    while (1) {
        //从服务进程读取信息，这里的命令不是FTP标准命令，而是内部命令，nobody进程与客户端之间才是FTP标准命令
        // read(sess->parent_fd, &cmd, 1);
        cmd = priv_sock_get_cmd(sess->parent_fd);  
        //解析FTP内部命令参数
        switch (cmd)
        {
        case PRIV_SOCK_GET_DATA_SOCK:
            privop_pasv_get_data_sock(sess);
            break;

        case PRIV_SOCK_PASV_ACTIVE:
            privop_pasv_active(sess);
            break;

        case PRIV_SOCK_PASV_LISTEN:
            privop_pasv_listen(sess);
            break;

        case PRIV_SOCK_PASV_ACCEPT:
            privop_pasv_accept(sess);
            break;

        default:
            break;
        }
    }
}