• Home
  • Categories
  • WIKI
  • LANGUAGE: en
    • 自己动手写ftp服务器4(上传下载)
    社区开发 1374 views · 0 replies ·
    Tofloor
    poster avatar
    zhqh100
    deepin
    2014-05-02 07:24
    Author
    LIST已经实现了，后面实现ftp服务器的最核心功能——上传下载！
    (当然，最大的bug是不支持中文，暂时也没考虑去解决此问题)

    开发语言：C语言
    操作系统：LinuxDeepin 2013
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8. #include
    9. #include
    10. #include
    11. #include
    12. #include
    13. #include
    14. #include
    15. #define bool unsigned short
    17. typedef struct cmd_opts {
    18.         bool daemonize;
    19.         bool listen_any;
    20.         char *listen_addr;
    21.         int port;
    22.         int max_conn;
    23.         int userid;
    24.         char *chrootdir;
    25. }cmd_opts;
    27. //格式化字符串line
    28. static int write_file(char *line,const char *mode,int num,const char *user,const char * group,int size,const char *date,const char*fl_name) {
    29.         sprintf(line,"%s %3d %-4s %-4s %8d %12s %s\r\n",mode,num,user,group,size,date,fl_name);
    30.         return 0;
    31. }
    33. //判断字符是否是以某指令开始
    34. int strBeginWith(char *str,char *substr){
    35.         while(*str && *substr && *str==*substr){
    36.                 str++;
    37.                 substr++;
    38.         }
    39.         if(*substr=='\0')
    40.                 return 1;
    41.         else
    42.                 return 0;
    43. }
    45. //字符串转int
    46. int toint(char *str) {
    47.         if (strlen(str) < 1)
    48.         {
    49.                 return -1;
    50.         }
    51.         int retVal = str[0] - '0';
    52.         int i = 1;
    53.         while(str[i] >= '0' && str[i] <= '9')
    54.         {
    55.                 retVal = retVal * 10 + str[i] - '0';
    56.                 i++;
    57.         }
    58.         return retVal;
    59. }
    61. //向客户端发送消息
    62. int send_repl(int send_sock,char *msg) {
    63.         printf("Send Message:%s\n", msg);
    64.         if (send(send_sock, msg, strlen(msg),0) < 0) {
    65.                 perror("send");
    66.                 close(send_sock);
    67.                 return -1;
    68.         }
    69.         return 0;
    70. }
    73. //创建数据传输的连接，用于处理"LIST","STOR","RETR"等请求
    74. int make_client_connection(int client_port,const char* client_addr) {
    75.    int sock=-1;
    77.    struct sockaddr_in servaddr;
    78.    servaddr.sin_family = AF_INET;
    79.    servaddr.sin_addr.s_addr = inet_addr(client_addr);
    80.    servaddr.sin_port = htons (client_port);
    82.    if ((sock = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
    83.       send_repl(sock,"425 Can't open data connection.\r\n");
    84.       perror("socket");
    85.       return -1;
    86.    }
    87.    int status = connect (sock, (struct sockaddr *)&servaddr, sizeof (servaddr));
    89.    if(status!=0) {
    90.       send_repl(sock,"425 Can't open data connection.\r\n");
    91.       perror("connect");
    92.       return -1;
    93.    }
    94.    return sock;
    95. }
    97. //zhqh100@gmail.com
    98. enum {
    99.         TRUE=1,
    100.         FALSE=0
    101. };
    103. int main(int argc,char *argv[])
    104. {
    105.         struct cmd_opts *opts= malloc(sizeof(struct cmd_opts));
    107.    //设置一些初始配置
    108.         opts->daemonize    = FALSE;
    109.         opts->listen_any   = TRUE;
    110.         opts->port         = 21;
    111.         opts->userid       = 0;
    112.         opts->chrootdir    = "./";
    113.         opts->max_conn     = 5;
    114.         opts->listen_addr  = NULL;
    115.         struct sockaddr_in servaddr;
    116.         memset((char *)&servaddr, 0, sizeof(servaddr));
    117.    //TCP协议
    118.         servaddr.sin_family = PF_INET;
    119.         servaddr.sin_addr.s_addr =  htonl(INADDR_ANY);
    120.         servaddr.sin_port = htons (opts->port);
    122.         int servaddr_len = sizeof(servaddr);
    123.         int sock;
    124.         if ((sock = socket (PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
    125.                 perror("socket");
    126.                 return -1;
    127.         }
    128.         int flag = 1;
    129.         setsockopt(sock, SOL_SOCKET,SO_REUSEADDR,(char *) &flag, sizeof(int));
    130.        
    131.         setsockopt(sock, IPPROTO_TCP,TCP_NODELAY,(char *) &flag, sizeof(int));
    133.    //套接字绑定端口和地址
    134.         if(bind (sock, (struct sockaddr *)&servaddr, sizeof(servaddr))<0) {
    135.                 perror("bind");
    136.                 return -1;
    137.         }
    139.         if(listen(sock,opts->max_conn) <0) {
    140.                 perror("listen");
    141.                 return -1;
    142.         }
    143.         int connection;
    144.         struct stat *s_buff = malloc(sizeof(struct stat));
    145.         char mode[11]        = "----------";
    146.         char date[16];
    147.         struct passwd * pass_info = NULL;
    148.         struct group * group_info;
    149.         struct dirent *d_next;
    150.         char line[300];
    151.         DIR *dir;
    152.         //传输类型
    153.         int type;
    154.         //文件指针
    155.         int fpr;
    156.         //长度
    157.         int len;
    158.         //死循环等待客户端连接
    159.         while(1){
    160.                 printf("Begin to accept\n");
    161.                 if ((connection = accept(sock, (struct sockaddr *) &servaddr, &servaddr_len)) < 0) {
    162.                         perror("accept");
    163.                         return -1;
    164.                 }
    166.                 int pid = fork();
    167.                 char msg[]= "220 Service ready for new user.\r\n";
    168.                 char send_buff[1000];
    169.                 char read_buff[1000];
    170.                 char current_dir[1000];
    171.                 //客户端IP地址和端口号
    172.                 char client_addr[16];
    173.                 int client_port;
    174.                 //临时指针
    175.                 char *temp;
    176.                 int i;
    177.                 int client_fd;
    178.                 strcpy(current_dir,opts->chrootdir);
    180.                 //获取当前绝对路径
    181.                 getcwd(current_dir,sizeof(current_dir));
    183.                 len = strlen(msg);
    184.                 if(pid==0) {
    185.          //客户端连接后，服务器先主动发送200 Service ready
    186.                         if (send(connection, msg, len,0) < 0) {
    187.                                 perror("send");
    188.                                 close(connection);
    189.                                 return -1;
    190.                         }
    191.                         while(1){
    192.             //初始化读取buffer和发送buffer
    193.                                 memset(send_buff,0,sizeof(send_buff));
    194.                                 memset(read_buff,0,sizeof(read_buff));
    195.             //等待接收客户端指令
    196.                                 int recvbuff = recv(connection,read_buff,sizeof(read_buff),0);
    197.                                 if(recvbuff<1) {
    198.                                         return -1;
    199.                                 }
    200.                                 if(recvbuff==sizeof(read_buff)) {
    201.                                         return -2;
    202.                                 }
    203.                                 printf("Received:%s",read_buff);
    204.                                 if (strBeginWith(read_buff,"USER")){
    205.                                         //收到客户端发送的用户名，这里不处理用户名，均答复登陆成功
    206.                                         //注释代码也可用，只是这里修改后，发送的消息更精简了
    207.                                         //后面的人性化提示可以省略，但\r\n不可省略，经Filezilla和 CuteFTP客户端验证，必须把\r\n带上才可正常识别
    208.                                         // if (send_repl(connection, "331 Anonymous login okay, send your complete email as your password.\r\n") < 0)
    209.                                         if(send_repl(connection,"331 Anonymous\r\n") < 0)
    210.                                                 return -1;
    211.                                 }else if(strBeginWith(read_buff,"PASS")){
    212.                                         //可以看到ftp协议发送的密码均为明文发送
    213.                                         //这里不做密码校验，均答复已登录
    214.                                         // if (send_repl(connection, "230 User logged in, proceed.\r\n") < 0)
    215.                                         if (send_repl(connection, "230 User\r\n") < 0)
    216.                                                 return -1;
    217.                                 }else if (strBeginWith(read_buff,"SYST")){
    218.                                         //问操作系统类型
    219.                                         //下面UNIX的可替代选项参考 http://www.iana.org/assignments/operating-system-names/operating-system-names.xhtml
    220.                                         if (send_repl(connection, "215 UNIX\r\n") < 0)
    221.                                                 return -1;
    222.                                 }else if (strBeginWith(read_buff,"PWD")){
    223.                                         //当前路径
    224.                                         sprintf(send_buff,"257 %s\r\n",current_dir);
    225.                                         if (send_repl(connection, send_buff) < 0)
    226.                                                 return -1;
    227.                                 }else if (strBeginWith(read_buff,"PORT")){
    228.                                         //客户端发来的IP和端口号
    229.                                         char *temp = strtok(read_buff + 5,",");
    230.                                         strcpy(client_addr, temp);
    231.                                         for (i = 0; i < 3; ++i)
    232.                                         {
    233.                                                 strcat(client_addr, ".");
    234.                                                 temp = strtok(NULL, ",");
    235.                                                 strcat(client_addr, temp);
    236.                                         }
    237.                                         printf("client_addr = %s\n", client_addr);
    238.                                         temp = strtok(NULL, ",");
    239.                                         client_port = toint(temp);
    240.                                         temp = strtok(NULL, ",");
    241.                                         client_port = client_port * 256 + toint(temp);
    242.                                         printf("client_port = %d\n", client_port);
    243.                                         //回复传说中的200 OK
    244.                                         if (send_repl(connection, "200 \r\n") < 0)
    245.                                                 return -1;
    246.                                 }else if (strBeginWith(read_buff,"LIST")){
    247.                                         //列出当前路径的所有文件
    248.                                         client_fd = make_client_connection(client_port, client_addr);
    249.                                         if (client_fd != -1){
    250.                                                 dir = opendir(current_dir);
    251.                                                 if(send_repl(connection,"150 File status okay; about to open data connection.\r\n") < 0)
    252.                                                         return -1;
    253.                                                 while(1) {
    254.                                                         d_next = readdir(dir);
    255.                                                         if(d_next==NULL)
    256.                                                                 break;
    257.                                                         line[0]='\0';
    258.                                                         stat(d_next->d_name,s_buff);
    259.                      int b_mask = s_buff->st_mode & S_IFMT;
    260.                      //判断是文件还是文件夹
    261.                      if(b_mask == S_IFDIR) {
    262.                         mode[0]='d';
    263.                      } else if(b_mask == S_IFREG){
    264.                         mode[0]='-';
    265.                      } else {
    266.                         return FALSE;
    267.                      }
    268.                                                         mode[1] = (s_buff->st_mode & S_IRUSR)?'r':'-';
    269.                                                         mode[2] = (s_buff->st_mode & S_IWUSR)?'w':'-';
    270.                                                         mode[3] = (s_buff->st_mode & S_IXUSR)?'x':'-';
    271.                                                         mode[4] = (s_buff->st_mode & S_IRGRP)?'r':'-';
    272.                                                         mode[5] = (s_buff->st_mode & S_IWGRP)?'w':'-';
    273.                                                         mode[6] = (s_buff->st_mode & S_IXGRP)?'x':'-';
    274.                                                         mode[7] = (s_buff->st_mode & S_IROTH)?'r':'-';
    275.                                                         mode[8] = (s_buff->st_mode & S_IWOTH)?'w':'-';
    276.                                                         mode[9] = (s_buff->st_mode & S_IXOTH)?'x':'-';
    278.                                                         strftime(date,13,"%b %d %H:%M",localtime(&(s_buff->st_mtime)));
    279.                                                         pass_info = getpwuid(s_buff->st_uid);
    280.                                                         group_info = getgrgid(s_buff->st_gid);
    281.                                                         write_file(line,mode,s_buff->st_nlink,pass_info->pw_name,group_info->gr_name,s_buff->st_size,date,d_next->d_name);
    282.                                                         printf("line = %s\n", line);
    283.                                                         send(client_fd,line,strlen(line),0);
    284.                                                 }
    285.                                                 close(client_fd);
    286.                                                 if(send_repl(connection,"226 Closing data connection.\r\n"))
    287.                                                         return -1;
    288.                                                 closedir(dir);
    289.                                                 client_fd = -1;
    290.                                         }
    291.                                 }else if(strBeginWith(read_buff,"TYPE")){
    292.                                         switch(read_buff[5]){
    293.                                                 //type A Ascii文件流，type I，二进制文件流
    294.                                                 case 'I':
    295.                                                         if (send_repl(connection, "200 \r\n") < 0)
    296.                                                                 return -1;
    297.                                                         type = 1;break;
    298.                                                 case 'A':
    299.                                                         if (send_repl(connection, "200 \r\n") < 0)
    300.                                                                 return -1;
    301.                                                         type = 2;break;
    302.                                                 case 'L':printf("get TYPE L,need to handle the request");break;
    303.                                                 default: break;
    304.                                         }
    305.                                 }else if(strBeginWith(read_buff,"RETR")){
    306.                                         client_fd = make_client_connection(client_port,client_addr);
    307.                                         if(send_repl(connection,"150 File status okay; about to open data connection.\r\n") < 0)
    308.                                                         return -1;
    309.                                         temp = read_buff+5;//filename
    310.                                         //我原以为temp就是文件名，实际却是客户端发过来的数据会在可见字符后面跟一堆不可见字符，所以需要进行处理
    311.                                         //这里进行简单粗暴的处理，会造成无法接收中文文件的传输
    312.                                         i = 0;
    313.                                         while(1){
    314.                                                 if(temp[i] < ' ' | temp[i] > '~'){
    315.                                                         temp[i] = '\0';
    316.                                                         break;
    317.                                                 }
    318.                                                 i++;
    319.                                         }
    321.                                         fpr = open(temp,O_RDONLY);
    322.                                         if (fpr < 0)
    323.                                         {
    324.                                                 perror("open");
    325.                                                 return -1;
    326.                                         }
    327.                                         while(1){
    328.                                                 len = read(fpr,send_buff,sizeof(send_buff));
    329.                                                 if(len>0) {
    330.                                                         send(client_fd,send_buff,len,0);
    331.                                                 }
    332.                                                 else {
    333.                                                         break;
    334.                                                 }
    335.                                         }
    336.                                         close(fpr);
    337.                                         send_repl(connection,"226 Closing data connection.\r\n");
    338.                                         close(client_fd);
    339.                                 }else if(strBeginWith(read_buff,"STOR")){
    340.                                         client_fd = make_client_connection(client_port,client_addr);
    341.                                         if(send_repl(connection,"150 File status okay; about to open data connection.\r\n") < 0)
    342.                                                         return -1;
    343.                                         temp = read_buff+5;//filename
    344.                                         i = 0;
    345.                                         while(1){
    346.                                                 if(temp[i] < ' ' | temp[i] > '~'){
    347.                                                         temp[i] = '\0';
    348.                                                         break;
    349.                                                 }
    350.                                                 i++;
    351.                                         }
    353.                                         fpr = open(temp,O_WRONLY|O_CREAT,0644);
    354.                                         if (fpr < 0)
    355.                                         {
    356.                                                 perror(temp);
    357.                                                 return -1;
    358.                                         }
    359.                                         while(1){
    360.                                                 len = recv(client_fd,read_buff,sizeof(read_buff),0);
    361.                                                 if(len>0) {
    362.                                                         write(fpr,read_buff,len);
    363.                                                 }
    364.                                                 else {
    365.                                                         break;
    366.                                                 }
    367.                                         }
    368.                                         close(fpr);
    369.                                         send_repl(connection,"226 Closing data connection.\r\n");
    370.                                         close(client_fd);
    371.                                 }else{
    372.                                         //其他一律回复500,I don't know
    373.                                         if (send_repl(connection, "500 \r\n") < 0)
    374.                                                 return -1;
    375.                                 }
    376.                         }
    377.                 } else if(pid>0) {
    378.                         close(connection);
    379.                 }
    380.         }
    382.         return 0;
    383.        
    384. }
    Copy the Code

    可以上传一个大文件进行测试，如上传一个大的视频文件，如果上传后视频打开画面和本地画面一致，就证明功能实现正常。

    不上传图片了
    Reply Favorite View the author
    All Replies

    No replies yet