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    = ;     //proxy listen控制连接
     int accept_cmd_socket   = ;     //proxy accept客户端请求的控制连接
     int connect_cmd_socket  = ;     //proxy connect服务器建立控制连接
     int proxy_data_socket   = ;     //proxy listen数据连接
     int accept_data_socket  = ;     //proxy accept得到请求的数据连接（主动模式时accept得到服务器数据连接的请求，被动模式时accept得到客户端数据连接的请求）
     int connect_data_socket = ;     //proxy connect建立数据连接 （主动模式时connect客户端建立数据连接，被动模式时connect服务器端建立数据连接）
     int selectResult = ;     //select函数返回值
     int select_sd = ;    //select 函数监听的最大文件描述符
     int pasv_mode = ;

     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 != ){
         printf("usage : proxy server_ip\n example: proxy 121.121.121.121\n");
     }
     strcpy(serverIp,argv[]);

     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 = ;    //Select的超时结束时间
         timeout.tv_usec = ;    //ms

         //select循环监听 这里只对读操作的变化进行监听（working_set为监视读操作描述符所建立的集合）,第三和第四个参数的NULL代表不对写操作、和误操作进行监听
         selectResult = select(select_sd, &working_set, NULL, NULL, &timeout);

         // fail
         if (selectResult < ) {
             perror("select() failed\n");
             exit();
         }

         // timeout
         if (selectResult == ) {
             printf("select() timed out.\n");
             continue;
         }

         // selectResult > 0 时 开启循环判断有变化的文件描述符为哪个socket
         for (i = ; 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] = {};
                     char copy[BUFFSIZE] = {};

                     if (read(i, buff, BUFFSIZE) == ) {
                         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") == ){                //修改ip & port
                             //在这儿应该让proxy_data_socket监听任意端口
                             proxy_data_socket = bindAndListenSocket(); //开启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 = ;
                             data_port = getPortFromFtpParam(param);
                             bzero(buff,BUFFSIZE);
                             sprintf(buff,"PORT %s,%d,%d\r\n",serverProxyIp,proxy_data_port / ,proxy_data_port % );
                         }

                         //写入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] = {};
                     if(read(i,buff,BUFFSIZE) == ){
                         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[] == '' && buff[] == '' && buff[] == ''){
                         proxy_data_socket = bindAndListenSocket(); //开启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 + );
                         bzero(buff + ,BUFFSIZE - );
                         sprintf(buff + ,"%s,%d,%d).\r\n",clientProxyIp,proxy_data_port / ,proxy_data_port % );
                     }
                       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) < ){
                             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] = {};
                     if((n = read(accept_data_socket,buff,BUFFSIZE)) == ){
                         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] = {};
                     if((n = read(connect_data_socket,buff,BUFFSIZE)) == ){
                         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 ;
 }

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

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

     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) < ){
         perror("getsockname() failed: ");
         exit();
     }

     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 = ;
     char *p = param;    

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

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

     return port;
 }

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

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

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

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

     for(i = ;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 < ){
         perror("accept() failed:");
         exit();
     }

     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,);
     if(fd < ){
         perror("socket() failed :");
         exit();
     }

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

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

     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,);
     if(fd < ){
         perror("socket() failed :");
         exit();
     }

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

     return fd;
 }

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

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

     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)) < ){
         perror("bind() failed: ");
         exit();
     }

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

     return fd;
 }

proxy.c