Nginx HTTP之请求行解析函数ngx_http_parse_request_line

╰+攻爆jí腚メ 2022-04-16 03:24 245阅读 0赞

Nginx的HTTP模块中使用ngx_http_parse_request_line函数来对读取的请求行进行解析，HTTP请求行的格式不是很复杂，但是要注意HTTP 0.9与1.0、1.1之间的区别；另外，作为Nginx的第一个版本，里面支持的请求方法也只有GET、POST和HEAD。

  1. /* http/ngx_http_parse.c */
  3. /* 解析HTTP请求行
  4.  * param r: 待处理的HTTP请求
  5.  *       b: 存放请求行内容的缓冲区
  6.  * return : 成功解析完整的请求行时返回NGX_OK;
  7.  *          成功解析了部分请求行时返回NGX_AGAIN;
  8.  *          否则返回其他
  9.  */
  10. ngx_int_t ngx_http_parse_request_line(ngx_http_request_t *r, ngx_buf_t *b)
  11. {
  12.     // HTTP 0.9    请求行格式: [请求方法][空格..空格][URL](空格..空格)(回车符)[换行符]
  13.     // HTTP >= 1.0 请求行格式: [请求方法][空格..空格][URL][空格..空格][协议版本][回车符][换行符]
  15.     u_char  ch, *p, *m;
  17.     enum {
  18.         sw_start = 0,             // 初始状态
  19.         sw_method,                // 解析请求方法
  20.         sw_space_after_method,    // 解析请求方法后紧跟的一个空格
  21.         sw_spaces_before_uri,     // 解析URL前可能存在的多余空格
  22.         sw_schema,                // 解析schema(http/https)
  23.         sw_schema_slash,          // 解析<schema>:后紧跟的一个/
  24.         sw_schema_slash_slash,    // 解析<schema>:/后紧跟的一个/
  25.         sw_host,                  // 解析<schema>://后紧跟的主机(域名/IP)
  26.         sw_port,                  // 解析<schema>://<host>:后紧跟的端口
  27.         sw_after_slash_in_uri,    // 解析URL路径中/后的内容
  28.         sw_check_uri,             // ?
  29.         sw_uri,                   // ?
  30.         sw_http_09,               // 解析URL后紧跟空格后的内容
  31.         sw_http_H,                // 解析协议版本的第二个字符T
  32.         sw_http_HT,               // 解析协议版本的第三个字符T
  33.         sw_http_HTT,              // 解析协议版本的第四个字符P
  34.         sw_http_HTTP,             // 解析协议版本的第五个字符/
  35.         sw_first_major_digit,     // 解析协议版本的主版本号的第一个数字
  36.         sw_major_digit,           // 解析协议版本的主版本号第一个数字后的数字或者.
  37.         sw_first_minor_digit,     // 解析协议版本的次版本号的第一个数字
  38.         sw_minor_digit,           // 解析协议版本的次版本号第一个数字后的数字
  39.         sw_almost_done,           // 解析结束的\n
  40.         sw_done                   // 解析完成
  41.     } state;                      // 枚举变量: HTTP请求行解析状态
  43.     // 获取请求r的当前状态state
  44.     state = r->state;
  45.     // 获取缓冲区b的有效内容起始地址p
  46.     p = b->pos;
  48.     while (p < b->last && state < sw_done) {
  49.         // p小于b->last时, 表明缓冲区内的有效内容不为空;
  50.         // state小于sw_done, 表明未解析完成
  52.         // ch指向缓冲区有效内容的第一个字符, p后移一位
  53.         ch = *p++;
  55.         switch (state) {
  57.         /* HTTP methods: GET, HEAD, POST */
  58.         case sw_start:
  59.             // 当前状态为sw_start即起始状态
  61.             // 置r->request_start为p-1, 也就是当前字符的位置
  62.             r->request_start = p - 1;
  64.             if (ch == CR || ch == LF) {
  65.                 // 如果当前字符为\r或者\n
  67.                 // 跳过
  68.                 break;
  69.             }
  71.             if (ch < 'A' || ch > 'Z') {
  72.                 // 如果当前字符不是大写字母
  74.                 // 请求方法必须是由大写字母组成的, 所以返回NGX_HTTP_PARSE_INVALID_METHOD,
  75.                 // 从字面上可以看出, 这个返回值表示无效的请求方法
  76.                 return NGX_HTTP_PARSE_INVALID_METHOD;
  77.             }
  79.             // 置state为sw_method, 表示解析请求方法
  80.             state = sw_method;
  81.             break;
  83.         case sw_method:
  84.             // 当前状态为解析请求方法
  86.             if (ch == ' ') {
  87.                 // 如果当前字符为空格
  89.                 // 说明遇到了请求方法后面的空格了, p-2即为请求方法的最后一个字符
  90.                 // 置r->method_end为p-1, 记录请求方法的结束位置
  91.                 r->method_end = p - 1;
  92.                 // r->request_start此时指向的是请求方法的第一个字符
  93.                 m = r->request_start;
  95.                 if (r->method_end - m == 3) {
  96.                     // 如果请求方法子字符串的长度为3
  98.                     if (m[0] == 'G' && m[1] == 'E' && m[2] == 'T') {
  99.                         // 如果请求方法子字符串为GET
  101.                         // 置r->method为NGX_HTTP_GET
  102.                         r->method = NGX_HTTP_GET;
  103.                     }
  105.                 } else if (r->method_end - m == 4) {
  106.                     // 如果请求方法子字符串的长度为4
  108.                     if (m[0] == 'P' && m[1] == 'O'
  109.                         && m[2] == 'T' && m[3] == 'T')
  110.                     {
  111.                         // 如果请求方法子字符串为POST
  113.                         // 置r->method为NGX_HTTP_POST
  114.                         r->method = NGX_HTTP_POST;
  116.                     } else if (m[0] == 'H' && m[1] == 'E'
  117.                                && m[2] == 'A' && m[3] == 'D')
  118.                     {
  119.                         // 如果请求方法子字符串为HEAD
  121.                         // 置r->method为NGX_HTTP_HEAD
  122.                         r->method = NGX_HTTP_HEAD;
  123.                     }
  124.                 }
  126.                 // 解析完请求方法, 置state为sw_spaces_before_uri, 表示解析URL前面的空格
  127.                 // 因为此处已经解析到一个请求方法后的空格, 所以跳过状态sw_space_after_method,
  128.                 state = sw_spaces_before_uri;
  129.                 break;
  130.             }
  132.             if (ch < 'A' || ch > 'Z') {
  133.                 // 如果当前字符不是大写字母
  135.                 // 返回NGX_HTTP_PARSE_INVALID_METHOD
  136.                 return NGX_HTTP_PARSE_INVALID_METHOD;
  137.             }
  139.             break;
  141.         case sw_space_after_method:
  142.             // 当前状态为解析请求方法后紧跟的一个空格
  144.             switch (ch) {
  145.             case ' ':
  146.                 // 如果当前字符为空格
  148.                 // 置state为sw_spaces_before_uri, URL前面可能还有空格
  149.                 state = sw_spaces_before_uri;
  150.                 break;
  151.             default:
  152.                 // 如果当前字符为非空格的字符
  154.                 // 请求方法和URL之间至少需要一个空格,
  155.                 // 返回NGX_HTTP_PARSE_INVALID_METHOD
  156.                 return NGX_HTTP_PARSE_INVALID_METHOD;
  157.             }
  158.             break;
  160.         case sw_spaces_before_uri:
  161.             // 当前状态为解析URL前可能存在的多余空格
  163.             switch (ch) {
  164.             case '/':
  165.                 // 如果当前字符为/, 说明遇到URL的第一个字符
  167.                 // 置r->uri_start为p-1, 记录URL的起始位置
  168.                 r->uri_start = p - 1;
  169.                 // 置state为sw_after_slash_in_uri, 表示解析URL路径中/后的内容
  170.                 state = sw_after_slash_in_uri;
  171.                 break;
  172.             case ' ':
  173.                 // 如果当前字符为空格
  175.                 // 直接跳过
  176.                 break;
  177.             default:
  178.                 if ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z')) {
  179.                     // 如果当前字符为大小写字母, 说明遇到schema(http/https)的第一个字符了
  181.                     // 置r->schema_start为p-1, 记录schema的起始位置
  182.                     r->schema_start = p - 1;
  183.                     // 置state为sw_schema, 表示解析schema
  184.                     state = sw_schema;
  185.                     break;
  186.                 }
  187.                 // 当前字符为其他字符, 表示请求有误, 返回NGX_HTTP_PARSE_INVALID_REQUEST,
  188.                 // 即无效请求
  189.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  190.             }
  191.             break;
  193.         case sw_schema:
  194.             // 当前状态为解析schema
  196.             switch (ch) {
  197.             case ':':
  198.                 // 如果当前字符为：, 说明遇到schema的后一个字符了
  200.                 // 置r->schema_end为p-1, 记录schema的结束位置
  201.                 r->schema_end = p - 1;
  202.                 // 置state为sw_schema_slash, 表示解析<schema>:后紧跟的一个/
  203.                 state = sw_schema_slash;
  204.                 break;
  205.             default:
  206.                 if ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z')) {
  207.                     // 如果当前字符是大小写字符, 说明是我们想要的
  209.                     // 直接跳过
  210.                     break;
  211.                 }
  212.                 // 当前字符为其他字符, 返回NGX_HTTP_PARSE_INVALID_REQUEST
  213.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  214.             }
  215.             break;
  217.         case sw_schema_slash:
  218.             // 当前状态为解析<schema>:后紧跟的一个/
  219.             switch (ch) {
  220.             case '/':
  221.                 // 如果当前字符正是/
  223.                 // 置state为sw_schema_slash_slash, 解析紧跟的一个/
  224.                 state = sw_schema_slash_slash;
  225.                 break;
  226.             default:
  227.                 // 当前字符不为/, 返回NGX_HTTP_PARSE_INVALID_REQUEST
  228.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  229.             }
  230.             break;
  232.         case sw_schema_slash_slash:
  233.             // 当前状态为解析<schema>:/后紧跟的一个/
  235.             switch (ch) {
  236.             case '/':
  237.                 // 如果当前字符正是/
  239.                 // 置r->host_start为p-1, 记录URL中主机的起始位置
  240.                 r->host_start = p - 1;
  241.                 // 置state为sw_host, 表示解析<schema>://后紧跟的主机
  242.                 state = sw_host;
  243.                 break;
  244.             default:
  245.                 // 当前字符不为/, 返回NGX_HTTP_PARSE_INVALID_REQUEST
  246.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  247.             }
  248.             break;
  250.         case sw_host:
  251.             // 当前状态为解析<schema>://后紧跟的主机
  253.             switch (ch) {
  254.             case ':':
  255.                 // 如果当前字符为:, 说明遇到主机后紧跟的一个:了
  257.                 // 置r->host_end为p-1, 记录主机的结束位置
  258.                 r->host_end = p - 1;
  259.                 // 置state为sw_port, 因为遇到主机后紧跟的:了, 那么此:后需要跟着端口号
  260.                 state = sw_port;
  261.                 break;
  262.             case '/':
  263.                 // 如果当前字符是/, 因为主机后的:<port>不是必须的,
  264.                 // 说明遇到主机后紧跟的一个/了
  266.                 // 置r->host_end为p-1, 记录主机的结束位置
  267.                 r->host_end = p - 1;
  268.                 // 置r->uri_start为p-1, 记录URL中路径的起始地址
  269.                 r->uri_start = p - 1;
  270.                 // 置state为sw_after_slash_in_uri, 表示解析URL路径中/后的内容
  271.                 state = sw_after_slash_in_uri;
  272.                 break;
  273.             default:
  274.                 if ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z')
  275.                     || (ch >= '0' && ch <= '9') || ch == '.' || ch == '-')
  276.                 {
  277.                     // 如果当前字符为大小写字母、数字、.、-, 说明是主机(域名/IP)的有效字符
  279.                     // 直接跳过
  280.                     break;
  281.                 }
  282.                 // 当前字符为其他字符, 返回NGX_HTTP_PARSE_INVALID_REQUEST
  283.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  284.             }
  285.             break;
  287.         case sw_port:
  288.             // 当前状态为解析<schema>://<host>:后紧跟的端口
  289.             switch (ch) {
  290.             case '/':
  291.                 // 如果当前字符为/, 说明遇到端口后紧跟的一个/了
  293.                 // 置r->port_end为p-1, 记录端口的结束位置
  294.                 r->port_end = p - 1;
  295.                 // 置r->uri_start为p-1, 记录URL中路径的起始位置
  296.                 r->uri_start = p - 1;
  297.                 // 置state为sw_after_slash_in_uri, 表示解析URL路径中/后的内容
  298.                 state = sw_after_slash_in_uri;
  299.                 break;
  300.             default:
  301.                 if (ch < '0' && ch > '9') {
  302.                     // 如果当前字符不为数字, 端口必须由数字组成, 说明是非法字符
  303.                     // 返回NGX_HTTP_PARSE_INVALID_REQUEST
  304.                     return NGX_HTTP_PARSE_INVALID_REQUEST;
  305.                 }
  306.                 break;
  307.             }
  308.             break;
  310.         case sw_after_slash_in_uri:
  311.             // 当前状态为解析URL路径中/后的内容
  312.             switch (ch) {
  313.             case CR:
  314.                 // 如果当前字符为\r, 说明可能是HTTP 0.9
  316.                 // 置r->uri_end为p-1, 记录URL中路径的结束位置
  317.                 r->uri_end = p - 1;
  318.                 // 置r->http_minor为9
  319.                 r->http_minor = 9;
  320.                 // 置state为sw_almost_done, 表示解析结束的\n
  321.                 state = sw_almost_done;
  322.                 break;
  323.             case LF:
  324.                 // 如果当前字符为\n, 说明可能是HTTP 0.9
  326.                 // 置r->uri_end为p-1, 记录URL中路径的结束位置
  327.                 r->uri_end = p - 1;
  328.                 // 置r->http_minor为9
  329.                 r->http_minor = 9;
  330.                 // 置state为sw_done, 表示解析完成
  331.                 state = sw_done;
  332.                 break;
  333.             case ' ':
  334.                 // 如果当前字符为空格, 表示遇到URL(或者路径)后紧跟的一个空格
  336.                 // 置r->uri_end为p-1, 记录URL中路径的结束位置
  337.                 r->uri_end = p - 1;
  338.                 // 置state为sw_http_09, 表示解析URL后紧跟空格后的内容
  339.                 state = sw_http_09;
  340.                 break;
  341.             case '.':
  342.             case '%':
  343.                 // 如果当前字符为.或者%, 说明是复杂的URL
  345.                 // 置r->complex_uri为1
  346.                 r->complex_uri = 1;
  347.                 // 置state为sw_uri
  348.                 state = sw_uri;
  349.                 break;
  350.             case '/':
  351.                 // 如果当前字符为/
  353.                 // 置r->complex_uri为1
  354.                 // 因为仍要解析/后的内容, 因此state不变
  355.                 r->complex_uri = 1;
  356.                 break;
  357.             case '?':
  358.                 // 如果当前字符为?, 说明遇到了URL中的参数
  360.                 // 置r->args_start为p, 记录参数的起始位置
  361.                 r->args_start = p;
  362.                 // 置state为sw_uri
  363.                 state = sw_uri;
  364.                 break;
  365.             default:
  366.                 // 如果当前字符为其他字符
  367.                 // 置state为sw_check_uri
  368.                 state = sw_check_uri;
  369.                 break;
  370.             }
  371.             break;
  373.         case sw_check_uri:
  374.             // 当前状态为sw_check_uri
  376.             switch (ch) {
  377.             case CR:
  378.                 // 如果当前字符为\r, 说明遇到了URL后紧跟的\r
  380.                 // 置r->uri_end为p-1, 记录URL的结束位置
  381.                 r->uri_end = p - 1;
  382.                 // 显然是HTTP 0.9, 置r->http_minor为9
  383.                 r->http_minor = 9;
  384.                 // 置state为sw_almost_done, 表示解析结束的\n
  385.                 state = sw_almost_done;
  386.                 break;
  387.             case LF:
  388.                 // 如果当前字符为\n, 说明遇到了URL后紧跟的\n
  390.                 // 置r->uri_end为p-1, 记录URL的结束位置
  391.                 r->uri_end = p - 1;
  392.                 // 显然是HTTP 0.9, 置r->http_minor为9
  393.                 r->http_minor = 9;
  394.                 // 置state为sw_done, 表示解析完成
  395.                 state = sw_done;
  396.                 break;
  397.             case ' ':
  398.                 // 如果当前字符为空格, 表明遇到URL后紧跟的一个空格
  400.                 // 置r->uri_end为p-1, 记录URL的结束位置
  401.                 r->uri_end = p - 1;
  402.                 // 置state为sw_http_09, 表示解析URL后紧跟空格后的内容
  403.                 state = sw_http_09;
  404.                 break;
  405.             case '.':
  406.                 // 如果当前字符为., 表明遇到扩展名
  408.                 // 置r->uri_ext为p, 记录扩展名的起始位置
  409.                 r->uri_ext = p;
  410.                 break;
  411.             case '/':
  412.                 // 如果当前字符为/ 
  414.                 // 那么之前记录的"扩展名"其实不是真的扩展名, 置r->uri_ext为空
  415.                 r->uri_ext = NULL;
  416.                 // 置state为sw_after_slash_in_uri, 因为仍在解析URL且遇到了/
  417.                 state = sw_after_slash_in_uri;
  418.                 break;
  419.             case '%':
  420.                 // 如果当前字符为%, 表明是复杂的URL
  422.                 // 置r->complex_uri为1
  423.                 r->complex_uri = 1;
  424.                 // 置state为sw_uri
  425.                 state = sw_uri;
  426.                 break;
  427.             case '?':
  428.                 // 如果当前字符为?, 表明遇到了参数
  430.                 // 置r->args_start为p, 记录参数的起始位置
  431.                 r->args_start = p;
  432.                 // 置state为sw_uri
  433.                 state = sw_uri;
  434.                 break;
  435.             }
  436.             break;
  438.         case sw_uri:
  439.             // 当前状态为sw_uri
  441.             switch (ch) {
  442.             case CR:
  443.                 // 如果当前字符为\r, 说明遇到了URL后紧跟的\r
  445.                 // 置r->uri_end为p-1, 记录URL的结束位置
  446.                 r->uri_end = p - 1;
  447.                 // 显然是HTTP 0.9, 置r->http_minor为9
  448.                 r->http_minor = 9;
  449.                 // 置state为sw_almost_done, 表示解析结束的\n
  450.                 state = sw_almost_done;
  451.                 break;
  452.             case LF:
  453.                 // 如果当前字符为\n, 说明遇到了URL后紧跟的\n
  455.                 // 置r->uri_end为p-1, 记录URL的结束位置
  456.                 r->uri_end = p - 1;
  457.                 // 显然是HTTP 0.9, 置r->http_minor为9
  458.                 r->http_minor = 9;
  459.                 // 置state为sw_done, 表示解析完成
  460.                 state = sw_done;
  461.                 break;
  462.             case ' ':
  463.                 // 如果当前字符为空格, 表明遇到URL后紧跟的一个空格
  465.                 // 置r->uri_end为p-1, 记录URL的结束位置
  466.                 r->uri_end = p - 1;
  467.                 // 置state为sw_http_09, 表示解析URL后紧跟空格后的内容
  468.                 state = sw_http_09;
  469.                 break;
  470.             }
  471.             break;
  473.         case sw_http_09:
  474.             // 当前状态为解析URL后紧跟空格后的内容
  476.             switch (ch) {
  477.             case ' ':
  478.                 // 如果当前字符为空格, 直接跳过
  479.                 break;
  480.             case CR:
  481.                 // 如果当前字符为\r, 说明是HTTP 0.9
  483.                 // 置r->http_minor为9
  484.                 r->http_minor = 9;
  485.                 // 置state为sw_almost_done, 表示解析结束的\n
  486.                 state = sw_almost_done;
  487.                 break;
  488.             case LF:
  489.                 // 如果当前字符为\n, 说明是HTTP 0.9
  491.                 // 置r->http_minor为9
  492.                 r->http_minor = 9;
  493.                 // 置state为sw_done, 表示解析完成
  494.                 state = sw_done;
  495.                 break;
  496.             case 'H':
  497.                 // 如果当前字符是H, 说明是HTTP >= 1.0
  499.                 // 置state为sw_http_H, 表示解析协议版本的第二个字符T
  500.                 state = sw_http_H;
  501.                 break;
  502.             default:
  503.                 // 当前字符为其他字符, 返回NGX_HTTP_PARSE_INVALID_REQUEST
  504.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  505.             }
  506.             break;
  508.         case sw_http_H:
  509.             // 当前状态为解析协议版本的第二个字符T
  510.             switch (ch) {
  511.             case 'T':
  512.                 // 如果当前字符正是T
  514.                 // 置state为sw_http_HT
  515.                 state = sw_http_HT;
  516.                 break;
  517.             default:
  518.                 // 当前字符不为T, 返回NGX_HTTP_PARSE_INVALID_REQUEST
  519.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  520.             }
  521.             break;
  523.         case sw_http_HT:
  524.             // 当前状态为解析协议版本的第三个字符T
  526.             switch (ch) {
  527.             case 'T':
  528.                 // 如果当前字符正是T
  530.                 // 置state为sw_http_HTT
  531.                 state = sw_http_HTT;
  532.                 break;
  533.             default:
  534.                 // 当前字符不为T, 返回NGX_HTTP_PARSE_INVALID_REQUEST
  535.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  536.             }
  537.             break;
  539.         case sw_http_HTT:
  540.             // 当前状态为解析协议版本的第四个字符P
  542.             switch (ch) {
  543.             case 'P':
  544.                 // 如果当前字符正是P
  546.                 // 置state为sw_http_HTTP
  547.                 state = sw_http_HTTP;
  548.                 break;
  549.             default:
  550.                 // 当前字符不为P, 返回NGX_HTTP_PARSE_INVALID_REQUEST
  551.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  552.             }
  553.             break;
  555.         case sw_http_HTTP:
  556.             // 当前状态为解析协议版本的第五个字符/
  558.             switch (ch) {
  559.             case '/':
  560.                 // 如果当前字符正是/
  562.                 // 置state为sw_first_major_digit
  563.                 state = sw_first_major_digit;
  564.                 break;
  565.             default:
  566.                 // 当前字符不为/, 返回NGX_HTTP_PARSE_INVALID_REQUEST
  567.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  568.             }
  569.             break;
  571.         case sw_first_major_digit:
  572.             // 当前状态为解析协议版本的主版本号的第一个数字
  573.             if (ch < '1' || ch > '9') {
  574.                 // 如果当前字符不为数字1-9, 说明是无效字符;
  575.                 // 协议版本应该是在HTTP 1.0后才有的, 因此主版本号应该不小于1;
  576.                 // 返回NGX_HTTP_PARSE_INVALID_REQUEST
  577.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  578.             }
  579.             // 置r->http_major为ch-'0', 记录主版本号
  580.             r->http_major = ch - '0';
  581.             // 置state为sw_major_digit, 表示解析协议版本的主版本号第一个数字后的数字或者.
  582.             state = sw_major_digit;
  583.             break;
  585.         case sw_major_digit:
  586.             // 当前状态为解析协议版本的主版本号第一个数字后的数字或者.
  588.             if (ch == '.') {
  589.                 // 如果当前字符为., 说明遇到主版本号后紧跟的.了
  590.                 // 置state为sw_first_minor_digit, 表示解析次版本号的第一个数字
  591.                 state = sw_first_minor_digit;
  592.                 break;
  593.             }
  595.             if (ch < '0' || ch > '9') {
  596.                 // 如果当前字符不为数字, 说明是非法字符, 返回NGX_HTTP_PARSE_INVALID_REQUEST
  597.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  598.             }
  599.             // 更新主版本号r->http_major
  600.             r->http_major = r->http_major * 10 + ch - '0';
  601.             break;
  603.         case sw_first_minor_digit:
  604.             // 当前状态为解析协议版本的次版本号的第一个数字
  606.             if (ch < '0' || ch > '9') {
  607.                 // 如果当前字符不为数字, 说明是非法字符, 返回NGX_HTTP_PARSE_INVALID_REQUEST
  608.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  609.             }
  610.             // 置r->http_minor为ch-'0', 记录次版本号
  611.             r->http_minor = ch - '0';
  612.             // 置state为sw_minor_digit, 表示解析协议版本的次版本号第一个数字后的数字
  613.             state = sw_minor_digit;
  614.             break;
  616.         case sw_minor_digit:
  617.             // 当前状态为解析协议版本的次版本号第一个数字后的数字
  619.             if (ch == CR) {
  620.                 // 如果当前字符为\r, 说明遇到次版本号后紧跟的\r
  621.                 // 置state为sw_almost_done, 表示解析结束的\n
  622.                 state = sw_almost_done;
  623.                 break;
  624.             }
  626.             if (ch == LF) {
  627.                 // 如果当前字符为\n, 说明遇到次版本号后的\n
  628.                 // 置state为sw_done, 表示解析完成
  629.                 state = sw_done;
  630.                 break;
  631.             }
  633.             if (ch < '0' || ch > '9') {
  634.                 // 如果当前字符不为数字, 说明是非法字符, 返回NGX_HTTP_PARSE_INVALID_REQUEST
  635.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  636.             }
  637.             // 更新次版本号r->http_minor
  638.             r->http_minor = r->http_minor * 10 + ch - '0';
  639.             break;
  641.         case sw_almost_done:
  642.             // 当前状态为解析结束的\n
  644.             // 置r->request_end为p-2, 记录请求行有效内容的结束位置
  645.             r->request_end = p - 2;
  646.             switch (ch) {
  647.             case LF:
  648.                 // 如果当前字符正是\n
  650.                 // 置state为sw_done, 表示解析完成
  651.                 state = sw_done;
  652.                 break;
  653.             default:
  654.                 // 如果当前字符不是\n, 那么就是非法字符, 返回NGX_HTTP_PARSE_INVALID_REQUEST
  655.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  656.             }
  657.             break;
  659.         case sw_done:
  660.             // 当前状态为解析完成, 直接退出循环
  661.             break;
  662.         }
  663.     }
  665.     // 置缓冲区的pos为p
  666.     b->pos = p;
  668.     if (state == sw_done) {
  669.         // 如果state为sw_done, 表明解析完成
  671.         if (r->request_end == NULL) {
  672.             // 如果r->request_end为空
  674.             // 置r->request_end为p-1, p-1即为请求行的结束位置
  675.             r->request_end = p - 1;
  676.         }
  678.         // 求取HTTP版本, 规则为: 主版本号*1000+次版本号
  679.         // 所以,0.9->9, 1.0->1000, 1.1->1001
  680.         r->http_version = r->http_major * 1000 + r->http_minor;
  681.         // 重置请求r的state为sw_start
  682.         r->state = sw_start;
  684.         if (r->http_version == 9 && r->method != NGX_HTTP_GET) {
  685.             // 如果为HTTP 0.9且请求方法不为GET
  687.             // 返回NGX_HTTP_PARSE_INVALID_09_METHOD, 说明HTTP 0.9只支持GET方法
  688.             return NGX_HTTP_PARSE_INVALID_09_METHOD;
  689.         }
  691.         return NGX_OK;
  693.     } else {
  694.         // 没有解析完
  696.         // 记录当前解析状态
  697.         r->state = state;
  698.         // 返回NGX_AGAIN
  699.         return NGX_AGAIN;
  700.     }
  701. }

-——————————
作者：疯之墒
来源：CSDN
原文：https://blog.csdn.net/oyw5201314ck/article/details/78550785
版权声明：本文为博主原创文章，转载请附上博文链接！

发表评论

表情：
评论列表 （有 0 条评论，245人围观）

还没有评论，来说两句吧...

相关阅读

    相关 HTTP头部行请求参数

    HTTP响应头和请求头信息对照表 HTTP请求头提供了关于请求，响应或者其他的发送实体的信息。HTTP的头信息包括通用头、请求头、响应头和实体头四个部分。每个头域由一个域

    野性酷女野性酷女/ 0 赞/ 332 阅读