• Home
  • Categories
  • WIKI
  • LANGUAGE: en
    • 自己动手写ftp服务器5(到此为止)
    社区开发 2057 views · 2 replies ·
    Tofloor
    poster avatar
    zhqh100
    deepin
    2014-05-04 05:45
    Author
    实现了上传下载，我计划的功能也就实现了，本节稍微实现一下FTP无法缺少的删除和切换路径的功能，再进一步的功能如重命名、复制粘贴等功能各位可以直接看tinyftp的源代码。

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

    ftp就先研究到这里，接下来开始学习http的源码，可能的话后面再发一些心得
    Reply Favorite View the author
    All Replies
    yeser
    deepin
    2014-05-05 06:33
    #1
    虽一点不懂，但看看行数不多，觉得不难，呵呵!
    Reply View the author
    键盘机
    deepin
    2014-07-29 22:52
    #2
    马克一下
    Reply View the author