FTP 代理服務器實現

本文將在Linux環境下實現一個簡單的FTP代理服務器，主要內容涉及FTP主動/被動模式和簡單的Socket編程。

1. 主動模式和被動模式

FTP有兩種模式，即主動模式（Active Mode）和被動模式（Passive Mode），主要區別在誰在監聽數據端口。

1.1 主動模式

FTP服務器在開啟后一直在監聽21號端口等待客戶端通過任意端口進行連接，客戶端通過任意端口port1連接服務器21號端口成功后，服務器通過該命令套接字發送各種FTP命令（CD、DIR、QUIT...)。當要發送的命令涉及到數據傳輸的時候，服務器和客戶端間就要開啟數據通道，如果此時客戶端處於主動模式時，客戶端開啟並監聽一個大於1024的隨機端口port2，並通過命令套接字向服務器發送PORT命令通告客戶端處於主動模式且正在監聽port2。服務器在收到客戶端的PORT命令后，使用端口20連接客戶端port2（數據端口使用20只是個慣例，其實不適用影響不大），並完成數據傳輸。

PORT命令的格式為” PORT 223,3,123,41,99,165 “，指示客戶端ip為223.3.123.41，客戶端開啟的隨機端口port2 = 99 * 265 + 165 = 26400，在服務器返回200 PORT command successful之后，客戶端才發送獲取文件命令RETR。

1.2 主動模式的缺陷

從1.1中可以看出FTP在采取主動模式時，客戶端需要主動監聽一個大於1024的隨機端口，而一般客戶端的防火牆不會開放對這樣一個端口的連接。

1.3 被動模式

為了給客戶端帶來方便，FTP被動模式下，客戶端發送Request: Pasv命令，服務器在接收到命令后，主動開啟一個大於1024的端口port並發送響應Response: 227 Entering Passive Mode(...)，客戶端主動發起連接到服務器的port，並完成數據傳輸。在被動模式下客戶端不需要監聽任何端口，因此在客戶端存在某些防火牆規則的情況下會更加適合。

2. FTP代理服務器架構

1. FTP代理服務器監聽套接字proxy_cmd_socket監聽21號端口，當客戶端連接時，得到accept_cmd_socket，proxy主連接服務器21號端口得到connect_cmd_socket，proxy轉發accept_cmd_socket和connect_cmd_socket之間除了情況2和情況3的通信。

2. 當處於主動模式下客戶通過accept_cmd_socket發送PORT命令時，proxy需要把PORT命令的ip換成proxy的外網ip（指server看到的proxy的ip），並隨機監聽一個大於1024的端口port1，把PORT命令中的端口port改為port1。

3. 當處於被動模式下服務器響應客戶端的Response: 227....命令時，proxy需要把Response中的ip換成proxy的內網ip（指client看到的proxy的ip），並隨機監聽一個大於1024的端口port2，把Response中的端口port改為port2。

4. 當處於主動模式下，服務器收到proxy修改過的PORT命令，會主動連接proxy的端口port1得到accept_data_socket，proxy主動連接客戶端的port端口得到proxy_connect_socket，proxy轉發accept_data_socket_socket和proxy_connect_socket間的通信。

5. 當處於被動模式下，客戶端收到proxy修改過的Response： 227...后，會連接proxy的端口port2得到accept_data_socket，proxy連接服務器的port端口得到proxy_connect_socket，proxy轉發accept_data_socket_socket和proxy_connect_socket間的通信。

 

 3. FTP代理服務器實現

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#include <arpa/inet.h>
#include <string.h>
#include <ctype.h>


#define TRUE 1
#define FALSE 0

#define CMD_PORT 21
#define BUFFSIZE 4096
#define LISTENQ 5


int acceptSocket(int socket,struct sockaddr *addr,socklen_t *addrlen);
int connectToServerByAddr(struct sockaddr_in servaddr);
int connectToServer(char *ip,unsigned short port);
int bindAndListenSocket(unsigned short port);
void splitCmd(char *buff, char **cmd,char **param);
unsigned short getPortFromFtpParam(char *param);
void getSockLocalIp(int fd,char *ipStr,int buffsize);
unsigned short getSockLocalPort(int sockfd);

int main(int argc, const char *argv[])
{
    int i;
    fd_set master_set, working_set;  //文件描述符集合
    struct timeval timeout;          //select 參數中的超時結構體
    int proxy_cmd_socket    = 0;     //proxy listen控制連接
    int accept_cmd_socket   = 0;     //proxy accept客戶端請求的控制連接
    int connect_cmd_socket  = 0;     //proxy connect服務器建立控制連接
    int proxy_data_socket   = 0;     //proxy listen數據連接
    int accept_data_socket  = 0;     //proxy accept得到請求的數據連接（主動模式時accept得到服務器數據連接的請求，被動模式時accept得到客戶端數據連接的請求）
    int connect_data_socket = 0;     //proxy connect建立數據連接 （主動模式時connect客戶端建立數據連接，被動模式時connect服務器端建立數據連接）
    int selectResult = 0;     //select函數返回值
    int select_sd = 10;    //select 函數監聽的最大文件描述符
    int pasv_mode = 1;

    char serverProxyIp[BUFFSIZE];    //待獲得
    char clientProxyIp[BUFFSIZE];    //待獲得 serverProxyIp和clientProxyIp可能不一樣
    char serverIp[BUFFSIZE];

    unsigned short proxy_data_port;
    unsigned short data_port;
    socklen_t clilen;
    struct sockaddr_in cliaddr;

    if(argc != 2){
        printf("usage : proxy server_ip\n example: proxy 121.121.121.121\n");
    }
    strcpy(serverIp,argv[1]);

    
    FD_ZERO(&master_set);   //清空master_set集合
    bzero(&timeout, sizeof(timeout));
    
    proxy_cmd_socket = bindAndListenSocket(CMD_PORT);  //開啟proxy_cmd_socket、bind（）、listen操作
    FD_SET(proxy_cmd_socket, &master_set);  //將proxy_cmd_socket加入master_set集合
    
    while (TRUE) {
        FD_ZERO(&working_set); //清空working_set文件描述符集合
        memcpy(&working_set, &master_set, sizeof(master_set)); //將master_set集合copy到working_set集合
        timeout.tv_sec = 60;    //Select的超時結束時間
        timeout.tv_usec = 0;    //ms
        
        //select循環監聽 這里只對讀操作的變化進行監聽（working_set為監視讀操作描述符所建立的集合）,第三和第四個參數的NULL代表不對寫操作、和誤操作進行監聽
        selectResult = select(select_sd, &working_set, NULL, NULL, &timeout);
        
        // fail
        if (selectResult < 0) {
            perror("select() failed\n");
            exit(1);
        }
        
        // timeout
        if (selectResult == 0) {
            printf("select() timed out.\n");
            continue;
        }
        
        // selectResult > 0 時 開啟循環判斷有變化的文件描述符為哪個socket
        for (i = 0; i < select_sd; i++) {
            //判斷變化的文件描述符是否存在於working_set集合
            if (FD_ISSET(i, &working_set)) {
                if (i == proxy_cmd_socket) {

                    accept_cmd_socket = acceptSocket(proxy_cmd_socket,NULL,NULL);  //執行accept操作,建立proxy和客戶端之間的控制連接
                    connect_cmd_socket = connectToServer(serverIp,CMD_PORT); //執行connect操作,建立proxy和服務器端之間的控制連接
                    
                    getSockLocalIp(connect_cmd_socket,serverProxyIp,BUFFSIZE);            //獲取本地ip，格式為port和pasv使用的格式
                    getSockLocalIp(accept_cmd_socket,clientProxyIp,BUFFSIZE);            //獲取本地ip，格式為port和pasv使用的格式
                    printf("proxy ip from server's view : %s\n",serverProxyIp);
                    printf("proxy ip from client's view : %s\n",clientProxyIp);
                    
                    //將新得到的socket加入到master_set結合中
                    FD_SET(accept_cmd_socket, &master_set);
                    FD_SET(connect_cmd_socket, &master_set);
                }
                
                if (i == accept_cmd_socket) {
                    char buff[BUFFSIZE] = {0};
                    char copy[BUFFSIZE] = {0};
                   
                    if (read(i, buff, BUFFSIZE) == 0) {
                        close(i); //如果接收不到內容,則關閉Socket
                        close(connect_cmd_socket);
                        printf("client closed\n");
                        
                        //socket關閉后，使用FD_CLR將關閉的socket從master_set集合中移去,使得select函數不再監聽關閉的socket
                        FD_CLR(i, &master_set);
                        FD_CLR(connect_cmd_socket, &master_set);

                    } else {
                        printf("command received from client : %s\n",buff);
                        char *cmd,*param;
                        strcpy(copy,buff);
                        splitCmd(copy,&cmd,&param); 
                        //如果接收到內容,則對內容進行必要的處理，之后發送給服務器端（寫入connect_cmd_socket）

                        //處理客戶端發給proxy的request，部分命令需要進行處理，如PORT、RETR、STOR                        
                        //PORT
                        //////////////
                        if(strcmp(cmd,"PORT") == 0){                //修改ip & port
                            //在這兒應該讓proxy_data_socket監聽任意端口
                            proxy_data_socket = bindAndListenSocket(0); //開啟proxy_data_socket、bind（）、listen操作
                            proxy_data_port = getSockLocalPort(proxy_data_socket);
                            FD_SET(proxy_data_socket, &master_set);//將proxy_data_socket加入master_set集合
                            pasv_mode = 0;
                            data_port = getPortFromFtpParam(param);
                            bzero(buff,BUFFSIZE);
                            sprintf(buff,"PORT %s,%d,%d\r\n",serverProxyIp,proxy_data_port / 256,proxy_data_port % 256);
                        }
                        
                        //寫入proxy與server建立的cmd連接,除了PORT之外，直接轉發buff內容
                       printf("command sent to server : %s\n",buff);
                       write(connect_cmd_socket, buff, strlen(buff));
                    }
                }
                
                if (i == connect_cmd_socket) {
                  //處理服務器端發給proxy的reply，寫入accept_cmd_socket
                    char buff[BUFFSIZE] = {0};
                    if(read(i,buff,BUFFSIZE) == 0){
                        close(i);
                        close(accept_cmd_socket);
                        FD_CLR(i,&master_set);
                        FD_CLR(accept_cmd_socket,&master_set);
                    }
                    
                      printf("reply received from server : %s\n",buff);
                  //PASV收到的端口 227 （port）        
                  //////////////
                    if(buff[0] == '2' && buff[1] == '2' && buff[2] == '7'){
                        proxy_data_socket = bindAndListenSocket(0); //開啟proxy_data_socket、bind（）、listen操作
                        proxy_data_port = getSockLocalPort(proxy_data_socket);
                        FD_SET(proxy_data_socket, &master_set);//將proxy_data_socket加入master_set集合
                        data_port = getPortFromFtpParam(buff + 27);
                        bzero(buff + 27,BUFFSIZE - 27);
                        sprintf(buff + 27,"%s,%d,%d).\r\n",clientProxyIp,proxy_data_port / 256,proxy_data_port % 256);
                    }
                      printf("reply sent to client : %s\n",buff);

                    write(accept_cmd_socket,buff,strlen(buff));
                }
                
                if (i == proxy_data_socket) {
                    if(pasv_mode){            //clinet connect
                        accept_data_socket = acceptSocket(proxy_data_socket,NULL,NULL);        //client <-> proxy
                        connect_data_socket = connectToServer(serverIp,data_port);        //proxy <-> server
                    }
                    else{    //主動模式
                        accept_data_socket = acceptSocket(proxy_data_socket,NULL,NULL);        //proxy <-> server
                        clilen = sizeof(cliaddr);
                        if(getpeername(accept_cmd_socket,(struct sockaddr *)&cliaddr,&clilen) < 0){
                            perror("getpeername() failed: ");
                        }
                        cliaddr.sin_port = htons(data_port);
                        connect_data_socket = connectToServerByAddr(cliaddr);        //client <-> proxy
                    }

                    FD_SET(accept_data_socket, &master_set);
                    FD_SET(connect_data_socket, &master_set);
                    printf("data connectiong established\n");
                  //建立data連接(accept_data_socket、connect_data_socket)
                }
                
                if (i == accept_data_socket) {

                    int n;
                    char buff[BUFFSIZE] = {0};
                    if((n = read(accept_data_socket,buff,BUFFSIZE)) == 0){
                        close(accept_data_socket);
                        close(connect_data_socket);
                        close(proxy_data_socket);
                        FD_CLR(proxy_data_socket,&master_set);
                        FD_CLR(accept_data_socket, &master_set);
                        FD_CLR(connect_data_socket, &master_set);
                    }
                    else{
                        write(connect_data_socket,buff,n);
                    }
            

                    //判斷主被動和傳輸方式（上傳、下載）決定如何傳輸數據
                }
                
                if (i == connect_data_socket) {
                    int n;
                    char buff[BUFFSIZE] = {0};
                    if((n = read(connect_data_socket,buff,BUFFSIZE)) == 0){
                        close(accept_data_socket);
                        close(connect_data_socket);
                        close(proxy_data_socket);
                        FD_CLR(proxy_data_socket,&master_set);
                        FD_CLR(accept_data_socket, &master_set);
                        FD_CLR(connect_data_socket, &master_set);
                    }
                    else{
                        write(accept_data_socket,buff,n);
                    }
                    //判斷主被動和傳輸方式（上傳、下載）決定如何傳輸數據
                }
            }
        }
    }
    
    return 0;
}

unsigned short getSockLocalPort(int sockfd)
{
    struct sockaddr_in addr;
    socklen_t addrlen;
    addrlen = sizeof(addr);

    if(getsockname(sockfd,(struct sockaddr *)&addr,&addrlen) < 0){
        perror("getsockname() failed: ");
        exit(1);
    }

    return ntohs(addr.sin_port);
}


void getSockLocalIp(int fd,char *ipStr,int buffsize)
{

    bzero(ipStr,buffsize);

    struct sockaddr_in addr;
    socklen_t addrlen;
    addrlen = sizeof(addr);

    if(getsockname(fd,(struct sockaddr *)&addr,&addrlen) < 0){
        perror("getsockname() failed: ");
        exit(1);
    }

    inet_ntop(AF_INET,&addr.sin_addr,ipStr,addrlen);

    char *p = ipStr;
    while(*p){
        if(*p == '.') *p = ',';
        p++;
    }
}

unsigned short getPortFromFtpParam(char *param)
{
    unsigned short port,t;
    int count = 0;
    char *p = param;    

    while(count < 4){
        if(*(p++) == ','){
            count++;
        }
    }

    sscanf(p,"%hu",&port);
    while(*p != ',' && *p != '\r' && *p != ')') p++;
    if(*p == ','){
        p++;
        sscanf(p,"%hu",&t);
        port = port * 256 + t;
    }

    return port;
}

//從FTP命令行中解析出命令和參數
void splitCmd(char *buff, char **cmd,char **param)
{
    int i;
    char *p;

    while((p = &buff[strlen(buff) - 1]) && (*p == '\r' || *p == '\n')) *p = 0;

    p = strchr(buff,' ');
    *cmd = buff;

    if(!p){
        *param = NULL;
    }else{
        *p = 0;
        *param = p + 1;
    }

    for(i = 0;i < strlen(*cmd);i++){
        (*cmd)[i] = toupper((*cmd)[i]);
    }
}


int acceptSocket(int cmd_socket,struct sockaddr *addr,socklen_t *addrlen)
{
    int fd = accept(cmd_socket,addr,addrlen);
    if(fd < 1){
        perror("accept() failed:");
        exit(1);
    }

    return fd;
}


int connectToServerByAddr(struct sockaddr_in servaddr)
{
    int fd;

    struct sockaddr_in cliaddr;
    bzero(&cliaddr,sizeof(cliaddr));
    cliaddr.sin_family = AF_INET;
    cliaddr.sin_addr.s_addr = htonl(INADDR_ANY);    
    //cliaddr.sin_port = htons(20);

    fd = socket(AF_INET,SOCK_STREAM,0);
    if(fd < 0){
        perror("socket() failed :");
        exit(1);
    }

    if(bind(fd,(struct sockaddr *)&cliaddr,sizeof(cliaddr) ) < 0){
        perror("bind() failed :");
        exit(1);
    }

    servaddr.sin_family = AF_INET;
    if(connect(fd,(struct sockaddr *)&servaddr,sizeof(servaddr)) < 0){
        perror("connect() failed :");
        exit(1);
    }

    return fd;
}


int connectToServer(char *ip,unsigned short port)
{
    int fd;
    struct sockaddr_in servaddr;

    bzero(&servaddr,sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(port);
    inet_pton(AF_INET,ip,&servaddr.sin_addr);

    fd = socket(AF_INET,SOCK_STREAM,0);
    if(fd < 0){
        perror("socket() failed :");
        exit(1);
    }

    if(connect(fd,(struct sockaddr *)&servaddr,sizeof(servaddr)) < 0){
        perror("connect() failed :");
        exit(1);
    }

    return fd;
}

int bindAndListenSocket(unsigned short port)
{
    int fd;
    struct sockaddr_in addr;

    fd = socket(AF_INET,SOCK_STREAM,0);
    if(fd < 0){
        perror("socket() failed: ");
        exit(1);
    }
    
    bzero(&addr,sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    addr.sin_port = htons(port);

    if(bind(fd,(struct sockaddr*)&addr,sizeof(addr)) < 0){
        perror("bind() failed: ");
        exit(1);
    }

    if(listen(fd,LISTENQ) < 0){
        perror("listen() failed: ");
        exit(1);
    }

    return fd;
}