[关闭]
@RunZhi 2016-09-13T16:14:14.000000Z 字数 28364 阅读 1563

webbench,tinyhttpd源码剖析与性能测试

操作系统实验报告

实验目的:

1.编译并运行WebBench,测试baidu服务器的性能

2.熟读并理解WebBench源码,将每一行程序的理解注释加入该任务四的实验报告中,要求注释偏口语化.

3.编译并运行TinyHttpd，并用浏览器访问该小型web服务器

4.熟读并理解TinyHttpd的源码，将每一行程序的理解注释加入该任务四的实验报告中，要求注释偏口语化

5.
将自己编译的WebBench程序去测试自己编译的TinyHttpd程序，看看会发生什么“现象”？
请分析：
A) 为什么会发生这个“现象”?
B) 是谁的问题导致该现象的发生？
C) 请修复该问题.

实验过程:

Webbench:

下载webbench源代码并且运行程序:

  1. sudo make
  2. sudo make install
  3. ./webbench -c 100 -t 30 http://www.baidu.com/

然后终端输出如下:
实验截图1

源代码的解析附在后面.

Tinyhttpd

下载tinyHttpd源代码,但此时它们是无法通过编译的,需要进行一定的修改,具体修改处详见:http://blog.csdn.net/cqu20093154/article/details/41025885.

完成编译后,运行程序:

  1. ./httpd

终端显示:
实验截图2

打开浏览器,在地址栏输入localhost:42557,浏览器将显示:
实验截图3

用Webbench测试本机运行的tinyhttpd的性能

运行tinyhttpd,然后用webbench进行测试,发现如下现象
实验截图4

所有的request都是fail的!再看看httpd的进程,早已经不见了.

上网查找资料后,得知问题出现在tinyhttpd的httpd.c的一处源代码:

  1. ...
  2. void unimplemented(int client)
  3. {
  4.      char buf[1024];
  6.      // HTTP method 不被支持
  7.      sprintf(buf, "HTTP/1.0 501 Method Not Implemented\r\n");
  8.      send(client, buf, strlen(buf), 0);
  10.      // 输出服务器信息到网页上
  11.      sprintf(buf, SERVER_STRING);
  12.      send(client, buf, strlen(buf), 0);
  13.      sprintf(buf, "Content-Type: text/html\r\n");
  14.      send(client, buf, strlen(buf), 0);
  15.      sprintf(buf, "\r\n");
  16.      send(client, buf, strlen(buf), 0);
  17.      sprintf(buf, "<HTML><HEAD><TITLE>Method Not Implemented\r\n");
  18.      send(client, buf, strlen(buf), 0);
  19.      sprintf(buf, "</TITLE></HEAD>\r\n");
  20.      send(client, buf, strlen(buf), 0);
  21.      sprintf(buf, "<BODY><P>HTTP request method not supported.\r\n");
  22.      send(client, buf, strlen(buf), 0);
  23.      sprintf(buf, "</BODY></HTML>\r\n");
  24.      send(client, buf, strlen(buf), 0);
  25. }
  27. ...

因为webbench在访问一次之后就断掉了,tinyhttpd是否好几次把信息发送过去,由于webbench连接成功并且收到一次消息后便断了连接（具体看webbench.c的如下代码片段)

  1. static int bench(void)
  2. {
  3. ....
  4.      /* check avaibility of target server */
  5.      // host/proxyhost为服务器端ip, proxyport为服务器端口号建立socket连接
  6.      i=Socket(proxyhost==NULL?host:proxyhost, proxyport);
  7.      if(i<0) {
  8.           // 出现错误
  9.           fprintf(stderr, "\nConnect to server failed. Aborting benchmark.\n");
  10.           return 1;
  11.      }
  13.      //对套接字i的引用计数-1，当引用计数为0的时候，关闭套接字
  14.      close(i);
  15.  ....

而webbench给tinyhttpd发送的是无method的请求，因此tinyhttpd将会执行unimplemented函数:

  1. void unimplemented(int client)
  2. {
  3.      char buf[1024];
  5.      // HTTP method 不被支持
  6.      sprintf(buf, "HTTP/1.0 501 Method Not Implemented\r\n");
  7.      send(client, buf, strlen(buf), 0);
  9.      // 输出服务器信息到网页上
  10.      sprintf(buf, SERVER_STRING);
  11.      send(client, buf, strlen(buf), 0);
  12.      sprintf(buf, "Content-Type: text/html\r\n");
  13.      send(client, buf, strlen(buf), 0);
  14.      sprintf(buf, "\r\n");
  15.      send(client, buf, strlen(buf), 0);
  16.      sprintf(buf, "<HTML><HEAD><TITLE>Method Not Implemented\r\n");
  17.      send(client, buf, strlen(buf), 0);
  18.      sprintf(buf, "</TITLE></HEAD>\r\n");
  19.      send(client, buf, strlen(buf), 0);
  20.      sprintf(buf, "<BODY><P>HTTP request method not supported.\r\n");
  21.      send(client, buf, strlen(buf), 0);
  22.      sprintf(buf, "</BODY></HTML>\r\n");
  23.      send(client, buf, strlen(buf), 0);
  24. }

由于webbench是收到了一次消息便断了连接，因此在tinyhttpd在执行完上面函数的第11行的时候(send函数），就会向系统发送异常消息，而程序没有对消息进行处理，因此程序会dump掉。

要改的方法很多，其中一种方法就是，把要发送的消息一次性发送完.把那一大段sprintf send的直接改成:

  1.      strcat(buf, "HTTP/1.0 501 Method Not Implemented\r\n");
  2.      strcat(buf, SERVER_STRING);
  3.      strcat(buf, "Content-Type: text/html\r\n\r\n<HTML><HEAD><TITLE>Method Not Implemented\r\n</TITLE></HEAD>\r\n<BODY><P>HTTP request method not supported.\r\n</BODY></HTML>\r\n");
  4.      printf("%s\n",buf);
  5.      send(client, buf, strlen(buf), 0);

也可以让send不发异常消息给系统，做法是：把send函数的最后一个参数设为:MSG_NOSIGNAL.

然后重新开始测试,即可.测试结果如下:
实验截图5

(出现了Cannot allocate memory错误,但个人认为这不是错误而是电脑硬件条件不够好的缘故)

源代码解析

Webbench

  1. //webbench.c
  3. /*
  4.  * (C) Radim Kolar 1997-2004
  5.  * This is free software, see GNU Public License version 2 for
  6.  * details.
  7.  *
  8.  * Simple forking WWW Server benchmark:
  9.  *
  10.  * Usage:
  11.  *   webbench --help
  12.  *
  13.  * Return codes:
  14.  *    0 - sucess
  15.  *    1 - benchmark failed (server is not on-line)
  16.  *    2 - bad param
  17.  *    3 - internal error, fork failed
  18.  * 
  19.  */ 
  20. #include "socket.c"
  21. #include <unistd.h>
  22. #include <sys/param.h>
  23. #include <rpc/types.h>
  24. #include <getopt.h>
  25. #include <strings.h>
  26. #include <time.h>
  27. #include <signal.h>
  30. /* values */
  31. volatile int timerexpired = 0;    //判断压力测试是否已经达到预定时间
  32. int speed = 0;                    //记录成功得到服务器响应的进程数量
  33. int failed = 0;                   //记录失败的进程数量
  34. int bytes = 0;                    //记录进程成功读取的字节数
  36. /* globals */
  37. int http10 = 1; /* http版本，0 - http/0.9, 1 - http/1.0, 2 - http/1.1 */
  39. /* Allow: GET, HEAD, OPTIONS, TRACE */
  40. #define METHOD_GET 0
  41. #define METHOD_HEAD 1
  42. #define METHOD_OPTIONS 2
  43. #define METHOD_TRACE 3
  44. #define PROGRAM_VERSION "1.5"
  46. int method = METHOD_GET;   //请求方式，默认为get方式
  47. int clients = 1;           //并发数量，默认为1
  48. int force = 0;             //0表示等待读取从服务器返回的数据，1表示不等待
  49. int force_reload = 0;      //0表示缓存，1表示不缓存
  50. int proxyport = 80;        //代理服务器的端口号
  51. char *proxyhost = NULL;    //代理服务器的ip
  52. int benchtime = 30;        //压力测试时间，默认为30秒
  55. /* internal */
  56. int mypipe[2];                 //使用管道进行父进程与子进程的通信
  57. char host[MAXHOSTNAMELEN];     //服务器端的ip
  58. #define REQUEST_SIZE 2048
  59. char request[REQUEST_SIZE];    //所要发送的http请求
  61. static const struct option long_options[]=
  62. {
  63.      {"force", no_argument, &force, 1}, 
  64.      {"reload", no_argument, &force_reload, 1}, 
  65.      {"time", required_argument, NULL, 't'}, 
  66.      {"help", no_argument, NULL, '?'}, 
  67.      {"http09", no_argument, NULL, '9'}, 
  68.      {"http10", no_argument, NULL, '1'}, 
  69.      {"http11", no_argument, NULL, '2'}, 
  70.      {"get", no_argument, &method, METHOD_GET}, 
  71.      {"head", no_argument, &method, METHOD_HEAD}, 
  72.      {"options", no_argument, &method, METHOD_OPTIONS}, 
  73.      {"trace", no_argument, &method, METHOD_TRACE}, 
  74.      {"version", no_argument, NULL, 'V'}, 
  75.      {"proxy", required_argument, NULL, 'p'}, 
  76.      {"clients", required_argument, NULL, 'c'}, 
  77.      {NULL, 0, NULL, 0}
  78. };
  80. /* prototypes */
  81. static void benchcore(const char* host, const int port,  const char *request);
  82. static int bench(void);
  83. static void build_request(const char *url);
  85. static void alarm_handler(int signal)
  86. {
  87.      //设置标记，表示已经达到了预定的测试时间
  88.      timerexpired=1; 
  89. }   
  91. static void usage(void)
  92. {
  93.      //输出如何使用webbench信息的函数
  94.      fprintf(stderr, 
  95.              "webbench [option]... URL\n"
  96.              "  -f|--force               Don't wait for reply from server.\n"
  97.              "  -r|--reload              Send reload request - Pragma: no-cache.\n"
  98.              "  -t|--time <sec>          Run benchmark for <sec> seconds. Default 30.\n"
  99.              "  -p|--proxy <server:port> Use proxy server for request.\n"
  100.              "  -c|--clients <n>         Run <n> HTTP clients at once. Default one.\n"
  101.              "  -9|--http09              Use HTTP/0.9 style requests.\n"
  102.              "  -1|--http10              Use HTTP/1.0 protocol.\n"
  103.              "  -2|--http11              Use HTTP/1.1 protocol.\n"
  104.              "  --get                    Use GET request method.\n"
  105.              "  --head                   Use HEAD request method.\n"
  106.              "  --options                Use OPTIONS request method.\n"
  107.              "  --trace                  Use TRACE request method.\n"
  108.              "  -?|-h|--help             This information.\n"
  109.              "  -V|--version             Display program version.\n"
  110.           );
  111. };
  112. int main(int argc,  char *argv[])
  113. {
  114.      int opt=0;
  115.      int options_index=0;
  116.      char *tmp=NULL;
  118.      // 命令行参数不合法，输出使用手册
  119.      if(argc==1)
  120.      {
  121.           usage();
  122.           return 2;
  123.      } 
  125.      // 检查参数,使用getopt_long
  126.      while((opt=getopt_long(argc, argv, "912Vfrt:p:c:?h", long_options, &options_index))!=EOF )
  127.      {
  128.           switch(opt)
  129.           {
  130.           case  0 :
  131.                break;
  132.           case 'f':
  133.                force=1;
  134.                break;
  135.           case 'r':
  136.                force_reload=1;
  137.                break; 
  138.           case '9':
  139.                http10=0;
  140.                break;
  141.           case '1':
  142.                http10=1;
  143.                break;
  144.           case '2':
  145.                http10=2;
  146.                break;
  147.           case 'V':
  148.                printf(PROGRAM_VERSION"\n");
  149.                exit(0);
  150.           case 't':
  151.                benchtime=atoi(optarg);
  152.                break;        
  153.           case 'p': 
  154.                /* proxy server parsing server:port */
  155.                tmp=strrchr(optarg, ':');
  156.                proxyhost=optarg;
  157.                if(tmp==NULL)
  158.                {
  159.                     break;
  160.                }
  161.                if(tmp==optarg)
  162.                {
  163.                     fprintf(stderr, "Error in option --proxy %s: Missing hostname.\n", optarg);
  164.                     return 2;
  165.                }
  166.                if(tmp==optarg+strlen(optarg)-1)
  167.                {
  168.                     fprintf(stderr, "Error in option --proxy %s Port number is missing.\n", optarg);
  169.                     return 2;
  170.                }
  171.                *tmp='\0';
  172.                proxyport=atoi(tmp+1);break;
  173.           case ':':
  174.           case 'h':
  175.           case '?': usage();return 2;break;
  176.           case 'c': clients=atoi(optarg);break;
  177.           }
  178.      }
  180.      // optind为一个不包含选项的命令行参数，这里就是指URL值在参数表中的index
  181.      if(optind==argc) {
  182.           fprintf(stderr, "webbench: Missing URL!\n");
  183.           usage();
  184.           return 2;
  185.      }
  187.      // 设置默认参数
  188.      if(clients==0) clients=1;
  189.      if(benchtime==0) benchtime=60;
  191.      /* Copyright */
  192.      // 输出copyright
  193.      fprintf(stderr, "Webbench - Simple Web Benchmark "PROGRAM_VERSION"\n"
  194.              "Copyright (c) Radim Kolar 1997-2004,  GPL Open Source Software.\n"
  195.           );
  197.      build_request(argv[optind]);
  198.      /* print bench info */
  199.      // 打印测试的信息
  200.      printf("\nBenchmarking: ");
  202.      switch(method)
  203.      {
  204.      case METHOD_GET:
  205.      default:
  206.           printf("GET");
  207.           break;
  208.      case METHOD_OPTIONS:
  209.           printf("OPTIONS");
  210.           break;
  211.      case METHOD_HEAD:
  212.           printf("HEAD");
  213.           break;
  214.      case METHOD_TRACE:
  215.           printf("TRACE");
  216.           break;
  217.      }
  219.      printf(" %s", argv[optind]);
  221.      switch(http10)
  222.      {
  223.      case 0: printf(" (using HTTP/0.9)");break;
  224.      case 2: printf(" (using HTTP/1.1)");break;
  225.      }
  227.      printf("\n");
  229.      if(clients==1)
  230.           printf("1 client");
  231.      else
  232.           printf("%d clients", clients);
  234.      printf(",  running %d sec",  benchtime);
  235.      if(force)
  236.           printf(",  early socket close");
  237.      if(proxyhost!=NULL)
  238.           printf(",  via proxy server %s:%d", proxyhost, proxyport);
  239.      if(force_reload)
  240.           printf(",  forcing reload");
  241.      printf(".\n");
  242.      return bench();
  243. }
  245. void build_request(const char *url)
  246. {
  247.      // 对全局变量char request[REQUEST_SIZE]进行操作,根据URL构建http请求
  248.      char tmp[10];
  249.      int i;
  251.      //字节清零
  252.      bzero(host, MAXHOSTNAMELEN);
  253.      bzero(request, REQUEST_SIZE);
  255.      //确定http版本
  256.      if(force_reload && proxyhost!=NULL && http10<1) http10=1;
  257.      if(method==METHOD_HEAD && http10<1) http10=1;
  258.      if(method==METHOD_OPTIONS && http10<2) http10=2;
  259.      if(method==METHOD_TRACE && http10<2) http10=2;
  261.      //根据请求，设置内容
  262.      switch(method)
  263.      {
  264.      default:
  265.      case METHOD_GET:
  266.           strcpy(request, "GET");
  267.           break;
  268.      case METHOD_HEAD:
  269.           strcpy(request, "HEAD");
  270.           break;
  271.      case METHOD_OPTIONS:
  272.           strcpy(request, "OPTIONS");
  273.           break;
  274.      case METHOD_TRACE:
  275.           strcpy(request, "TRACE");
  276.           break;
  277.      }
  279.      strcat(request, " ");
  281.      // 检测URL内容是否合法 
  282.      if(NULL==strstr(url, "://"))
  283.      {
  284.           fprintf(stderr,  "\n%s: is not a valid URL.\n", url);
  285.           exit(2);
  286.      }
  287.      // 检测URL长度是否合法
  288.      if(strlen(url)>1500)
  289.      {
  290.           fprintf(stderr, "URL is too long.\n");
  291.           exit(2);
  292.      }
  294.      if(proxyhost==NULL)
  295.           if (0!=strncasecmp("http://", url, 7))
  296.           {
  297.                //不使用代理服务器，只允许使用HTTP协议
  298.                fprintf(stderr, "\nOnly HTTP protocol is directly supported,  set --proxy for others.\n");
  299.                exit(2);
  300.           }
  302.      /* protocol/host delimiter */
  303.      // 获得://后面第一个字符的相对索引号
  304.      i=strstr(url, "://")-url+3;
  305.      /* printf("%d\n", i); */
  307.      if(strchr(url+i, '/')==NULL) {
  308.           // 没有其它的'/'符号,不合法
  309.           fprintf(stderr, "\nInvalid URL syntax - hostname don't ends with '/'.\n");
  310.           exit(2);
  311.      }
  314.      if(proxyhost==NULL)
  315.      {
  316.           //不使用代理服务器, 必定是http协议
  317.           /* get port from hostname */
  318.           if( index(url+i, ':')!=NULL && index(url+i, ':')<index(url+i,'/') )
  319.           {
  320.                // 如果是 server:port的格式
  321.                // 获取主机地址
  322.                strncpy(host, url+i, strchr(url+i, ':')-url-i);
  323.                bzero(tmp, 10);
  324.                strncpy(tmp, index(url+i, ':')+1, strchr(url+i, '/')-index(url+i, ':')-1);
  325.                /* printf("tmp=%s\n", tmp); */
  326.                // 目标端口
  327.                proxyport=atoi(tmp);
  328.                if(proxyport==0)
  329.                     // 默认端口号为80
  330.                     proxyport=80;
  331.           }
  332.           else
  333.           {
  334.                // 获取主机地址
  335.                strncpy(host, url+i, strcspn(url+i, "/"));
  336.           }
  337.           // printf("Host=%s\n", host);
  338.           // 获取域名后的目标地址
  339.           strcat(request+strlen(request), url+i+strcspn(url+i, "/"));
  340.      }
  341.      else
  342.      {
  343.           // printf("ProxyHost=%s\nProxyPort=%d\n", proxyhost, proxyport);
  344.           // 使用了代理服务器
  345.           strcat(request, url);
  346.      }
  347.      // 确定http版本号
  348.      if(http10==1)
  349.           strcat(request, " HTTP/1.0");
  350.      else if (http10==2)
  351.           strcat(request, " HTTP/1.1");
  353.      // 换行
  354.      strcat(request, "\r\n");
  356.      //添加 User-Agent信息
  357.      if(http10>0)
  358.           strcat(request, "User-Agent: WebBench "PROGRAM_VERSION"\r\n");
  359.      if(proxyhost==NULL && http10>0)
  360.      {
  361.           // 如果http版本大于0.9,则添加Host信息
  362.           strcat(request, "Host: ");
  363.           strcat(request, host);
  364.           strcat(request, "\r\n");
  365.      }
  366.      if(force_reload && proxyhost!=NULL)
  367.      {
  368.           // 如果不使用缓存且有代理服务器，则不缓存
  369.           strcat(request, "Pragma: no-cache\r\n");
  370.      }
  371.      if(http10>1)
  372.           // 如果HTTP1.1,则存在长链接，应将Connection设置为close
  373.           strcat(request, "Connection: close\r\n");
  374.      /* add empty line at end */
  375.      if(http10>0) strcat(request, "\r\n");  //再添加换行
  376.      // printf("Req=%s\n", request);
  377. }
  379. /* vraci system rc error kod */
  380. static int bench(void)
  381. {
  382.      int i, j, k;   
  383.      pid_t pid=0;
  384.      FILE *f;
  386.      /* check avaibility of target server */
  387.      // host/proxyhost为服务器端ip, proxyport为服务器端口号建立socket连接
  388.      i=Socket(proxyhost==NULL?host:proxyhost, proxyport);
  389.      if(i<0) {
  390.           // 出现错误
  391.           fprintf(stderr, "\nConnect to server failed. Aborting benchmark.\n");
  392.           return 1;
  393.      }
  395.      //对套接字i的引用计数-1，当引用计数为0的时候，关闭套接字
  396.      close(i);
  397.      /* create pipe */
  398.      // 子进程向父进程回报数据
  399.      if(pipe(mypipe))
  400.      {
  401.           perror("pipe failed.");
  402.           return 3;
  403.      }
  405.      /* not needed,  since we have alarm() in childrens */
  406.      /* wait 4 next system clock tick */
  407.      /*
  408.        cas=time(NULL);
  409.        while(time(NULL)==cas)
  410.        sched_yield();
  411.      */
  413.      /* fork childs */
  414.      // 通过fork来产生clients个子程序来进行测试
  415.      for(i=0;i<clients;i++)
  416.      {
  417.           pid=fork();
  418.           if(pid <= (pid_t) 0)
  419.           {
  420.                // fork返回了0，要么此时是子进程， 要么是产生了错误
  421.                /* child process or error*/
  422.                // 子进程休眠，动机不明
  423.                sleep(1); /* make childs faster */
  424.                break;
  425.           }
  426.      }
  428.      if( pid< (pid_t) 0)
  429.      {
  430.           // fork函数运行错误
  431.           fprintf(stderr, "problems forking worker no. %d\n", i);
  432.           perror("fork failed.");
  433.           return 3;
  434.      }
  436.      if(pid== (pid_t) 0)
  437.      {
  438.           // 子进程运行此处的代码
  439.           /* I am a child */
  441.           //进行压力测试
  442.           if(proxyhost==NULL)
  443.                benchcore(host, proxyport, request);
  444.           else
  445.                benchcore(proxyhost, proxyport, request);
  447.           /* write results to pipe */
  448.           // 向管道写数据
  449.           f=fdopen(mypipe[1], "w");
  450.           if(f==NULL)
  451.           {
  452.                // 管道打开错误处理
  453.                perror("open pipe for writing failed.");
  454.                return 3;
  455.           }
  456.           /* fprintf(stderr, "Child - %d %d\n", speed, failed); */
  457.           fprintf(f, "%d %d %d\n", speed, failed, bytes);
  458.           fclose(f);
  459.           return 0;
  460.      }
  461.      else
  462.      {
  463.           // 父进程运行此处的代码
  464.           f=fdopen(mypipe[0], "r");
  465.           if(f==NULL) 
  466.           {
  467.                perror("open pipe for reading failed.");
  468.                return 3;
  469.           }
  470.           // 设置没有缓冲区
  471.           setvbuf(f, NULL, _IONBF, 0);
  473.           // 初始化
  474.           speed=0;
  475.           failed=0;
  476.           bytes=0;
  478.           while(1)
  479.           {
  480.                // 通过f从管道读取数据
  481.                // fscanf是阻塞式函数
  482.                pid=fscanf(f, "%d %d %d", &i, &j, &k);
  483.                if(pid<2)
  484.                {
  485.                     fprintf(stderr, "Some of our childrens died.\n");
  486.                     break;
  487.                }
  488.                // 统计数据
  489.                speed+=i;
  490.                failed+=j;
  491.                bytes+=k;
  492.                /* fprintf(stderr, "*Knock* %d %d read=%d\n", speed, failed, pid); */
  493.                // 子进程数据读完后，退出
  494.                if(--clients==0) break;
  495.           }
  496.           fclose(f);
  498.           // 输出测试数据
  499.           printf("\nSpeed=%d pages/min,  %d bytes/sec.\nRequests: %d susceed,  %d failed.\n",
  500.                  (int)((speed+failed)/(benchtime/60.0f)), 
  501.                  (int)(bytes/(float)benchtime), 
  502.                  speed, 
  503.                  failed);
  504.      }
  505.      return i;
  506. }
  508. void benchcore(const char *host, const int port, const char *req)
  509. {
  510.      int rlen;
  511.      char buf[1500];
  512.      int s, i;
  513.      struct sigaction sa;
  515.      /* setup alarm signal handler */
  516.      sa.sa_handler=alarm_handler; //设置alarm_handler为信号处理函数
  517.      sa.sa_flags=0;
  519.      // sigaction函数 成功会返回0，失败会返回-1
  520.      // 设置超时将产生信息SIGALRM, 用sa的sa_handler函数处理
  521.      if(sigaction(SIGALRM, &sa, NULL))
  522.           exit(3);
  523.      //开始计时
  524.      alarm(benchtime);
  526.      rlen = strlen(req);
  527. nexttry:while(1)
  528.      {
  529.           if(timerexpired)
  530.           {
  531.                // 超时返回
  532.                if(failed>0)
  533.                {
  534.                     /* fprintf(stderr, "Correcting failed by signal\n"); */
  535.                     failed--;
  536.                }
  537.                return;
  538.           }
  539.           s=Socket(host, port);
  541.           if(s<0)
  542.           {    // 连接失败, failed数加1
  543.                failed++;
  544.                continue;
  545.           }
  547.           if( rlen!=write(s, req, rlen) )
  548.           {
  549.                // 实际写入数据长度和预期写入数据长度不符,失败
  550.                failed++;
  551.                // 套接字引用计数-1
  552.                close(s);
  553.                continue;
  554.           }
  556.           if( http10 == 0 ) //对http0.9做的处理,不懂
  557.                if( shutdown(s, 1) )
  558.                {
  559.                     // 禁止在一个套接口上进行数据的接收与发送?
  560.                     failed++;
  561.                     close(s);
  562.                     continue;
  563.                }
  565.           if(force==0) 
  566.           {
  567.                // 等待读取服务器返回的数据
  568.                /* read all available data from socket */
  569.                while(1)
  570.                {
  571.                     //超时退出
  572.                     if(timerexpired)
  573.                          break;
  574.                     // 读取返回数据,i为读取到的字节数
  575.                     i=read(s, buf, 1500);
  576.                     /* fprintf(stderr, "%d\n", i); */
  577.                     if(i<0) 
  578.                     {
  579.                          // 读取文件失败,失败数加1,并对套接字引用计数减1
  580.                          failed++;
  581.                          close(s);
  582.                          // 跳回循环继续测试
  583.                          goto nexttry;
  584.                     }
  585.                     else
  586.                          if(i==0)
  587.                               break;
  588.                          else
  589.                               // 成功读取的字节数增加
  590.                               bytes+=i;
  591.                }
  592.           }
  594.           if(close(s))
  595.           {
  596.                // 若套接字引用计数变为0,则失败数减1
  597.                failed++;
  598.                continue;
  599.           }
  601.           // 成功次数+1
  602.           speed++;
  603.      }
  604. }
  1. // socket.c
  2. /* $Id: socket.c 1.1 1995/01/01 07:11:14 cthuang Exp $
  3.  *
  4.  * This module has been modified by Radim Kolar for OS/2 emx
  5.  */
  7. /***********************************************************************
  8.   module:       socket.c
  9.   program:      popclient
  10.   SCCS ID:      @(#)socket.c    1.5  4/1/94
  11.   programmer:   Virginia Tech Computing Center
  12.   compiler:     DEC RISC C compiler (Ultrix 4.1)
  13.   environment:  DEC Ultrix 4.3 
  14.   description:  UNIX sockets code.
  15. ***********************************************************************/
  17. #include <sys/types.h>
  18. #include <sys/socket.h>
  19. #include <fcntl.h>
  20. #include <netinet/in.h>
  21. #include <arpa/inet.h>
  22. #include <netdb.h>
  23. #include <sys/time.h>
  24. #include <string.h>
  25. #include <unistd.h>
  26. #include <stdio.h>
  27. #include <stdlib.h>
  28. #include <stdarg.h>
  30. /*
  31.   为了方便，把sockaddr_in定义放在这方便阅读
  32. struct  sockaddr_in {
  33.      short  int  sin_family;           //协议族
  34.      unsigned  short  int  sin_port;     //存储端口号
  35.      struct  in_addr  sin_addr;          //IP地址
  36.      unsigned  char  sin_zero[8];        //作内存对齐用
  37. };
  38. */
  40. /*
  41. struct hostent {  
  42.      char *h_name;    //主机的规范名
  43.      char **h_aliases;  //主机的别名
  44.      int h_addrtype;    //主机ip地址的类型
  45.      int h_length;      //主机ip地址的长度
  46.      char **h_addr_list;  //主机ip地址
  47. };
  48. */
  50. /*
  51.   const char* host: 目标主机地址
  52.   int clientPort: 主机地址的端口
  53.  */
  54. int Socket(const char *host, int clientPort)
  55. {
  56.      int sock;
  57.      unsigned long inaddr;
  58.      struct sockaddr_in ad;
  59.      struct hostent *hp;
  61.      memset(&ad, 0, sizeof(ad));  //初始化
  62.      ad.sin_family = AF_INET;     //协议族使用AF_INET,AF_INET是一种很常用的地址协议族
  64.      inaddr = inet_addr(host);    //将点分十进制转为整型数
  65.      if (inaddr != INADDR_NONE)   //如果host是一个合法IP地址
  66.           memcpy(&ad.sin_addr, &inaddr, sizeof(inaddr));  //将转换得到的IP地址复制到结构体ad的sin_addr中
  67.      else
  68.      {
  69.           //否则,host可能是一个域名或主机名，或是非法名称
  70.           hp = gethostbyname(host); //根据host获得IP地址
  71.           if (hp == NULL)    //获取失败，为非法名称
  72.                return -1;    //返回-1
  73.           //获得了IP地址，复制到ad中(可能有多个IP地址，复制第一个)
  74.           memcpy(&ad.sin_addr, hp->h_addr, hp->h_length);  
  75.      }
  76.      ad.sin_port = htons(clientPort); //转换字节顺序为高序字节
  78.      //创建TCP套接字，系统自动推断用什么协议
  79.      sock = socket(AF_INET, SOCK_STREAM, 0);
  82.      if (sock < 0)
  83.           //创建失败
  84.           return sock; 
  85.      if (connect(sock, (struct sockaddr *)&ad, sizeof(ad)) < 0)
  86.           //三次握手失败则返回-1
  87.           return -1;
  88.      return sock;
  89. }

Tinyhttpd

  1. /* J. David's webserver */
  2. /* This is a simple webserver.
  3.  * Created November 1999 by J. David Blackstone.
  4.  * CSE 4344 (Network concepts), Prof. Zeigler
  5.  * University of Texas at Arlington
  6.  */
  7. /* This program compiles for Sparc Solaris 2.6.
  8.  * To compile for Linux:
  9.  *  1) Comment out the #include <pthread.h> line.
  10.  *  2) Comment out the line that defines the variable newthread.
  11.  *  3) Comment out the two lines that run pthread_create().
  12.  *  4) Uncomment the line that runs accept_request().
  13.  *  5) Remove -lsocket from the Makefile.
  14.  */
  15. #include <stdio.h>
  16. #include <sys/socket.h>
  17. #include <sys/types.h>
  18. #include <netinet/in.h>
  19. #include <arpa/inet.h>
  20. #include <unistd.h>
  21. #include <ctype.h>
  22. #include <strings.h>
  23. #include <string.h>
  24. #include <sys/stat.h>
  25. #include <pthread.h>
  26. #include <sys/wait.h>
  27. #include <stdlib.h>
  29. #define ISspace(x) isspace((int)(x))
  31. #define SERVER_STRING "Server: jdbhttpd/0.1.0\r\n"
  33. void* accept_request(void *pclient);                                         //处理从套接字上监听到的一个HTTP请求
  34. void bad_request(int);                                            //返回给客户端这是个错误请求
  35. void cat(int, FILE *);                                            //读取服务器上某个文件写到socket套接字
  36. void cannot_execute(int);                                         //处理发生在执行cgi程序时出现的错误
  37. void error_die(const char *);                                     //把错误信息写到perror并退出
  38. void execute_cgi(int, const char *, const char *, const char *);  //运行cgi程序的处理
  39. int get_line(int, char *, int);                                   //读取套接字的一行
  40. void headers(int, const char *);                                  //把HTTP响应的头部写到套接字
  41. void not_found(int);                                              //处理找不到请求的文件时的情况
  42. void serve_file(int, const char *);                               //调用cat把服务器文件返回给浏览器
  43. int startup(u_short *);                                           //初始化httpd服务
  44. void unimplemented(int);                                          //返回给浏览器表明收到的HTTP请求所用的method不被支持
  46. /**********************************************************************/
  47. /* A request has caused a call to accept() on the server port to
  48.  * return.  Process the request appropriately.
  49.  * Parameters: the socket connected to the client */
  50. /**********************************************************************/
  51. void* accept_request(void *pclient)
  52. {
  53.      int client = *(int*)pclient;
  54.      char buf[1024];
  55.      int numchars;
  56.      char method[255];
  57.      char url[255];
  58.      char path[512];
  59.      size_t i, j;
  60.      struct stat st;  //文件状态
  61.      // 指定是cgi程序的标记
  62.      int cgi = 0;      /* becomes true if server decides this is a CGI
  63.                         * program */
  64.      char *query_string = NULL;
  66.      // 获得请求的第一行
  67.      numchars = get_line(client, buf, sizeof(buf));
  68.      i = 0;
  69.      j = 0;
  71.      //把请求方法存到method数组
  72.      while (!ISspace(buf[j]) && (i < sizeof(method) - 1))
  73.      {
  74.           method[i] = buf[j];
  75.           i++;
  76.           j++;
  77.      }
  78.      // 结束标记
  79.      method[i] = '\0';
  81.      // 如果不是GET也不是POST，则无法处理
  82.      if (strcasecmp(method, "GET") && strcasecmp(method, "POST"))
  83.      {
  84.           unimplemented(client);
  85.           return NULL;
  86.      }
  88.      // POST请求，开启cgi
  89.      if (strcasecmp(method, "POST") == 0)
  90.           cgi = 1;
  92.      i = 0;
  93.      // 读取 URL. j用于定位URL的位置,i作为储存url数组的index
  94.      while (ISspace(buf[j]) && (j < sizeof(buf)))
  95.           // 略过空格字符
  96.           j++;
  97.      while (!ISspace(buf[j]) && (i < sizeof(url) - 1) && (j < sizeof(buf)))
  98.      {
  99.           url[i] = buf[j];
  100.           i++;
  101.           j++;
  102.      }
  103.      url[i] = '\0';
  105.      if (strcasecmp(method, "GET") == 0)
  106.      {
  107.           // 处理GET method
  108.           query_string = url;
  109.           while ((*query_string != '?') && (*query_string != '\0'))
  110.                query_string++;
  111.           if (*query_string == '?')
  112.           {
  113.                // 开启cgi
  114.                cgi = 1;
  115.                *query_string = '\0';
  116.                query_string++;
  117.           }
  118.      }
  119.      // 格式化url到path数组，html文件都在htdocs中
  120.      sprintf(path, "htdocs%s", url);
  122.      if (path[strlen(path) - 1] == '/')
  123.           // 默认情况为访问index.html
  124.           strcat(path, "index.html");
  126.      if (stat(path, &st) == -1) {
  127.           // 找不到文件，则把所有的headers的信息都丢弃
  128.           while ((numchars > 0) && strcmp("\n", buf))  /* read & discard headers */
  129.                numchars = get_line(client, buf, sizeof(buf));
  130.           not_found(client);   //发送寻找失败的信息
  131.      }
  132.      else
  133.      {
  134.           if ((st.st_mode & S_IFMT) == S_IFDIR)
  135.                // 如果找到的是目录，访问目录下的index.html
  136.                strcat(path, "/index.html");
  137.           if ((st.st_mode & S_IXUSR) ||
  138.               (st.st_mode & S_IXGRP) ||
  139.               (st.st_mode & S_IXOTH)    )
  140.                // 如果： 文件所有者具有可执行权限 或是 用户组具有可执行权限 或是 其它用户具有可执行权限，则设置cgi
  141.                cgi = 1;
  142.           if (!cgi)
  143.                // 不是cgi, 把服务器文件返回，否则执行cgi
  144.                serve_file(client, path);
  145.           else
  146.                // 执行cgi
  147.                execute_cgi(client, path, method, query_string);
  148.      }
  150.      // 断开与客户端的链接，http具有无连接特点,每次连接只处理一个请求
  151.      close(client);
  152.      return NULL;
  153. }
  155. /**********************************************************************/
  156. /* Inform the client that a request it has made has a problem.
  157.  * Parameters: client socket */
  158. /**********************************************************************/
  159. void bad_request(int client)
  160. {
  161.      char buf[1024];
  163.      // 回应客户端错误的HTTP请求
  164.      sprintf(buf, "HTTP/1.0 400 BAD REQUEST\r\n");
  165.      send(client, buf, sizeof(buf), 0);
  166.      sprintf(buf, "Content-type: text/html\r\n");
  167.      send(client, buf, sizeof(buf), 0);
  168.      sprintf(buf, "\r\n");
  169.      send(client, buf, sizeof(buf), 0);
  170.      sprintf(buf, "<P>Your browser sent a bad request, ");
  171.      send(client, buf, sizeof(buf), 0);
  172.      sprintf(buf, "such as a POST without a Content-Length.\r\n");
  173.      send(client, buf, sizeof(buf), 0);
  174. }
  176. /**********************************************************************/
  177. /* Put the entire contents of a file out on a socket.  This function
  178.  * is named after the UNIX "cat" command, because it might have been
  179.  * easier just to do something like pipe, fork, and exec("cat").
  180.  * Parameters: the client socket descriptor
  181.  *             FILE pointer for the file to cat */
  182. /**********************************************************************/
  183. void cat(int client, FILE *resource)
  184. {
  185.      char buf[1024];
  187.      // 读取文件中的所有数据写到socket中
  188.      fgets(buf, sizeof(buf), resource);
  189.      while (!feof(resource))
  190.      {
  191.           send(client, buf, strlen(buf), 0);
  192.           fgets(buf, sizeof(buf), resource);
  193.      }
  194. }
  196. /**********************************************************************/
  197. /* Inform the client that a CGI script could not be executed.
  198.  * Parameter: the client socket descriptor. */
  199. /**********************************************************************/
  200. void cannot_execute(int client)
  201. {
  202.      char buf[1024];
  204.      // 回应客户端 cgi无法执行
  205.      sprintf(buf, "HTTP/1.0 500 Internal Server Error\r\n");
  206.      send(client, buf, strlen(buf), 0);
  207.      sprintf(buf, "Content-type: text/html\r\n");
  208.      send(client, buf, strlen(buf), 0);
  209.      sprintf(buf, "\r\n");
  210.      send(client, buf, strlen(buf), 0);
  211.      sprintf(buf, "<P>Error prohibited CGI execution.\r\n");
  212.      send(client, buf, strlen(buf), 0);
  213. }
  215. /**********************************************************************/
  216. /* Print out an error message with perror() (for system errors; based
  217.  * on value of errno, which indicates system call errors) and exit the
  218.  * program indicating an error. */
  219. /**********************************************************************/
  220. void error_die(const char *sc)
  221. {
  222.      // 显示出错信息
  223.      perror(sc);
  224.      exit(1);
  225. }
  227. /**********************************************************************/
  228. /* Execute a CGI script.  Will need to set environment variables as
  229.  * appropriate.
  230.  * Parameters: client socket descriptor
  231.  *             path to the CGI script */
  232. /**********************************************************************/
  233. void execute_cgi(int client, const char *path,
  234.                  const char *method, const char *query_string)
  235. {
  236.      char buf[1024];
  237.      int cgi_output[2];
  238.      int cgi_input[2];
  239.      pid_t pid;
  240.      int status;
  241.      int i;
  242.      char c;
  243.      int numchars = 1;
  244.      int content_length = -1;
  246.      buf[0] = 'A';
  247.      buf[1] = '\0';
  248.      if (strcasecmp(method, "GET") == 0)
  249.           // GET请求下，把所有的HTTP header读取并丢弃
  250.           while ((numchars > 0) && strcmp("\n", buf))  /* read & discard headers */
  251.                numchars = get_line(client, buf, sizeof(buf));
  252.      else    /* POST */
  253.      {
  254.           // 找出 content_length
  255.           numchars = get_line(client, buf, sizeof(buf));
  256.           while ((numchars > 0) && strcmp("\n", buf))
  257.           {
  258.                // 使用 \0 进行分隔
  259.                buf[15] = '\0';
  261.                if (strcasecmp(buf, "Content-Length:") == 0)
  262.                     // 找到Content-Length并且处理
  263.                     content_length = atoi(&(buf[16]));
  264.                numchars = get_line(client, buf, sizeof(buf));
  265.           }
  266.           if (content_length == -1) {
  267.                // 找不到Content-Length,发送请求错误信息
  268.                bad_request(client);
  269.                return;
  270.           }
  271.      }
  273.      // HTTP 状态码 200
  274.      sprintf(buf, "HTTP/1.0 200 OK\r\n");
  275.      send(client, buf, strlen(buf), 0);
  277.      // 建立管道
  278.      if (pipe(cgi_output) < 0) {
  279.           // 错误处理
  280.           cannot_execute(client);
  281.           return;
  282.      }
  283.      if (pipe(cgi_input) < 0) {
  284.           cannot_execute(client);
  285.           return;
  286.      }
  288.      // 建立一个进程进行处理
  289.      if ( (pid = fork()) < 0 ) {
  290.           cannot_execute(client);
  291.           return;
  292.      }
  293.      if (pid == 0)  /* child: CGI script */
  294.      {
  295.           // 子进程处理CGI部分
  296.           char meth_env[255];
  297.           char query_env[255];
  298.           char length_env[255];
  300.           // 把 stdout 重定向到 cgi_output的写入端
  301.           dup2(cgi_output[1], 1);
  302.           // 把 stdin 重定向到 cgi_input的读取端
  303.           dup2(cgi_input[0], 0);
  304.           // 关闭cgi_input的写入端和cgi_output的读取端
  305.           close(cgi_output[0]);
  306.           close(cgi_input[1]);
  308.           // 设置request_method的环境变量
  309.           sprintf(meth_env, "REQUEST_METHOD=%s", method);
  310.           putenv(meth_env);
  311.           if (strcasecmp(method, "GET") == 0) {
  312.                // 设置 query_string 的环境变量
  313.                sprintf(query_env, "QUERY_STRING=%s", query_string);
  314.                putenv(query_env);
  315.           }
  316.           else {   /* POST */
  317.                // 设置 content_length的环境变量
  318.                sprintf(length_env, "CONTENT_LENGTH=%d", content_length);
  319.                putenv(length_env);
  320.           }
  321.           // 用execl运行cgi程序
  322.           execl(path, query_string, NULL);
  323.           exit(0);
  324.      }
  325.      else
  326.      {    /* parent */
  327.           // 父进程处理部分，关闭cgi_output的写入端和cgi_input的读取端
  328.           close(cgi_output[1]);
  329.           close(cgi_input[0]);
  331.           if (strcasecmp(method, "POST") == 0)
  332.                // 接收POST过来的数据
  333.                for (i = 0; i < content_length; i++) {
  334.                     recv(client, &c, 1, 0);
  335.                     // 把POST数据写入cgi_input（重定向到stdin）
  336.                     write(cgi_input[1], &c, 1);
  337.                }
  338.           // 读取cgi_output的管道输出到客户端(管道的输入是stdin)
  339.           while (read(cgi_output[0], &c, 1) > 0)
  340.                send(client, &c, 1, 0);
  342.           // 关闭管道
  343.           close(cgi_output[0]);
  344.           close(cgi_input[1]);
  345.           // 等待子进程
  346.           waitpid(pid, &status, 0);
  347.      }
  348. }
  350. /**********************************************************************/
  351. /* Get a line from a socket, whether the line ends in a newline,
  352.  * carriage return, or a CRLF combination.  Terminates the string read
  353.  * with a null character.  If no newline indicator is found before the
  354.  * end of the buffer, the string is terminated with a null.  If any of
  355.  * the above three line terminators is read, the last character of the
  356.  * string will be a linefeed and the string will be terminated with a
  357.  * null character.
  358.  * Parameters: the socket descriptor
  359.  *             the buffer to save the data in
  360.  *             the size of the buffer
  361.  * Returns: the number of bytes stored (excluding null) */
  362. /**********************************************************************/
  363. /*
  364.   int sock: 套接字描述符
  365.   char *buf: 用于储存收到数据的缓冲区
  366.   int size: 缓冲区大小
  367.  */
  368. int get_line(int sock, char *buf, int size)
  369. {
  370.      int i = 0;
  371.      char c = '\0';
  372.      int n;
  374.      while ((i < size - 1) && (c != '\n'))
  375.      {
  376.           // 一次接受一个字节
  377.           n = recv(sock, &c, 1, 0);
  378.           /* DEBUG printf("%02X\n", c); */
  379.           if (n > 0)
  380.           {
  381.                // n大于0说明收到了数据（收到一个字节）
  382.                if (c == '\r')
  383.                {
  384.                     // 如果收到'\r',则再接受一个字节，用于处理换行符为\r\n的情况
  385.                     n = recv(sock, &c, 1, MSG_PEEK); //MSG_PEEK标记用于防止读取成功后从tcp buffer中删除已读取的数据
  386.                     /* DEBUG printf("%02X\n", c); */
  387.                     if ((n > 0) && (c == '\n'))
  388.                          // 读取
  389.                          recv(sock, &c, 1, 0);
  390.                     else
  391.                          // 使得buf统一以\n结尾
  392.                          c = '\n';
  393.                }
  394.                // 把收到的字节储存起来
  395.                buf[i] = c;
  396.                i++; //收到一个字节累加一次
  397.           }
  398.           else
  399.                c = '\n';  //统一让buf数组以\n结尾
  400.      }
  401.      buf[i] = '\0';
  402.      return(i); // 返回收到并存储的字节数
  403. }
  405. /**********************************************************************/
  406. /* Return the informational HTTP headers about a file. */
  407. /* Parameters: the socket to print the headers on
  408.  *             the name of the file */
  409. /**********************************************************************/
  410. void headers(int client, const char *filename)
  411. {
  412.      char buf[1024];
  413.      (void)filename;  /* could use filename to determine file type */
  415.      // 发送http头
  416.      strcpy(buf, "HTTP/1.0 200 OK\r\n");
  417.      send(client, buf, strlen(buf), 0);
  418.      strcpy(buf, SERVER_STRING);
  419.      send(client, buf, strlen(buf), 0);
  420.      sprintf(buf, "Content-Type: text/html\r\n");
  421.      send(client, buf, strlen(buf), 0);
  422.      strcpy(buf, "\r\n");
  423.      send(client, buf, strlen(buf), 0);
  424. }
  426. /**********************************************************************/
  427. /* Give a client a 404 not found status message. */
  428. /**********************************************************************/
  429. void not_found(int client)
  430. {
  431.      char buf[1024];
  433.      // 404页面
  434.      sprintf(buf, "HTTP/1.0 404 NOT FOUND\r\n");
  435.      send(client, buf, strlen(buf), 0);
  436.      sprintf(buf, SERVER_STRING);
  437.      send(client, buf, strlen(buf), 0);
  438.      sprintf(buf, "Content-Type: text/html\r\n");
  439.      send(client, buf, strlen(buf), 0);
  440.      sprintf(buf, "\r\n");
  441.      send(client, buf, strlen(buf), 0);
  442.      sprintf(buf, "<HTML><TITLE>Not Found</TITLE>\r\n");
  443.      send(client, buf, strlen(buf), 0);
  444.      sprintf(buf, "<BODY><P>The server could not fulfill\r\n");
  445.      send(client, buf, strlen(buf), 0);
  446.      sprintf(buf, "your request because the resource specified\r\n");
  447.      send(client, buf, strlen(buf), 0);
  448.      sprintf(buf, "is unavailable or nonexistent.\r\n");
  449.      send(client, buf, strlen(buf), 0);
  450.      sprintf(buf, "</BODY></HTML>\r\n");
  451.      send(client, buf, strlen(buf), 0);
  452. }
  454. /**********************************************************************/
  455. /* Send a regular file to the client.  Use headers, and report
  456.  * errors to client if they occur.
  457.  * Parameters: a pointer to a file structure produced from the socket
  458.  *              file descriptor
  459.  *             the name of the file to serve */
  460. /**********************************************************************/
  461. void serve_file(int client, const char *filename)
  462. {
  463.      FILE *resource = NULL;
  464.      int numchars = 1;
  465.      char buf[1024];
  467.      buf[0] = 'A';
  468.      buf[1] = '\0';
  469.      // 读取并丢弃header
  470.      while ((numchars > 0) && strcmp("\n", buf))  /* read & discard headers */
  471.           numchars = get_line(client, buf, sizeof(buf));
  473.      resource = fopen(filename, "r");
  474.      // 打开server文件爱你
  475.      if (resource == NULL)
  476.           not_found(client);
  477.      else
  478.      {
  479.           // 写http头并且复制文件
  480.           headers(client, filename);
  481.           cat(client, resource);
  482.      }
  483.      fclose(resource);
  484. }
  486. /**********************************************************************/
  487. /* This function starts the process of listening for web connections
  488.  * on a specified port.  If the port is 0, then dynamically allocate a
  489.  * port and modify the original port variable to reflect the actual
  490.  * port.
  491.  * Parameters: pointer to variable containing the port to connect on
  492.  * Returns: the socket */
  493. /**********************************************************************/
  494. int startup(u_short *port)
  495. {
  496.      int httpd = 0;
  497.      struct sockaddr_in name;
  499.      // 建立socket
  500.      httpd = socket(PF_INET, SOCK_STREAM, 0);
  501.      if (httpd == -1)
  502.           // 建立失败
  503.           error_die("socket");
  505.      //初始化
  506.      memset(&name, 0, sizeof(name));
  507.      name.sin_family = AF_INET;
  508.      name.sin_port = htons(*port);
  509.      name.sin_addr.s_addr = htonl(INADDR_ANY);
  511.      if (bind(httpd, (struct sockaddr *)&name, sizeof(name)) < 0)
  512.           error_die("bind");
  513.      if (*port == 0)  /* if dynamically allocating a port */
  514.      {
  515.           // 动态随机分配一个端口
  516.           socklen_t namelen = sizeof(name);
  517.           if (getsockname(httpd, (struct sockaddr *)&name, &namelen) == -1)
  518.                error_die("getsockname");
  519.           *port = ntohs(name.sin_port);
  520.      }
  521.      //监听
  522.      if (listen(httpd, 5) < 0)
  523.           error_die("listen");
  524.      // 返回socket id
  525.      return(httpd);
  526. }
  528. /**********************************************************************/
  529. /* Inform the client that the requested web method has not been
  530.  * implemented.
  531.  * Parameter: the client socket */
  532. /**********************************************************************/
  533. void unimplemented(int client)
  534. {
  535.      char buf[1024];
  536.      *buf = '\0' //方便进行strcat
  538.      // HTTP method 不被支持
  539.      strcat(buf, "HTTP/1.0 501 Method Not Implemented\r\n");
  540.      strcat(buf, SERVER_STRING);
  541.      strcat(buf, "Content-Type: text/html\r\n\r\n<HTML><HEAD><TITLE>Method Not Implemented\r\n</TITLE></HEAD>\r\n<BODY><P>HTTP request method not supported.\r\n</BODY></HTML>\r\n");
  542.      printf("%s\n",buf);
  543.      send(client, buf, strlen(buf), 0);
  544.      /*
  545.      sprintf(buf, "HTTP/1.0 501 Method Not Implemented\r\n");
  546.      send(client, buf, strlen(buf), 0);
  548.      // 输出服务器信息到网页上
  549.      sprintf(buf, SERVER_STRING);
  550.      send(client, buf, strlen(buf), 0);
  551.      sprintf(buf, "Content-Type: text/html\r\n");
  552.      send(client, buf, strlen(buf), 0);
  553.      sprintf(buf, "\r\n");
  554.      send(client, buf, strlen(buf), 0);
  555.      sprintf(buf, "<HTML><HEAD><TITLE>Method Not Implemented\r\n");
  556.      send(client, buf, strlen(buf), 0);
  557.      sprintf(buf, "</TITLE></HEAD>\r\n");
  558.      send(client, buf, strlen(buf), 0);
  559.      sprintf(buf, "<BODY><P>HTTP request method not supported.\r\n");
  560.      send(client, buf, strlen(buf), 0);
  561.      sprintf(buf, "</BODY></HTML>\r\n");
  562.      send(client, buf, strlen(buf), 0);
  563.      */
  564. }
  566. /**********************************************************************/
  568. int main(void)
  569. {
  570.      int server_sock = -1;
  571.      u_short port = 0; //端口为0
  572.      int client_sock = -1;
  573.      struct sockaddr_in client_name;
  574.      socklen_t client_name_len = sizeof(client_name);
  575.      pthread_t newthread;
  577.      server_sock = startup(&port);  //服务器端监听套接字设置
  578.      printf("httpd running on port %d\n", port);
  580.      while (1)
  581.      {
  582.           // 主线程阻塞等待客户端请求
  583.           client_sock = accept(server_sock,
  584.                                (struct sockaddr *)&client_name,
  585.                                &client_name_len);
  586.           if (client_sock == -1)
  587.                error_die("accept");
  588.           /* accept_request(client_sock); */
  589.           // 监听到请求,则创建工作线程.
  590.           if (pthread_create(&newthread , NULL, accept_request, (void*)&client_sock) != 0)
  591.                perror("pthread_create");
  592.      }
  594.      // 关闭套接字,关闭TCP连接
  595.      close(server_sock);
  597.      return(0);
  598. }
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注