[关闭]
@Dubyoo 2014-06-17T21:38:32.000000Z 字数 10373 阅读 2264

2014-06-17 FTP文件服务器（TCP，HTTP）

未分类

参考资料：
深入理解HTTP协议
http://www.blogjava.net/zjusuyong/articles/304788.html

遇到的问题：
客户端获取文件或文件夹时，若文件名中含有空格' '，则发送给服务器的文件名实际上对应的是'%20'，如：

  1. 客户端点击页面上显示的文件名"Ubuntu One"
  2. 实际上服务器获取的URL文件名是"Ubuntu%20One"

原因：
在网络编程中，如果URL参数中含有特殊字符，如空格 ' ' 、 '#' 等
可能导致服务器端无法获得正确的参数值。这些字符被转换为 '%'+ ASCII码的两位16进制表示，如空格的ASCII码是32，即16进制的0x20，因此空格被替换成'%20'。
服务器接收后需要将之转换。

  1. /*************************************************************************
  2.     > File Name: FtpServer.c
  3.     > Author: Dubyoo
  4.     > Mail:wangwei1543@gmail.com 
  5.     > Created Time: Mon 16 Jun 2014 04:42:26 PM CST
  6.  ************************************************************************/
  8. #include <stdarg.h>
  9. #include <errno.h>
  10. #include <fcntl.h>
  11. #include <unistd.h>
  12. #include <string.h>
  13. #include <time.h>
  14. #include <sys/types.h>
  15. #include <sys/stat.h>
  16. #include <dirent.h>
  17. #include <errno.h>
  18. #include <netinet/in.h>
  19. #include <sys/socket.h>
  20. #include <resolv.h>
  21. #include <arpa/inet.h>
  22. #include <stdlib.h>
  23. #include <signal.h>
  24. #include <getopt.h>
  26. #define DEFAULTIP "127.0.0.1"
  27. #define DEFAULTPORT "80"
  28. #define DEFAULTBACK "10"
  29. #define DEFAULTDIR "/home"
  30. #define DEFAULTLOG "/tmp/das-server.log"
  32. void prterrmsg(char *msg);
  33. #define prterrmsg(msg)  { perror(msg);abort(); }
  34. void wrterrmsg(char *msg);
  35. #define wrterrmsg(msg) { fputs(msg, logfp); fputs(strerror(errno),logfp);fflush(logfp); abort(); }
  36. void prtinfomsg(char *msg);
  37. #define prtinfomsg(msg) { fputs(msg, stdout); }
  38. void wrtinfomsg(char *msg);
  39. #define wrtinfomsg(msg) { fputs(msg, logfp); fflush(logfp); }
  40. #define MAXBUF 1024
  41. char buffer[MAXBUF + 1];
  42. char *host = 0;
  43. char *port = 0;
  44. char *back = 0;
  45. char *dirroot = 0;
  46. char *logdir = 0;
  47. unsigned char daemon_y_n = 0;
  48. FILE *logfp;
  49. #define MAXPATH 150
  51. /*-----------------------------------------------
  52.  *--- dir_up - 返回 dirpath 所指目录的上一级目录
  53.  *-----------------------------------------------
  54.  */
  55. char *dir_up(char *dirpath)
  56. {
  57.     static char Path[MAXPATH];
  58.     int len;
  59.     strcpy(Path, dirpath);
  60.     len = strlen(Path);
  61.     if (len > 1 && Path[len - 1] == '/')
  62.         len--;
  63.     while (Path[len - 1] != '/' && len > 1)
  64.         len--;
  65.     if(len > 1)
  66.         len--;
  67.     Path[len] = 0;
  68.     return Path;
  69. }
  71. /*-------------------------------------------------------
  72.  *--- AllocateMemory - 分配空间并把 d 所指的内容复制到 s
  73.  *-------------------------------------------------------
  74.  */
  75. void AllocateMemory(char **s, int l, const char *d)
  76. {
  77.     *s = (char*)malloc(l + 1);
  78.     bzero(*s, l + 1);
  79.     memcpy(*s, d, l);
  80. }
  82. /*------------------------------------------------------
  83.  *--- GiveResponse - 把 Path 所指的内容发送到 client_sock
  84.  *------------------- 如果 Path 是一个目录,则列出目录内容
  85.  *------------------- 如果 Path 是一个文件,则下载文件
  86.  *------------------------------------------------------
  87.  */
  88. void GiveResponse(FILE * client_sock, char *Path)
  89. {
  90.     struct dirent *dirent;
  91.     struct stat info;
  92.     char Filename[MAXPATH];
  93.     DIR *dir;
  94.     int fd, len;
  95.     char *p, *realPath, *realFilename, *nport;
  97.     /* 获得实际工作目录或文件 */
  98.     len = strlen(dirroot) + strlen(Path) + 1;
  99.     realPath = (char*)malloc(len + 1);
  100.     bzero(realPath, len + 1);
  101.     sprintf(realPath, "%s/%s", dirroot, Path);
  103.     /* 获得实际工作端口 */
  104.     len = strlen(port) + 1;
  105.     nport = (char*)malloc(len + 1);
  106.     bzero(nport, len + 1);
  107.     sprintf(nport, ":%s", port);
  109.     /* 获得实际工作目录或文件的信息以判断是文件还是目录 */
  110.     if (stat(realPath, &info)) 
  111.     {
  112.         fprintf(client_sock, 
  113.                 "HTTP/1.1 200 OK\r\nServer: by Dubyoo\r\nConnection: close\r\n\r\n"
  114.                 "<html><head>"
  115.                 "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\" />"
  116.                 "<title>%d - %s</title></head>"
  117.                 "<body><font size=+4>Linux 下目录访问服务器 </font><br><hr width=\"100%%\"><br><center>"
  118.                 "<table border cols=3 width=\"100%%\">", 
  119.                 errno,strerror(errno));
  120.         fprintf(client_sock,
  121.                 "</table><font color=\"CC0000\" size=+2> 请向管理员咨询为何出现如下错误提示: \n%s %s</font></body></html>", 
  122.                 Path, strerror(errno));
  123.         goto out;
  124.     }
  126.     /* 处理浏览文件请求,即下载文件 */
  127.     if (S_ISREG(info.st_mode)) 
  128.     {
  129.         fd = open(realPath, O_RDONLY);
  130.         len = lseek(fd, 0, SEEK_END);
  131.         p = (char *) malloc(len + 1);
  132.         bzero(p, len + 1);
  133.         lseek(fd, 0, SEEK_SET);
  134.         read(fd, p, len);
  135.         close(fd);
  136.         fprintf(client_sock, 
  137.                 "HTTP/1.1 200 OK\r\nServer: by Dubyoo\r\nConnection: keep-alive\r\nContent-type: application/*\r\nContent-Length:%d\r\n\r\n", 
  138.                 len);
  139.         fwrite(p, len, 1, client_sock);
  140.         free(p);
  141.     } 
  142.     else if (S_ISDIR(info.st_mode)) 
  143.     {
  144.         /* 处理浏览目录请求 */
  145.         dir = opendir(realPath);
  146.         fprintf(client_sock, 
  147.                 "HTTP/1.1 200 OK\r\nServer: by Dubyoo\r\nConnection: close\r\n\r\n"
  148.                 "<html>"
  149.                 "<head>"
  150.                 "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\" />"
  151.                 "<title>%s</title>"
  152.                 "</head>"
  153.                 "<body><font size=+4>Linux 下目录访问服务器 </font><br><hr width=\"100%%\"><br><center>"
  154.                 "<table border cols=3 width=\"100%%\">", 
  155.                 Path);
  156.         fprintf(client_sock,
  157.                 "<caption><font size=+3> 目录 %s</font></caption>\n",
  158.                 Path);
  159.         fprintf(client_sock,
  160.                 "<tr><td> 名称 </td><td> 大小 </td><td> 修改时间 </td></tr>\n"
  161.                 );
  162.         if (dir == 0) 
  163.         {
  164.             fprintf(client_sock, 
  165.                     "</table><font color=\"CC0000\" size=+2>%s</font></body></html>",
  166.                     strerror(errno));
  167.             return;
  168.         }
  170.         /* 读取目录里的所有内容 */
  171.         while ((dirent = readdir(dir)) != 0) 
  172.         {
  173.             if (strcmp(Path, "/") == 0)
  174.                 sprintf(Filename, "/%s", dirent->d_name);
  175.             else
  176.                 sprintf(Filename, "%s/%s", Path, dirent->d_name);
  177.             fprintf(client_sock, "<tr>");
  178.             len = strlen(dirroot) + strlen(Filename) + 1;
  179.             realFilename = (char*)malloc(len + 1);
  180.             bzero(realFilename, len + 1);
  181.             sprintf(realFilename, "%s/%s", dirroot, Filename);
  182.             if (stat(realFilename, &info) == 0) 
  183.             {
  184.                 if (strcmp(dirent->d_name, ".") == 0)   //跳过自身目录
  185.                     continue;
  186.                 if (strcmp(dirent->d_name, "..") == 0)  //返回上一级菜单
  187.                     fprintf(client_sock,
  188.                             "<td><a href=\"http://%s%s%s\">(parent)</a></td>",
  189.                             host, atoi(port) == 80 ? "" : nport,
  190.                             dir_up(Path));
  191.                 else
  192.                     fprintf(client_sock,
  193.                             "<td><a href=\"http://%s%s%s\">%s</a></td>",
  194.                             host, atoi(port) == 80 ? "" : nport, Filename,
  195.                             dirent->d_name);
  196.                 if (S_ISDIR(info.st_mode))
  197.                     fprintf(client_sock, "<td> 目录 </td>");
  198.                 else if (S_ISREG(info.st_mode)) //普通文件显示大小
  199.                 {
  200.                     if(info.st_size < 1000)
  201.                     {
  202.                         fprintf(client_sock, "<td>%dB</td>", (int)info.st_size);
  203.                     }
  204.                     else if(info.st_size >= 1000 && info.st_size < 1000000)
  205.                     {
  206.                         fprintf(client_sock, "<td>%dKB</td>", ((int)info.st_size)/1000);
  207.                     }
  208.                     if(info.st_size >= 1000000 && info.st_size < 1000000000)
  209.                     {
  210.                         fprintf(client_sock, "<td>%dMB</td>", ((int)info.st_size)/1000000);
  211.                     }
  212.                     if(info.st_size >= 1000000000 )
  213.                     {
  214.                         fprintf(client_sock, "<td>%dGB</td>", ((int)info.st_size)/1000000000);
  215.                     }
  216.                 }
  217.                 else if (S_ISLNK(info.st_mode))
  218.                     fprintf(client_sock, "<td> 链接 </td>");
  219.                 else if (S_ISCHR(info.st_mode))
  220.                     fprintf(client_sock, "<td> 字符设备 </td>");
  221.                 else if (S_ISBLK(info.st_mode))
  222.                     fprintf(client_sock, "<td> 块设备 </td>");
  223.                 else if (S_ISFIFO(info.st_mode))
  224.                     fprintf(client_sock, "<td>FIFO</td>");
  225.                 else if (S_ISSOCK(info.st_mode))
  226.                     fprintf(client_sock, "<td>Socket</td>");
  227.                 else
  228.                     fprintf(client_sock, "<td>( 未知 )</td>");
  229.                 fprintf(client_sock, "<td>%s</td>", ctime(&info.st_ctime));
  230.             }
  231.             fprintf(client_sock, "</tr>\n");
  232.             free(realFilename);
  233.         }
  234.         fprintf(client_sock, "</table></center></body></html>");
  235.     } 
  236.     else 
  237.     {
  238.         /* 既非常规文件又非目录,禁止访问 */
  239.         fprintf(client_sock,
  240.                 "HTTP/1.1 200 OK\r\nServer: by Dubyoo\r\nConnection: close\r\n\r\n"
  241.                 "<html>"
  242.                 "<head>"
  243.                 "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\" />"
  244.                 "<title>permission denied</title>"
  245.                 "</head>"
  246.                 "<body><font size=+4>Linux 下目录访问服务器 </font><br><hr width=\"100%%\"><br><center>"
  247.                 "<table border cols=3 width=\"100%%\">"
  248.                 );
  249.         fprintf(client_sock,
  250.                 "</table>"
  251.                 "<font color=\"CC0000\" size=+2> 你访问的资源 '%s' 被禁止访问,请联系管理员解决! </font>"
  252.                 "</body></html>", 
  253.                 Path);
  254.     }
  256. out:
  257.     free(realPath);
  258.     free(nport);
  259. }
  261. /*------------------------------------------------------
  262.  *--- getoption - 分析取出程序的参数
  263.  *------------------------------------------------------
  264.  */
  265. void getoption(int argc, char **argv)
  266. {
  267.     int c, len;
  268.     char *p = 0;
  269.     opterr = 0;
  270.     while (1) 
  271.     {
  272.         int option_index = 0;
  273.         static struct option long_options[] = 
  274.         {
  275.             { "host", 1, 0, 0 },
  276.             { "port", 1, 0, 0 },
  277.             { "back", 1, 0, 0 },
  278.             { "dir", 1, 0, 0 },
  279.             { "log", 1, 0, 0 },
  280.             { "daemon", 0, 0, 0 },
  281.             { 0, 0, 0, 0}
  282.         };
  284.         /*本程序支持如下参数:
  285.          *--host IP 地址 或者 -H IP 地址
  286.          *--port 端口 或者 -P 端口
  287.          * --back 监听数量 或者 -B 监听数量
  288.          *--dir 网站根目录 或者 -D 网站根目录
  289.          *--log 日志存放路径 或者 -L 日志存放路径* --daemon 使程序进入后台运行模式
  290.          */
  291.         c = getopt_long(argc, argv, "H:P:B:D:L", long_options, &option_index);
  292.         if (c == -1 || c == '?')
  293.             break;
  294.         if(optarg) 
  295.             len = strlen(optarg);
  296.         else
  297.             len = 0;
  298.         if ((!c && !(strcasecmp(long_options[option_index].name, "host"))) || c == 'H') 
  299.                 //strcasecmp(const char* s1, const char* s2) 比较两个字符串，忽略大小写
  300.             p = host = (char*)malloc(len + 1);
  301.         else if ((!c && !(strcasecmp(long_options[option_index].name, "port"))) || c == 'P')
  302.             p = port = (char*)malloc(len + 1);
  303.         else if ((!c && !(strcasecmp(long_options[option_index].name, "back"))) || c == 'B')
  304.             p = back = (char*)malloc(len + 1);
  305.         else if ((!c && !(strcasecmp(long_options[option_index].name, "dir"))) || c == 'D')
  306.             p = dirroot = (char*)malloc(len + 1);
  307.         else if ((!c && !(strcasecmp(long_options[option_index].name, "log"))) || c == 'L')
  308.             p = logdir = (char*)malloc(len + 1);
  309.         else if ((!c && !(strcasecmp(long_options[option_index].name, "daemon")))) 
  310.         {
  311.             daemon_y_n = 1;
  312.             continue;
  313.         }
  314.         else
  315.             break;
  316.         bzero(p, len + 1);
  317.         memcpy(p, optarg, len);
  318.     }
  319. }
  321. int main(int argc, char **argv)
  322. {
  323.     struct sockaddr_in addr;
  324.     int sock_fd;
  325.     socklen_t addrlen;
  327.     /* 获得程序工作的参数,如 IP 、端口、监听数、网页根目录、目录存放位置等 */
  328.     getoption(argc, argv);
  329.     if (!host) 
  330.     {
  331.         addrlen = strlen(DEFAULTIP);
  332.         AllocateMemory(&host, addrlen, DEFAULTIP);
  333.     }
  334.     if (!port) 
  335.     {
  336.         addrlen = strlen(DEFAULTPORT);
  337.         AllocateMemory(&port, addrlen, DEFAULTPORT);
  338.     }
  339.     if (!back) 
  340.     {
  341.         addrlen = strlen(DEFAULTBACK);
  342.         AllocateMemory(&back, addrlen, DEFAULTBACK);
  343.     }
  344.     if (!dirroot) 
  345.     {
  346.         addrlen = strlen(DEFAULTDIR);
  347.         AllocateMemory(&dirroot, addrlen, DEFAULTDIR);
  348.     }
  349.     if (!logdir) 
  350.     {
  351.         addrlen = strlen(DEFAULTLOG);
  352.         AllocateMemory(&logdir, addrlen, DEFAULTLOG);
  353.     }
  354.     printf("host=%s port=%s back=%s dirroot=%s logdir=%s %s是后台工作模式 ( 进程 ID :%d)\n", host, port, back, dirroot, logdir, daemon_y_n?"":"不", getpid());
  355.     /* fork() 两次处于后台工作模式下 */
  356.     if (daemon_y_n) 
  357.     {
  358.         if (fork())
  359.             exit(0);
  360.         if (fork())
  361.             exit(0);
  362.         close(0), close(1), close(2);
  363.         logfp = fopen(logdir, "a+");
  364.         if (!logfp)
  365.             exit(0);
  366.     }
  367.     /* 处理子进程退出以免产生僵尸进程 */
  368.     signal(SIGCHLD, SIG_IGN);
  369.     /* 创建 socket */
  370.     if ((sock_fd = socket(PF_INET, SOCK_STREAM, 0)) < 0) 
  371.     {
  372.         if (!daemon_y_n) 
  373.         {
  374.             prterrmsg("socket()");
  375.         } 
  376.         else 
  377.         {
  378.             wrterrmsg("socket()");
  379.         }
  380.     }
  381.     /* 设置端口快速重用 */
  382.     addrlen = 1;
  383.     setsockopt(sock_fd, SOL_SOCKET, SO_REUSEADDR, &addrlen,
  384.             sizeof(addrlen));
  385.     addr.sin_family = AF_INET;
  386.     addr.sin_port = htons(atoi(port));
  387.     addr.sin_addr.s_addr = INADDR_ANY;
  388.     //addr.sin_addr.s_addr = inet_addr(host);
  389.     addrlen = sizeof(struct sockaddr_in);
  390.     /* 绑定地址、端口等信息 */
  391.     if (bind(sock_fd, (struct sockaddr *) &addr, addrlen) < 0) 
  392.     {
  393.         if (!daemon_y_n) 
  394.         {
  395.             prterrmsg("bind()");
  396.         } 
  397.         else 
  398.         {
  399.             wrterrmsg("bind()");
  400.         }
  401.     }
  402.     /* 开启监听 */
  403.     if (listen(sock_fd, atoi(back)) < 0) 
  404.     {
  405.         if (!daemon_y_n) 
  406.         {
  407.             prterrmsg("listen()");
  408.         } 
  409.         else 
  410.         {
  411.             wrterrmsg("listen()");
  412.         }
  413.     }
  414.     while (1) 
  415.     {
  416.         int len;
  417.         int new_fd;
  418.         addrlen = sizeof(struct sockaddr_in);
  419.         /* 接受新连接请求 */
  420.         new_fd = accept(sock_fd, (struct sockaddr*)(&addr), &addrlen);
  421.         if (new_fd < 0) 
  422.         {
  423.             if (!daemon_y_n) 
  424.             {
  425.                 prterrmsg("accept()");
  426.             } 
  427.             else 
  428.             {
  429.                 wrterrmsg("accept()");
  430.             }
  431.             break;
  432.         }
  433.         bzero(buffer, MAXBUF + 1);
  434.         sprintf(buffer, " 连接来自于 : %s:%d\n",
  435.                 inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));
  436.         if (!daemon_y_n) 
  437.         {
  438.             prtinfomsg(buffer);
  439.         } 
  440.         else 
  441.         {
  442.             wrtinfomsg(buffer);
  443.         }
  444.         /* 产生一个子进程去处理请求,当前进程继续等待新的连接到来 */
  445.         if (!fork()) 
  446.         {
  447.             bzero(buffer, MAXBUF + 1);
  448.             if ((len = recv(new_fd, buffer, MAXBUF, 0)) > 0) 
  449.             {
  450.                 FILE *ClientFP = fdopen(new_fd, "w");
  451.                 if (ClientFP == NULL) 
  452.                 {
  453.                     if (!daemon_y_n) 
  454.                     {
  455.                         prterrmsg("fdopen()");
  456.                     } 
  457.                     else 
  458.                     {
  459.                         prterrmsg("fdopen()");
  460.                     }
  461.                 } 
  462.                 else 
  463.                 {
  464.                     char Req[MAXPATH + 1] = "";
  465.                     sscanf(buffer, "GET %s HTTP", Req);
  466.                     bzero(buffer, MAXBUF + 1);
  467.                     sprintf(buffer, " 请求取文件 : \"%s\"\n", Req);
  468.                     if (!daemon_y_n) 
  469.                     {
  470.                         prtinfomsg(buffer);
  471.                     } 
  472.                     else 
  473.                     {
  474.                         wrtinfomsg(buffer);
  475.                     }
  476.                     /* 处理用户请求 */
  477.                     GiveResponse(ClientFP, Req);
  478.                     fclose(ClientFP);
  479.                 }
  480.             }
  481.             exit(0);
  482.         }
  483.         close(new_fd);
  484.     }
  485.     close(sock_fd);
  486.     return 0;
  487. }
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注