One Level Up Top Level

src/http/ngx_http_parse.c - nginx

Global variables defined

Data types defined

Functions defined

Macros defined

Source code


  2. /*
  3. * Copyright (C) Igor Sysoev
  4. * Copyright (C) Nginx, Inc.
  5. */


  8. #include <ngx_config.h>
  9. #include <ngx_core.h>
  10. #include <ngx_http.h>


  13. static ngx_table_elt_t *ngx_http_parse_multi_header_lines_internal(
  14.     ngx_http_request_t *r, ngx_table_elt_t *headers, ngx_str_t *name,
  15.     ngx_str_t *value, u_char sep);

  17. ‌static uint32_t  usual[] = {
  18.     0x00000000, /* 0000 0000 0000 0000  0000 0000 0000 0000 */

  20.                 /* ?>=< ;:98 7654 3210  /.-, +*)( '&%$ #"!  */
  21.     0x7fff37d6, /* 0111 1111 1111 1111  0011 0111 1101 0110 */

  23.                 /* _^]\ [ZYX WVUT SRQP  ONML KJIH GFED CBA@ */
  24. #if (NGX_WIN32)
  25.     0xefffffff, /* 1110 1111 1111 1111  1111 1111 1111 1111 */
  26. #else
  27.     0xffffffff, /* 1111 1111 1111 1111  1111 1111 1111 1111 */
  28. #endif

  30.                 /*  ~}| {zyx wvut srqp  onml kjih gfed cba` */
  31.     0x7fffffff, /* 0111 1111 1111 1111  1111 1111 1111 1111 */

  33.     0xffffffff, /* 1111 1111 1111 1111  1111 1111 1111 1111 */
  34.     0xffffffff, /* 1111 1111 1111 1111  1111 1111 1111 1111 */
  35.     0xffffffff, /* 1111 1111 1111 1111  1111 1111 1111 1111 */
  36.     0xffffffff  /* 1111 1111 1111 1111  1111 1111 1111 1111 */
  37. };


  40. #if (NGX_HAVE_LITTLE_ENDIAN && NGX_HAVE_NONALIGNED)

  42. ‌#define ngx_str3_cmp(m, c0, c1, c2, c3)                                       \
  43.     *(uint32_t *) m == ((c3 << 24) | (c2 << 16) | (c1 << 8) | c0)

  45. ‌#define ngx_str3Ocmp(m, c0, c1, c2, c3)                                       \
  46.     *(uint32_t *) m == ((c3 << 24) | (c2 << 16) | (c1 << 8) | c0)

  48. ‌#define ngx_str4cmp(m, c0, c1, c2, c3)                                        \
  49.     *(uint32_t *) m == ((c3 << 24) | (c2 << 16) | (c1 << 8) | c0)

  51. ‌#define ngx_str5cmp(m, c0, c1, c2, c3, c4)                                    \
  52.     *(uint32_t *) m == ((c3 << 24) | (c2 << 16) | (c1 << 8) | c0)             \
  53.         && m[4] == c4

  55. ‌#define ngx_str6cmp(m, c0, c1, c2, c3, c4, c5)                                \
  56.     *(uint32_t *) m == ((c3 << 24) | (c2 << 16) | (c1 << 8) | c0)             \
  57.         && (((uint32_t *) m)[1] & 0xffff) == ((c5 << 8) | c4)

  59. ‌#define ngx_str7_cmp(m, c0, c1, c2, c3, c4, c5, c6, c7)                       \
  60.     *(uint32_t *) m == ((c3 << 24) | (c2 << 16) | (c1 << 8) | c0)             \
  61.         && ((uint32_t *) m)[1] == ((c7 << 24) | (c6 << 16) | (c5 << 8) | c4)

  63. ‌#define ngx_str8cmp(m, c0, c1, c2, c3, c4, c5, c6, c7)                        \
  64.     *(uint32_t *) m == ((c3 << 24) | (c2 << 16) | (c1 << 8) | c0)             \
  65.         && ((uint32_t *) m)[1] == ((c7 << 24) | (c6 << 16) | (c5 << 8) | c4)

  67. ‌#define ngx_str9cmp(m, c0, c1, c2, c3, c4, c5, c6, c7, c8)                    \
  68.     *(uint32_t *) m == ((c3 << 24) | (c2 << 16) | (c1 << 8) | c0)             \
  69.         && ((uint32_t *) m)[1] == ((c7 << 24) | (c6 << 16) | (c5 << 8) | c4)  \
  70.         && m[8] == c8

  72. #else /* !(NGX_HAVE_LITTLE_ENDIAN && NGX_HAVE_NONALIGNED) */

  74. ‌#define ngx_str3_cmp(m, c0, c1, c2, c3)                                       \
  75.     m[0] == c0 && m[1] == c1 && m[2] == c2

  77. ‌#define ngx_str3Ocmp(m, c0, c1, c2, c3)                                       \
  78.     m[0] == c0 && m[2] == c2 && m[3] == c3

  80. ‌#define ngx_str4cmp(m, c0, c1, c2, c3)                                        \
  81.     m[0] == c0 && m[1] == c1 && m[2] == c2 && m[3] == c3

  83. ‌#define ngx_str5cmp(m, c0, c1, c2, c3, c4)                                    \
  84.     m[0] == c0 && m[1] == c1 && m[2] == c2 && m[3] == c3 && m[4] == c4

  86. ‌#define ngx_str6cmp(m, c0, c1, c2, c3, c4, c5)                                \
  87.     m[0] == c0 && m[1] == c1 && m[2] == c2 && m[3] == c3                      \
  88.         && m[4] == c4 && m[5] == c5

  90. ‌#define ngx_str7_cmp(m, c0, c1, c2, c3, c4, c5, c6, c7)                       \
  91.     m[0] == c0 && m[1] == c1 && m[2] == c2 && m[3] == c3                      \
  92.         && m[4] == c4 && m[5] == c5 && m[6] == c6

  94. ‌#define ngx_str8cmp(m, c0, c1, c2, c3, c4, c5, c6, c7)                        \
  95.     m[0] == c0 && m[1] == c1 && m[2] == c2 && m[3] == c3                      \
  96.         && m[4] == c4 && m[5] == c5 && m[6] == c6 && m[7] == c7

  98. ‌#define ngx_str9cmp(m, c0, c1, c2, c3, c4, c5, c6, c7, c8)                    \
  99.     m[0] == c0 && m[1] == c1 && m[2] == c2 && m[3] == c3                      \
  100.         && m[4] == c4 && m[5] == c5 && m[6] == c6 && m[7] == c7 && m[8] == c8

  102. #endif


  105. /* gcc, icc, msvc and others compile these switches as an jump table */

  107. ngx_int_t
  108. ‌ngx_http_parse_request_line(ngx_http_request_t *r, ngx_buf_t *b)
  109. {
  110.     u_char  c, ch, *p, *m;
  111. ‌    enum {
  112.         sw_start = 0,
  113.         sw_method,
  114.         sw_spaces_before_uri,
  115.         sw_schema,
  116.         sw_schema_slash,
  117.         sw_schema_slash_slash,
  118.         sw_spaces_before_host,
  119.         sw_host_start,
  120.         sw_host,
  121.         sw_host_end,
  122.         sw_host_ip_literal,
  123.         sw_port_start,
  124.         sw_port,
  125.         sw_after_slash_in_uri,
  126.         sw_check_uri,
  127.         sw_uri,
  128.         sw_http_09,
  129.         sw_http_H,
  130.         sw_http_HT,
  131.         sw_http_HTT,
  132.         sw_http_HTTP,
  133.         sw_first_major_digit,
  134.         sw_major_digit,
  135.         sw_first_minor_digit,
  136.         sw_minor_digit,
  137.         sw_spaces_after_digit,
  138.         sw_almost_done
  139.     } state;

  141.     state = r->state;

  143.     for (p = b->pos; p < b->last; p++) {
  144.         ch = *p;

  146.         switch (state) {

  148.         /* HTTP methods: GET, HEAD, POST */
  149.         case sw_start:
  150.             r->request_start = p;

  152.             if (ch == CR || ch == LF) {
  153.                 break;
  154.             }

  156.             if ((ch < 'A' || ch > 'Z') && ch != '_' && ch != '-') {
  157.                 return NGX_HTTP_PARSE_INVALID_METHOD;
  158.             }

  160.             state = sw_method;
  161.             break;

  163.         case sw_method:
  164.             if (ch == ' ') {
  165.                 r->method_end = p - 1;
  166.                 m = r->request_start;
  167.                 state = sw_spaces_before_uri;

  169.                 switch (p - m) {

  171.                 case 3:
  172.                     if (ngx_str3_cmp(m, 'G', 'E', 'T', ' ')) {
  173.                         r->method = NGX_HTTP_GET;
  174.                         break;
  175.                     }

  177.                     if (ngx_str3_cmp(m, 'P', 'U', 'T', ' ')) {
  178.                         r->method = NGX_HTTP_PUT;
  179.                         break;
  180.                     }

  182.                     break;

  184.                 case 4:
  185.                     if (m[1] == 'O') {

  187.                         if (ngx_str3Ocmp(m, 'P', 'O', 'S', 'T')) {
  188.                             r->method = NGX_HTTP_POST;
  189.                             break;
  190.                         }

  192.                         if (ngx_str3Ocmp(m, 'C', 'O', 'P', 'Y')) {
  193.                             r->method = NGX_HTTP_COPY;
  194.                             break;
  195.                         }

  197.                         if (ngx_str3Ocmp(m, 'M', 'O', 'V', 'E')) {
  198.                             r->method = NGX_HTTP_MOVE;
  199.                             break;
  200.                         }

  202.                         if (ngx_str3Ocmp(m, 'L', 'O', 'C', 'K')) {
  203.                             r->method = NGX_HTTP_LOCK;
  204.                             break;
  205.                         }

  207.                     } else {

  209.                         if (ngx_str4cmp(m, 'H', 'E', 'A', 'D')) {
  210.                             r->method = NGX_HTTP_HEAD;
  211.                             break;
  212.                         }
  213.                     }

  215.                     break;

  217.                 case 5:
  218.                     if (ngx_str5cmp(m, 'M', 'K', 'C', 'O', 'L')) {
  219.                         r->method = NGX_HTTP_MKCOL;
  220.                         break;
  221.                     }

  223.                     if (ngx_str5cmp(m, 'P', 'A', 'T', 'C', 'H')) {
  224.                         r->method = NGX_HTTP_PATCH;
  225.                         break;
  226.                     }

  228.                     if (ngx_str5cmp(m, 'T', 'R', 'A', 'C', 'E')) {
  229.                         r->method = NGX_HTTP_TRACE;
  230.                         break;
  231.                     }

  233.                     break;

  235.                 case 6:
  236.                     if (ngx_str6cmp(m, 'D', 'E', 'L', 'E', 'T', 'E')) {
  237.                         r->method = NGX_HTTP_DELETE;
  238.                         break;
  239.                     }

  241.                     if (ngx_str6cmp(m, 'U', 'N', 'L', 'O', 'C', 'K')) {
  242.                         r->method = NGX_HTTP_UNLOCK;
  243.                         break;
  244.                     }

  246.                     break;

  248.                 case 7:
  249.                     if (ngx_str7_cmp(m, 'O', 'P', 'T', 'I', 'O', 'N', 'S', ' '))
  250.                     {
  251.                         r->method = NGX_HTTP_OPTIONS;
  252.                     }

  254.                     if (ngx_str7_cmp(m, 'C', 'O', 'N', 'N', 'E', 'C', 'T', ' '))
  255.                     {
  256.                         r->method = NGX_HTTP_CONNECT;
  257.                         state = sw_spaces_before_host;
  258.                     }

  260.                     break;

  262.                 case 8:
  263.                     if (ngx_str8cmp(m, 'P', 'R', 'O', 'P', 'F', 'I', 'N', 'D'))
  264.                     {
  265.                         r->method = NGX_HTTP_PROPFIND;
  266.                     }

  268.                     break;

  270.                 case 9:
  271.                     if (ngx_str9cmp(m,
  272.                             'P', 'R', 'O', 'P', 'P', 'A', 'T', 'C', 'H'))
  273.                     {
  274.                         r->method = NGX_HTTP_PROPPATCH;
  275.                     }

  277.                     break;
  278.                 }

  280.                 break;
  281.             }

  283.             if ((ch < 'A' || ch > 'Z') && ch != '_' && ch != '-') {
  284.                 return NGX_HTTP_PARSE_INVALID_METHOD;
  285.             }

  287.             break;

  289.         /* space* before URI */
  290.         case sw_spaces_before_uri:

  292.             if (ch == '/') {
  293.                 r->uri_start = p;
  294.                 state = sw_after_slash_in_uri;
  295.                 break;
  296.             }

  298.             c = (u_char) (ch | 0x20);
  299.             if (c >= 'a' && c <= 'z') {
  300.                 r->schema_start = p;
  301.                 state = sw_schema;
  302.                 break;
  303.             }

  305.             switch (ch) {
  306.             case ' ':
  307.                 break;
  308.             default:
  309.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  310.             }
  311.             break;

  313.         case sw_schema:

  315.             c = (u_char) (ch | 0x20);
  316.             if (c >= 'a' && c <= 'z') {
  317.                 break;
  318.             }

  320.             if ((ch >= '0' && ch <= '9') || ch == '+' || ch == '-' || ch == '.')
  321.             {
  322.                 break;
  323.             }

  325.             switch (ch) {
  326.             case ':':
  327.                 r->schema_end = p;
  328.                 state = sw_schema_slash;
  329.                 break;
  330.             default:
  331.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  332.             }
  333.             break;

  335.         case sw_schema_slash:
  336.             switch (ch) {
  337.             case '/':
  338.                 state = sw_schema_slash_slash;
  339.                 break;
  340.             default:
  341.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  342.             }
  343.             break;

  345.         case sw_schema_slash_slash:
  346.             switch (ch) {
  347.             case '/':
  348.                 state = sw_host_start;
  349.                 break;
  350.             default:
  351.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  352.             }
  353.             break;

  355.         case sw_spaces_before_host:

  357.             if (ch == ' ') {
  358.                 break;
  359.             }

  361.             /* fall through */

  363.         case sw_host_start:

  365.             r->host_start = p;

  367.             if (ch == '[') {
  368.                 state = sw_host_ip_literal;
  369.                 break;
  370.             }

  372.             state = sw_host;

  374.             /* fall through */

  376.         case sw_host:

  378.             c = (u_char) (ch | 0x20);
  379.             if (c >= 'a' && c <= 'z') {
  380.                 break;
  381.             }

  383.             if ((ch >= '0' && ch <= '9') || ch == '.' || ch == '-') {
  384.                 break;
  385.             }

  387.             /* fall through */

  389.         case sw_host_end:

  391.             if (ch == ':') {
  392.                 state = sw_port_start;
  393.                 break;
  394.             }

  396.             r->host_end = p;

  398.             if (r->method == NGX_HTTP_CONNECT) {
  399.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  400.             }

  402.             switch (ch) {
  403.             case '/':
  404.                 r->uri_start = p;
  405.                 state = sw_after_slash_in_uri;
  406.                 break;
  407.             case '?':
  408.                 r->uri_start = p;
  409.                 r->args_start = p + 1;
  410.                 r->empty_path_in_uri = 1;
  411.                 state = sw_uri;
  412.                 break;
  413.             case ' ':
  414.                 /*
  415.                  * use single "/" from request line to preserve pointers,
  416.                  * if request line will be copied to large client buffer
  417.                  */
  418.                 r->uri_start = r->schema_end + 1;
  419.                 r->uri_end = r->schema_end + 2;
  420.                 state = sw_http_09;
  421.                 break;
  422.             default:
  423.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  424.             }
  425.             break;

  427.         case sw_host_ip_literal:

  429.             if (ch >= '0' && ch <= '9') {
  430.                 break;
  431.             }

  433.             c = (u_char) (ch | 0x20);
  434.             if (c >= 'a' && c <= 'z') {
  435.                 break;
  436.             }

  438.             switch (ch) {
  439.             case ':':
  440.                 break;
  441.             case ']':
  442.                 state = sw_host_end;
  443.                 break;
  444.             case '-':
  445.             case '.':
  446.             case '_':
  447.             case '~':
  448.                 /* unreserved */
  449.                 break;
  450.             case '!':
  451.             case '$':
  452.             case '&':
  453.             case '\'':
  454.             case '(':
  455.             case ')':
  456.             case '*':
  457.             case '+':
  458.             case ',':
  459.             case ';':
  460.             case '=':
  461.                 /* sub-delims */
  462.                 break;
  463.             default:
  464.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  465.             }
  466.             break;

  468.         case sw_port_start:
  469.             state = sw_port;

  471.             if (ch >= '0' && ch <= '9') {
  472.                 break;
  473.             }

  475.             if (r->method == NGX_HTTP_CONNECT) {
  476.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  477.             }

  479.             /* fall through */

  481.         case sw_port:
  482.             if (ch >= '0' && ch <= '9') {
  483.                 break;
  484.             }

  486.             r->host_end = p;

  488.             if (r->method == NGX_HTTP_CONNECT) {
  489.                 if (ch == ' ') {
  490.                     state = sw_http_09;
  491.                     break;
  492.                 }

  494.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  495.             }

  497.             switch (ch) {
  498.             case '/':
  499.                 r->uri_start = p;
  500.                 state = sw_after_slash_in_uri;
  501.                 break;
  502.             case '?':
  503.                 r->uri_start = p;
  504.                 r->args_start = p + 1;
  505.                 r->empty_path_in_uri = 1;
  506.                 state = sw_uri;
  507.                 break;
  508.             case ' ':
  509.                 /*
  510.                  * use single "/" from request line to preserve pointers,
  511.                  * if request line will be copied to large client buffer
  512.                  */
  513.                 r->uri_start = r->schema_end + 1;
  514.                 r->uri_end = r->schema_end + 2;
  515.                 state = sw_http_09;
  516.                 break;
  517.             default:
  518.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  519.             }
  520.             break;

  522.         /* check "/.", "//", "%", and "\" (Win32) in URI */
  523.         case sw_after_slash_in_uri:

  525.             if (usual[ch >> 5] & (1U << (ch & 0x1f))) {
  526.                 state = sw_check_uri;
  527.                 break;
  528.             }

  530.             switch (ch) {
  531.             case ' ':
  532.                 r->uri_end = p;
  533.                 state = sw_http_09;
  534.                 break;
  535.             case CR:
  536.                 r->uri_end = p;
  537.                 r->http_minor = 9;
  538.                 state = sw_almost_done;
  539.                 break;
  540.             case LF:
  541.                 r->uri_end = p;
  542.                 r->http_minor = 9;
  543.                 goto done;
  544.             case '.':
  545.                 r->complex_uri = 1;
  546.                 state = sw_uri;
  547.                 break;
  548.             case '%':
  549.                 r->quoted_uri = 1;
  550.                 state = sw_uri;
  551.                 break;
  552.             case '/':
  553.                 r->complex_uri = 1;
  554.                 state = sw_uri;
  555.                 break;
  556. #if (NGX_WIN32)
  557.             case '\\':
  558.                 r->complex_uri = 1;
  559.                 state = sw_uri;
  560.                 break;
  561. #endif
  562.             case '?':
  563.                 r->args_start = p + 1;
  564.                 state = sw_uri;
  565.                 break;
  566.             case '#':
  567.                 r->complex_uri = 1;
  568.                 state = sw_uri;
  569.                 break;
  570.             case '+':
  571.                 r->plus_in_uri = 1;
  572.                 break;
  573.             default:
  574.                 if (ch < 0x20 || ch == 0x7f) {
  575.                     return NGX_HTTP_PARSE_INVALID_REQUEST;
  576.                 }
  577.                 state = sw_check_uri;
  578.                 break;
  579.             }
  580.             break;

  582.         /* check "/", "%" and "\" (Win32) in URI */
  583.         case sw_check_uri:

  585.             if (usual[ch >> 5] & (1U << (ch & 0x1f))) {
  586.                 break;
  587.             }

  589.             switch (ch) {
  590.             case '/':
  591. #if (NGX_WIN32)
  592.                 if (r->uri_ext == p) {
  593.                     r->complex_uri = 1;
  594.                     state = sw_uri;
  595.                     break;
  596.                 }
  597. #endif
  598.                 r->uri_ext = NULL;
  599.                 state = sw_after_slash_in_uri;
  600.                 break;
  601.             case '.':
  602.                 r->uri_ext = p + 1;
  603.                 break;
  604.             case ' ':
  605.                 r->uri_end = p;
  606.                 state = sw_http_09;
  607.                 break;
  608.             case CR:
  609.                 r->uri_end = p;
  610.                 r->http_minor = 9;
  611.                 state = sw_almost_done;
  612.                 break;
  613.             case LF:
  614.                 r->uri_end = p;
  615.                 r->http_minor = 9;
  616.                 goto done;
  617. #if (NGX_WIN32)
  618.             case '\\':
  619.                 r->complex_uri = 1;
  620.                 state = sw_after_slash_in_uri;
  621.                 break;
  622. #endif
  623.             case '%':
  624.                 r->quoted_uri = 1;
  625.                 state = sw_uri;
  626.                 break;
  627.             case '?':
  628.                 r->args_start = p + 1;
  629.                 state = sw_uri;
  630.                 break;
  631.             case '#':
  632.                 r->complex_uri = 1;
  633.                 state = sw_uri;
  634.                 break;
  635.             case '+':
  636.                 r->plus_in_uri = 1;
  637.                 break;
  638.             default:
  639.                 if (ch < 0x20 || ch == 0x7f) {
  640.                     return NGX_HTTP_PARSE_INVALID_REQUEST;
  641.                 }
  642.                 break;
  643.             }
  644.             break;

  646.         /* URI */
  647.         case sw_uri:

  649.             if (usual[ch >> 5] & (1U << (ch & 0x1f))) {
  650.                 break;
  651.             }

  653.             switch (ch) {
  654.             case ' ':
  655.                 r->uri_end = p;
  656.                 state = sw_http_09;
  657.                 break;
  658.             case CR:
  659.                 r->uri_end = p;
  660.                 r->http_minor = 9;
  661.                 state = sw_almost_done;
  662.                 break;
  663.             case LF:
  664.                 r->uri_end = p;
  665.                 r->http_minor = 9;
  666.                 goto done;
  667.             case '#':
  668.                 r->complex_uri = 1;
  669.                 break;
  670.             default:
  671.                 if (ch < 0x20 || ch == 0x7f) {
  672.                     return NGX_HTTP_PARSE_INVALID_REQUEST;
  673.                 }
  674.                 break;
  675.             }
  676.             break;

  678.         /* space+ after URI */
  679.         case sw_http_09:
  680.             switch (ch) {
  681.             case ' ':
  682.                 break;
  683.             case CR:
  684.                 r->http_minor = 9;
  685.                 state = sw_almost_done;
  686.                 break;
  687.             case LF:
  688.                 r->http_minor = 9;
  689.                 goto done;
  690.             case 'H':
  691.                 r->http_protocol.data = p;
  692.                 state = sw_http_H;
  693.                 break;
  694.             default:
  695.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  696.             }
  697.             break;

  699.         case sw_http_H:
  700.             switch (ch) {
  701.             case 'T':
  702.                 state = sw_http_HT;
  703.                 break;
  704.             default:
  705.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  706.             }
  707.             break;

  709.         case sw_http_HT:
  710.             switch (ch) {
  711.             case 'T':
  712.                 state = sw_http_HTT;
  713.                 break;
  714.             default:
  715.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  716.             }
  717.             break;

  719.         case sw_http_HTT:
  720.             switch (ch) {
  721.             case 'P':
  722.                 state = sw_http_HTTP;
  723.                 break;
  724.             default:
  725.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  726.             }
  727.             break;

  729.         case sw_http_HTTP:
  730.             switch (ch) {
  731.             case '/':

  733.                 /*
  734.                  * use single "/" from request line to preserve pointers,
  735.                  * if request line will be copied to large client buffer
  736.                  */
  737.                 if (r->method == NGX_HTTP_CONNECT) {
  738.                     r->uri_start = p;
  739.                     r->uri_end = p + 1;
  740.                 }

  742.                 state = sw_first_major_digit;
  743.                 break;
  744.             default:
  745.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  746.             }
  747.             break;

  749.         /* first digit of major HTTP version */
  750.         case sw_first_major_digit:
  751.             if (ch < '1' || ch > '9') {
  752.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  753.             }

  755.             r->http_major = ch - '0';

  757.             if (r->http_major > 1) {
  758.                 return NGX_HTTP_PARSE_INVALID_VERSION;
  759.             }

  761.             state = sw_major_digit;
  762.             break;

  764.         /* major HTTP version or dot */
  765.         case sw_major_digit:
  766.             if (ch == '.') {
  767.                 state = sw_first_minor_digit;
  768.                 break;
  769.             }

  771.             if (ch < '0' || ch > '9') {
  772.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  773.             }

  775.             r->http_major = r->http_major * 10 + (ch - '0');

  777.             if (r->http_major > 1) {
  778.                 return NGX_HTTP_PARSE_INVALID_VERSION;
  779.             }

  781.             break;

  783.         /* first digit of minor HTTP version */
  784.         case sw_first_minor_digit:
  785.             if (ch < '0' || ch > '9') {
  786.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  787.             }

  789.             r->http_minor = ch - '0';
  790.             state = sw_minor_digit;
  791.             break;

  793.         /* minor HTTP version or end of request line */
  794.         case sw_minor_digit:
  795.             if (ch == CR) {
  796.                 state = sw_almost_done;
  797.                 break;
  798.             }

  800.             if (ch == LF) {
  801.                 goto done;
  802.             }

  804.             if (ch == ' ') {
  805.                 state = sw_spaces_after_digit;
  806.                 break;
  807.             }

  809.             if (ch < '0' || ch > '9') {
  810.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  811.             }

  813.             if (r->http_minor > 99) {
  814.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  815.             }

  817.             r->http_minor = r->http_minor * 10 + (ch - '0');
  818.             break;

  820.         case sw_spaces_after_digit:
  821.             switch (ch) {
  822.             case ' ':
  823.                 break;
  824.             case CR:
  825.                 state = sw_almost_done;
  826.                 break;
  827.             case LF:
  828.                 goto done;
  829.             default:
  830.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  831.             }
  832.             break;

  834.         /* end of request line */
  835.         case sw_almost_done:
  836.             r->request_end = p - 1;
  837.             switch (ch) {
  838.             case LF:
  839.                 goto done;
  840.             default:
  841.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  842.             }
  843.         }
  844.     }

  846.     b->pos = p;
  847.     r->state = state;

  849.     return NGX_AGAIN;

  851. done:

  853.     b->pos = p + 1;

  855.     if (r->request_end == NULL) {
  856.         r->request_end = p;
  857.     }

  859.     r->http_version = r->http_major * 1000 + r->http_minor;
  860.     r->state = sw_start;

  862.     if (r->http_version == 9 && r->method != NGX_HTTP_GET) {
  863.         return NGX_HTTP_PARSE_INVALID_09_METHOD;
  864.     }

  866.     return NGX_OK;
  867. }


  870. ngx_int_t
  871. ‌ngx_http_parse_header_line(ngx_http_request_t *r, ngx_buf_t *b,
  872.     ngx_uint_t allow_underscores)
  873. {
  874.     u_char      c, ch, *p;
  875.     ngx_uint_t  hash, i;
  876. ‌    enum {
  877.         sw_start = 0,
  878.         sw_name,
  879.         sw_space_before_value,
  880.         sw_value,
  881.         sw_space_after_value,
  882.         sw_ignore_line,
  883.         sw_almost_done,
  884.         sw_header_almost_done
  885.     } state;

  887.     /* the last '\0' is not needed because string is zero terminated */

  889.     static u_char  lowcase[] =
  890.         "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  891.         "\0\0\0\0\0\0\0\0\0\0\0\0\0-\0\0" "0123456789\0\0\0\0\0\0"
  892.         "\0abcdefghijklmnopqrstuvwxyz\0\0\0\0\0"
  893.         "\0abcdefghijklmnopqrstuvwxyz\0\0\0\0\0"
  894.         "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  895.         "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  896.         "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
  897.         "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";

  899.     state = r->state;
  900.     hash = r->header_hash;
  901.     i = r->lowcase_index;

  903.     for (p = b->pos; p < b->last; p++) {
  904.         ch = *p;

  906.         switch (state) {

  908.         /* first char */
  909.         case sw_start:
  910.             r->header_name_start = p;
  911.             r->invalid_header = 0;

  913.             switch (ch) {
  914.             case CR:
  915.                 r->header_end = p;
  916.                 state = sw_header_almost_done;
  917.                 break;
  918.             case LF:
  919.                 r->header_end = p;
  920.                 goto header_done;
  921.             default:
  922.                 state = sw_name;

  924.                 c = lowcase[ch];

  926.                 if (c) {
  927.                     hash = ngx_hash(0, c);
  928.                     r->lowcase_header[0] = c;
  929.                     i = 1;
  930.                     break;
  931.                 }

  933.                 if (ch == '_') {
  934.                     if (allow_underscores) {
  935.                         hash = ngx_hash(0, ch);
  936.                         r->lowcase_header[0] = ch;
  937.                         i = 1;

  939.                     } else {
  940.                         hash = 0;
  941.                         i = 0;
  942.                         r->invalid_header = 1;
  943.                     }

  945.                     break;
  946.                 }

  948.                 if (ch <= 0x20 || ch == 0x7f || ch == ':') {
  949.                     r->header_end = p;
  950.                     return NGX_HTTP_PARSE_INVALID_HEADER;
  951.                 }

  953.                 hash = 0;
  954.                 i = 0;
  955.                 r->invalid_header = 1;

  957.                 break;

  959.             }
  960.             break;

  962.         /* header name */
  963.         case sw_name:
  964.             c = lowcase[ch];

  966.             if (c) {
  967.                 hash = ngx_hash(hash, c);
  968.                 r->lowcase_header[i++] = c;
  969.                 i &= (NGX_HTTP_LC_HEADER_LEN - 1);
  970.                 break;
  971.             }

  973.             if (ch == '_') {
  974.                 if (allow_underscores) {
  975.                     hash = ngx_hash(hash, ch);
  976.                     r->lowcase_header[i++] = ch;
  977.                     i &= (NGX_HTTP_LC_HEADER_LEN - 1);

  979.                 } else {
  980.                     r->invalid_header = 1;
  981.                 }

  983.                 break;
  984.             }

  986.             if (ch == ':') {
  987.                 r->header_name_end = p;
  988.                 state = sw_space_before_value;
  989.                 break;
  990.             }

  992.             if (ch == CR) {
  993.                 r->header_name_end = p;
  994.                 r->header_start = p;
  995.                 r->header_end = p;
  996.                 state = sw_almost_done;
  997.                 break;
  998.             }

  1000.             if (ch == LF) {
  1001.                 r->header_name_end = p;
  1002.                 r->header_start = p;
  1003.                 r->header_end = p;
  1004.                 goto done;
  1005.             }

  1007.             /* IIS may send the duplicate "HTTP/1.1 ..." lines */
  1008.             if (ch == '/'
  1009.                 && r->upstream
  1010.                 && p - r->header_name_start == 4
  1011.                 && ngx_strncmp(r->header_name_start, "HTTP", 4) == 0)
  1012.             {
  1013.                 state = sw_ignore_line;
  1014.                 break;
  1015.             }

  1017.             if (ch <= 0x20 || ch == 0x7f) {
  1018.                 r->header_end = p;
  1019.                 return NGX_HTTP_PARSE_INVALID_HEADER;
  1020.             }

  1022.             r->invalid_header = 1;

  1024.             break;

  1026.         /* space* before header value */
  1027.         case sw_space_before_value:
  1028.             switch (ch) {
  1029.             case ' ':
  1030.                 break;
  1031.             case CR:
  1032.                 r->header_start = p;
  1033.                 r->header_end = p;
  1034.                 state = sw_almost_done;
  1035.                 break;
  1036.             case LF:
  1037.                 r->header_start = p;
  1038.                 r->header_end = p;
  1039.                 goto done;
  1040.             case '\0':
  1041.                 r->header_end = p;
  1042.                 return NGX_HTTP_PARSE_INVALID_HEADER;
  1043.             default:
  1044.                 r->header_start = p;
  1045.                 state = sw_value;
  1046.                 break;
  1047.             }
  1048.             break;

  1050.         /* header value */
  1051.         case sw_value:
  1052.             switch (ch) {
  1053.             case ' ':
  1054.                 r->header_end = p;
  1055.                 state = sw_space_after_value;
  1056.                 break;
  1057.             case CR:
  1058.                 r->header_end = p;
  1059.                 state = sw_almost_done;
  1060.                 break;
  1061.             case LF:
  1062.                 r->header_end = p;
  1063.                 goto done;
  1064.             case '\0':
  1065.                 r->header_end = p;
  1066.                 return NGX_HTTP_PARSE_INVALID_HEADER;
  1067.             }
  1068.             break;

  1070.         /* space* before end of header line */
  1071.         case sw_space_after_value:
  1072.             switch (ch) {
  1073.             case ' ':
  1074.                 break;
  1075.             case CR:
  1076.                 state = sw_almost_done;
  1077.                 break;
  1078.             case LF:
  1079.                 goto done;
  1080.             case '\0':
  1081.                 r->header_end = p;
  1082.                 return NGX_HTTP_PARSE_INVALID_HEADER;
  1083.             default:
  1084.                 state = sw_value;
  1085.                 break;
  1086.             }
  1087.             break;

  1089.         /* ignore header line */
  1090.         case sw_ignore_line:
  1091.             switch (ch) {
  1092.             case LF:
  1093.                 state = sw_start;
  1094.                 break;
  1095.             default:
  1096.                 break;
  1097.             }
  1098.             break;

  1100.         /* end of header line */
  1101.         case sw_almost_done:
  1102.             switch (ch) {
  1103.             case LF:
  1104.                 goto done;
  1105.             case CR:
  1106.                 break;
  1107.             default:
  1108.                 return NGX_HTTP_PARSE_INVALID_HEADER;
  1109.             }
  1110.             break;

  1112.         /* end of header */
  1113.         case sw_header_almost_done:
  1114.             switch (ch) {
  1115.             case LF:
  1116.                 goto header_done;
  1117.             default:
  1118.                 return NGX_HTTP_PARSE_INVALID_HEADER;
  1119.             }
  1120.         }
  1121.     }

  1123.     b->pos = p;
  1124.     r->state = state;
  1125.     r->header_hash = hash;
  1126.     r->lowcase_index = i;

  1128.     return NGX_AGAIN;

  1130. done:

  1132.     b->pos = p + 1;
  1133.     r->state = sw_start;
  1134.     r->header_hash = hash;
  1135.     r->lowcase_index = i;

  1137.     return NGX_OK;

  1139. header_done:

  1141.     b->pos = p + 1;
  1142.     r->state = sw_start;

  1144.     return NGX_HTTP_PARSE_HEADER_DONE;
  1145. }


  1148. ngx_int_t
  1149. ‌ngx_http_parse_uri(ngx_http_request_t *r)
  1150. {
  1151.     u_char  *p, ch;
  1152. ‌    enum {
  1153.         sw_start = 0,
  1154.         sw_after_slash_in_uri,
  1155.         sw_check_uri,
  1156.         sw_uri
  1157.     } state;

  1159.     state = sw_start;

  1161.     for (p = r->uri_start; p != r->uri_end; p++) {

  1163.         ch = *p;

  1165.         switch (state) {

  1167.         case sw_start:

  1169.             if (ch != '/') {
  1170.                 return NGX_ERROR;
  1171.             }

  1173.             state = sw_after_slash_in_uri;
  1174.             break;

  1176.         /* check "/.", "//", "%", and "\" (Win32) in URI */
  1177.         case sw_after_slash_in_uri:

  1179.             if (usual[ch >> 5] & (1U << (ch & 0x1f))) {
  1180.                 state = sw_check_uri;
  1181.                 break;
  1182.             }

  1184.             switch (ch) {
  1185.             case '.':
  1186.                 r->complex_uri = 1;
  1187.                 state = sw_uri;
  1188.                 break;
  1189.             case '%':
  1190.                 r->quoted_uri = 1;
  1191.                 state = sw_uri;
  1192.                 break;
  1193.             case '/':
  1194.                 r->complex_uri = 1;
  1195.                 state = sw_uri;
  1196.                 break;
  1197. #if (NGX_WIN32)
  1198.             case '\\':
  1199.                 r->complex_uri = 1;
  1200.                 state = sw_uri;
  1201.                 break;
  1202. #endif
  1203.             case '?':
  1204.                 r->args_start = p + 1;
  1205.                 state = sw_uri;
  1206.                 break;
  1207.             case '#':
  1208.                 r->complex_uri = 1;
  1209.                 state = sw_uri;
  1210.                 break;
  1211.             case '+':
  1212.                 r->plus_in_uri = 1;
  1213.                 break;
  1214.             default:
  1215.                 if (ch <= 0x20 || ch == 0x7f) {
  1216.                     return NGX_ERROR;
  1217.                 }
  1218.                 state = sw_check_uri;
  1219.                 break;
  1220.             }
  1221.             break;

  1223.         /* check "/", "%" and "\" (Win32) in URI */
  1224.         case sw_check_uri:

  1226.             if (usual[ch >> 5] & (1U << (ch & 0x1f))) {
  1227.                 break;
  1228.             }

  1230.             switch (ch) {
  1231.             case '/':
  1232. #if (NGX_WIN32)
  1233.                 if (r->uri_ext == p) {
  1234.                     r->complex_uri = 1;
  1235.                     state = sw_uri;
  1236.                     break;
  1237.                 }
  1238. #endif
  1239.                 r->uri_ext = NULL;
  1240.                 state = sw_after_slash_in_uri;
  1241.                 break;
  1242.             case '.':
  1243.                 r->uri_ext = p + 1;
  1244.                 break;
  1245. #if (NGX_WIN32)
  1246.             case '\\':
  1247.                 r->complex_uri = 1;
  1248.                 state = sw_after_slash_in_uri;
  1249.                 break;
  1250. #endif
  1251.             case '%':
  1252.                 r->quoted_uri = 1;
  1253.                 state = sw_uri;
  1254.                 break;
  1255.             case '?':
  1256.                 r->args_start = p + 1;
  1257.                 state = sw_uri;
  1258.                 break;
  1259.             case '#':
  1260.                 r->complex_uri = 1;
  1261.                 state = sw_uri;
  1262.                 break;
  1263.             case '+':
  1264.                 r->plus_in_uri = 1;
  1265.                 break;
  1266.             default:
  1267.                 if (ch <= 0x20 || ch == 0x7f) {
  1268.                     return NGX_ERROR;
  1269.                 }
  1270.                 break;
  1271.             }
  1272.             break;

  1274.         /* URI */
  1275.         case sw_uri:

  1277.             if (usual[ch >> 5] & (1U << (ch & 0x1f))) {
  1278.                 break;
  1279.             }

  1281.             switch (ch) {
  1282.             case '#':
  1283.                 r->complex_uri = 1;
  1284.                 break;
  1285.             default:
  1286.                 if (ch <= 0x20 || ch == 0x7f) {
  1287.                     return NGX_ERROR;
  1288.                 }
  1289.                 break;
  1290.             }
  1291.             break;
  1292.         }
  1293.     }

  1295.     return NGX_OK;
  1296. }


  1299. ngx_int_t
  1300. ‌ngx_http_parse_complex_uri(ngx_http_request_t *r, ngx_uint_t merge_slashes)
  1301. {
  1302.     u_char  c, ch, decoded, *p, *u;
  1303. ‌    enum {
  1304.         sw_usual = 0,
  1305.         sw_slash,
  1306.         sw_dot,
  1307.         sw_dot_dot,
  1308.         sw_quoted,
  1309.         sw_quoted_second
  1310.     } state, quoted_state;

  1312. #if (NGX_SUPPRESS_WARN)
  1313.     decoded = '\0';
  1314.     quoted_state = sw_usual;
  1315. #endif

  1317.     state = sw_usual;
  1318.     p = r->uri_start;
  1319.     u = r->uri.data;
  1320.     r->uri_ext = NULL;
  1321.     r->args_start = NULL;

  1323.     if (r->empty_path_in_uri) {
  1324.         *u++ = '/';
  1325.     }

  1327.     ch = *p++;

  1329.     while (p <= r->uri_end) {

  1331.         /*
  1332.          * we use "ch = *p++" inside the cycle, but this operation is safe,
  1333.          * because after the URI there is always at least one character:
  1334.          * the line feed
  1335.          */

  1337.         ngx_log_debug3(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1338.                        "s:%d in:'%Xd:%c'", state, ch, ch);

  1340.         switch (state) {

  1342.         case sw_usual:

  1344.             if (usual[ch >> 5] & (1U << (ch & 0x1f))) {
  1345.                 *u++ = ch;
  1346.                 ch = *p++;
  1347.                 break;
  1348.             }

  1350.             switch (ch) {
  1351. #if (NGX_WIN32)
  1352.             case '\\':
  1353.                 if (u - 2 >= r->uri.data
  1354.                     && *(u - 1) == '.' && *(u - 2) != '.')
  1355.                 {
  1356.                     u--;
  1357.                 }

  1359.                 r->uri_ext = NULL;

  1361.                 if (p == r->uri_start + r->uri.len) {

  1363.                     /*
  1364.                      * we omit the last "\" to cause redirect because
  1365.                      * the browsers do not treat "\" as "/" in relative URL path
  1366.                      */

  1368.                     break;
  1369.                 }

  1371.                 state = sw_slash;
  1372.                 *u++ = '/';
  1373.                 break;
  1374. #endif
  1375.             case '/':
  1376. #if (NGX_WIN32)
  1377.                 if (u - 2 >= r->uri.data
  1378.                     && *(u - 1) == '.' && *(u - 2) != '.')
  1379.                 {
  1380.                     u--;
  1381.                 }
  1382. #endif
  1383.                 r->uri_ext = NULL;
  1384.                 state = sw_slash;
  1385.                 *u++ = ch;
  1386.                 break;
  1387.             case '%':
  1388.                 quoted_state = state;
  1389.                 state = sw_quoted;
  1390.                 break;
  1391.             case '?':
  1392.                 r->args_start = p;
  1393.                 goto args;
  1394.             case '#':
  1395.                 goto done;
  1396.             case '.':
  1397.                 r->uri_ext = u + 1;
  1398.                 *u++ = ch;
  1399.                 break;
  1400.             case '+':
  1401.                 r->plus_in_uri = 1;
  1402.                 /* fall through */
  1403.             default:
  1404.                 *u++ = ch;
  1405.                 break;
  1406.             }

  1408.             ch = *p++;
  1409.             break;

  1411.         case sw_slash:

  1413.             if (usual[ch >> 5] & (1U << (ch & 0x1f))) {
  1414.                 state = sw_usual;
  1415.                 *u++ = ch;
  1416.                 ch = *p++;
  1417.                 break;
  1418.             }

  1420.             switch (ch) {
  1421. #if (NGX_WIN32)
  1422.             case '\\':
  1423.                 break;
  1424. #endif
  1425.             case '/':
  1426.                 if (!merge_slashes) {
  1427.                     *u++ = ch;
  1428.                 }
  1429.                 break;
  1430.             case '.':
  1431.                 state = sw_dot;
  1432.                 *u++ = ch;
  1433.                 break;
  1434.             case '%':
  1435.                 quoted_state = state;
  1436.                 state = sw_quoted;
  1437.                 break;
  1438.             case '?':
  1439.                 r->args_start = p;
  1440.                 goto args;
  1441.             case '#':
  1442.                 goto done;
  1443.             case '+':
  1444.                 r->plus_in_uri = 1;
  1445.                 /* fall through */
  1446.             default:
  1447.                 state = sw_usual;
  1448.                 *u++ = ch;
  1449.                 break;
  1450.             }

  1452.             ch = *p++;
  1453.             break;

  1455.         case sw_dot:

  1457.             if (usual[ch >> 5] & (1U << (ch & 0x1f))) {
  1458.                 state = sw_usual;
  1459.                 *u++ = ch;
  1460.                 ch = *p++;
  1461.                 break;
  1462.             }

  1464.             switch (ch) {
  1465. #if (NGX_WIN32)
  1466.             case '\\':
  1467. #endif
  1468.             case '/':
  1469.                 state = sw_slash;
  1470.                 u--;
  1471.                 break;
  1472.             case '.':
  1473.                 state = sw_dot_dot;
  1474.                 *u++ = ch;
  1475.                 break;
  1476.             case '%':
  1477.                 quoted_state = state;
  1478.                 state = sw_quoted;
  1479.                 break;
  1480.             case '?':
  1481.                 u--;
  1482.                 r->args_start = p;
  1483.                 goto args;
  1484.             case '#':
  1485.                 u--;
  1486.                 goto done;
  1487.             case '+':
  1488.                 r->plus_in_uri = 1;
  1489.                 /* fall through */
  1490.             default:
  1491.                 state = sw_usual;
  1492.                 *u++ = ch;
  1493.                 break;
  1494.             }

  1496.             ch = *p++;
  1497.             break;

  1499.         case sw_dot_dot:

  1501.             if (usual[ch >> 5] & (1U << (ch & 0x1f))) {
  1502.                 state = sw_usual;
  1503.                 *u++ = ch;
  1504.                 ch = *p++;
  1505.                 break;
  1506.             }

  1508.             switch (ch) {
  1509. #if (NGX_WIN32)
  1510.             case '\\':
  1511. #endif
  1512.             case '/':
  1513.             case '?':
  1514.             case '#':
  1515.                 u -= 4;
  1516.                 for ( ;; ) {
  1517.                     if (u < r->uri.data) {
  1518.                         return NGX_HTTP_PARSE_INVALID_REQUEST;
  1519.                     }
  1520.                     if (*u == '/') {
  1521.                         u++;
  1522.                         break;
  1523.                     }
  1524.                     u--;
  1525.                 }
  1526.                 if (ch == '?') {
  1527.                     r->args_start = p;
  1528.                     goto args;
  1529.                 }
  1530.                 if (ch == '#') {
  1531.                     goto done;
  1532.                 }
  1533.                 state = sw_slash;
  1534.                 break;
  1535.             case '%':
  1536.                 quoted_state = state;
  1537.                 state = sw_quoted;
  1538.                 break;
  1539.             case '+':
  1540.                 r->plus_in_uri = 1;
  1541.                 /* fall through */
  1542.             default:
  1543.                 state = sw_usual;
  1544.                 *u++ = ch;
  1545.                 break;
  1546.             }

  1548.             ch = *p++;
  1549.             break;

  1551.         case sw_quoted:
  1552.             r->quoted_uri = 1;

  1554.             if (ch >= '0' && ch <= '9') {
  1555.                 decoded = (u_char) (ch - '0');
  1556.                 state = sw_quoted_second;
  1557.                 ch = *p++;
  1558.                 break;
  1559.             }

  1561.             c = (u_char) (ch | 0x20);
  1562.             if (c >= 'a' && c <= 'f') {
  1563.                 decoded = (u_char) (c - 'a' + 10);
  1564.                 state = sw_quoted_second;
  1565.                 ch = *p++;
  1566.                 break;
  1567.             }

  1569.             return NGX_HTTP_PARSE_INVALID_REQUEST;

  1571.         case sw_quoted_second:
  1572.             if (ch >= '0' && ch <= '9') {
  1573.                 ch = (u_char) ((decoded << 4) + (ch - '0'));

  1575.                 if (ch == '%' || ch == '#') {
  1576.                     state = sw_usual;
  1577.                     *u++ = ch;
  1578.                     ch = *p++;
  1579.                     break;

  1581.                 } else if (ch == '\0') {
  1582.                     return NGX_HTTP_PARSE_INVALID_REQUEST;
  1583.                 }

  1585.                 state = quoted_state;
  1586.                 break;
  1587.             }

  1589.             c = (u_char) (ch | 0x20);
  1590.             if (c >= 'a' && c <= 'f') {
  1591.                 ch = (u_char) ((decoded << 4) + (c - 'a') + 10);

  1593.                 if (ch == '?') {
  1594.                     state = sw_usual;
  1595.                     *u++ = ch;
  1596.                     ch = *p++;
  1597.                     break;

  1599.                 } else if (ch == '+') {
  1600.                     r->plus_in_uri = 1;
  1601.                 }

  1603.                 state = quoted_state;
  1604.                 break;
  1605.             }

  1607.             return NGX_HTTP_PARSE_INVALID_REQUEST;
  1608.         }
  1609.     }

  1611.     if (state == sw_quoted || state == sw_quoted_second) {
  1612.         return NGX_HTTP_PARSE_INVALID_REQUEST;
  1613.     }

  1615.     if (state == sw_dot) {
  1616.         u--;

  1618.     } else if (state == sw_dot_dot) {
  1619.         u -= 4;

  1621.         for ( ;; ) {
  1622.             if (u < r->uri.data) {
  1623.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  1624.             }

  1626.             if (*u == '/') {
  1627.                 u++;
  1628.                 break;
  1629.             }

  1631.             u--;
  1632.         }
  1633.     }

  1635. done:

  1637.     r->uri.len = u - r->uri.data;

  1639.     if (r->uri_ext) {
  1640.         r->exten.len = u - r->uri_ext;
  1641.         r->exten.data = r->uri_ext;
  1642.     }

  1644.     r->uri_ext = NULL;

  1646.     return NGX_OK;

  1648. args:

  1650.     while (p < r->uri_end) {
  1651.         if (*p++ != '#') {
  1652.             continue;
  1653.         }

  1655.         r->args.len = p - 1 - r->args_start;
  1656.         r->args.data = r->args_start;
  1657.         r->args_start = NULL;

  1659.         break;
  1660.     }

  1662.     r->uri.len = u - r->uri.data;

  1664.     if (r->uri_ext) {
  1665.         r->exten.len = u - r->uri_ext;
  1666.         r->exten.data = r->uri_ext;
  1667.     }

  1669.     r->uri_ext = NULL;

  1671.     return NGX_OK;
  1672. }


  1675. ngx_int_t
  1676. ‌ngx_http_parse_status_line(ngx_http_request_t *r, ngx_buf_t *b,
  1677.     ngx_http_status_t *status)
  1678. {
  1679.     u_char   ch;
  1680.     u_char  *p;
  1681. ‌    enum {
  1682.         sw_start = 0,
  1683.         sw_H,
  1684.         sw_HT,
  1685.         sw_HTT,
  1686.         sw_HTTP,
  1687.         sw_first_major_digit,
  1688.         sw_major_digit,
  1689.         sw_first_minor_digit,
  1690.         sw_minor_digit,
  1691.         sw_status,
  1692.         sw_space_after_status,
  1693.         sw_status_text,
  1694.         sw_almost_done
  1695.     } state;

  1697.     state = r->state;

  1699.     for (p = b->pos; p < b->last; p++) {
  1700.         ch = *p;

  1702.         switch (state) {

  1704.         /* "HTTP/" */
  1705.         case sw_start:
  1706.             status->line_start = p;

  1708.             switch (ch) {
  1709.             case 'H':
  1710.                 state = sw_H;
  1711.                 break;
  1712.             default:
  1713.                 return NGX_ERROR;
  1714.             }
  1715.             break;

  1717.         case sw_H:
  1718.             switch (ch) {
  1719.             case 'T':
  1720.                 state = sw_HT;
  1721.                 break;
  1722.             default:
  1723.                 return NGX_ERROR;
  1724.             }
  1725.             break;

  1727.         case sw_HT:
  1728.             switch (ch) {
  1729.             case 'T':
  1730.                 state = sw_HTT;
  1731.                 break;
  1732.             default:
  1733.                 return NGX_ERROR;
  1734.             }
  1735.             break;

  1737.         case sw_HTT:
  1738.             switch (ch) {
  1739.             case 'P':
  1740.                 state = sw_HTTP;
  1741.                 break;
  1742.             default:
  1743.                 return NGX_ERROR;
  1744.             }
  1745.             break;

  1747.         case sw_HTTP:
  1748.             switch (ch) {
  1749.             case '/':
  1750.                 state = sw_first_major_digit;
  1751.                 break;
  1752.             default:
  1753.                 return NGX_ERROR;
  1754.             }
  1755.             break;

  1757.         /* the first digit of major HTTP version */
  1758.         case sw_first_major_digit:
  1759.             if (ch < '1' || ch > '9') {
  1760.                 return NGX_ERROR;
  1761.             }

  1763.             r->http_major = ch - '0';
  1764.             state = sw_major_digit;
  1765.             break;

  1767.         /* the major HTTP version or dot */
  1768.         case sw_major_digit:
  1769.             if (ch == '.') {
  1770.                 state = sw_first_minor_digit;
  1771.                 break;
  1772.             }

  1774.             if (ch < '0' || ch > '9') {
  1775.                 return NGX_ERROR;
  1776.             }

  1778.             if (r->http_major > 99) {
  1779.                 return NGX_ERROR;
  1780.             }

  1782.             r->http_major = r->http_major * 10 + (ch - '0');
  1783.             break;

  1785.         /* the first digit of minor HTTP version */
  1786.         case sw_first_minor_digit:
  1787.             if (ch < '0' || ch > '9') {
  1788.                 return NGX_ERROR;
  1789.             }

  1791.             r->http_minor = ch - '0';
  1792.             state = sw_minor_digit;
  1793.             break;

  1795.         /* the minor HTTP version or the end of the request line */
  1796.         case sw_minor_digit:
  1797.             if (ch == ' ') {
  1798.                 state = sw_status;
  1799.                 break;
  1800.             }

  1802.             if (ch < '0' || ch > '9') {
  1803.                 return NGX_ERROR;
  1804.             }

  1806.             if (r->http_minor > 99) {
  1807.                 return NGX_ERROR;
  1808.             }

  1810.             r->http_minor = r->http_minor * 10 + (ch - '0');
  1811.             break;

  1813.         /* HTTP status code */
  1814.         case sw_status:
  1815.             if (ch == ' ') {
  1816.                 break;
  1817.             }

  1819.             if (ch < '0' || ch > '9') {
  1820.                 return NGX_ERROR;
  1821.             }

  1823.             status->code = status->code * 10 + (ch - '0');

  1825.             if (++status->count == 3) {
  1826.                 state = sw_space_after_status;
  1827.                 status->start = p - 2;
  1828.             }

  1830.             break;

  1832.         /* space or end of line */
  1833.         case sw_space_after_status:
  1834.             switch (ch) {
  1835.             case ' ':
  1836.                 state = sw_status_text;
  1837.                 break;
  1838.             case '.':                    /* IIS may send 403.1, 403.2, etc */
  1839.                 state = sw_status_text;
  1840.                 break;
  1841.             case CR:
  1842.                 state = sw_almost_done;
  1843.                 break;
  1844.             case LF:
  1845.                 goto done;
  1846.             default:
  1847.                 return NGX_ERROR;
  1848.             }
  1849.             break;

  1851.         /* any text until end of line */
  1852.         case sw_status_text:
  1853.             switch (ch) {
  1854.             case CR:
  1855.                 state = sw_almost_done;

  1857.                 break;
  1858.             case LF:
  1859.                 goto done;
  1860.             }
  1861.             break;

  1863.         /* end of status line */
  1864.         case sw_almost_done:
  1865.             status->end = p - 1;
  1866.             switch (ch) {
  1867.             case LF:
  1868.                 goto done;
  1869.             default:
  1870.                 return NGX_ERROR;
  1871.             }
  1872.         }
  1873.     }

  1875.     b->pos = p;
  1876.     r->state = state;

  1878.     return NGX_AGAIN;

  1880. done:

  1882.     b->pos = p + 1;

  1884.     if (status->end == NULL) {
  1885.         status->end = p;
  1886.     }

  1888.     status->http_version = r->http_major * 1000 + r->http_minor;
  1889.     r->state = sw_start;

  1891.     return NGX_OK;
  1892. }


  1895. ngx_int_t
  1896. ‌ngx_http_parse_unsafe_uri(ngx_http_request_t *r, ngx_str_t *uri,
  1897.     ngx_str_t *args, ngx_uint_t *flags)
  1898. {
  1899.     u_char      ch, *p, *src, *dst;
  1900.     size_t      len;
  1901.     ngx_uint_t  quoted;

  1903.     len = uri->len;
  1904.     p = uri->data;
  1905.     quoted = 0;

  1907.     if (len == 0 || p[0] == '?') {
  1908.         goto unsafe;
  1909.     }

  1911.     if (p[0] == '.' && len > 1 && p[1] == '.'
  1912.         && (len == 2 || ngx_path_separator(p[2])))
  1913.     {
  1914.         goto unsafe;
  1915.     }

  1917.     for ( /* void */ ; len; len--) {

  1919.         ch = *p++;

  1921.         if (ch == '%') {
  1922.             quoted = 1;
  1923.             continue;
  1924.         }

  1926.         if (usual[ch >> 5] & (1U << (ch & 0x1f))) {
  1927.             continue;
  1928.         }

  1930.         if (ch == '?') {
  1931.             args->len = len - 1;
  1932.             args->data = p;
  1933.             uri->len -= len;

  1935.             break;
  1936.         }

  1938.         if (ch == '\0') {
  1939.             goto unsafe;
  1940.         }

  1942.         if (ngx_path_separator(ch) && len > 2) {

  1944.             /* detect "/../" and "/.." */

  1946.             if (p[0] == '.' && p[1] == '.'
  1947.                 && (len == 3 || ngx_path_separator(p[2])))
  1948.             {
  1949.                 goto unsafe;
  1950.             }
  1951.         }
  1952.     }

  1954.     if (quoted) {
  1955.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1956.                        "escaped URI: \"%V\"", uri);

  1958.         src = uri->data;

  1960.         dst = ngx_pnalloc(r->pool, uri->len);
  1961.         if (dst == NULL) {
  1962.             return NGX_ERROR;
  1963.         }

  1965.         uri->data = dst;

  1967.         ngx_unescape_uri(&dst, &src, uri->len, 0);

  1969.         uri->len = dst - uri->data;

  1971.         ngx_log_debug1(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  1972.                        "unescaped URI: \"%V\"", uri);

  1974.         len = uri->len;
  1975.         p = uri->data;

  1977.         if (p[0] == '.' && len > 1 && p[1] == '.'
  1978.             && (len == 2 || ngx_path_separator(p[2])))
  1979.         {
  1980.             goto unsafe;
  1981.         }

  1983.         for ( /* void */ ; len; len--) {

  1985.             ch = *p++;

  1987.             if (ch == '\0') {
  1988.                 goto unsafe;
  1989.             }

  1991.             if (ngx_path_separator(ch) && len > 2) {

  1993.                 /* detect "/../" and "/.." */

  1995.                 if (p[0] == '.' && p[1] == '.'
  1996.                     && (len == 3 || ngx_path_separator(p[2])))
  1997.                 {
  1998.                     goto unsafe;
  1999.                 }
  2000.             }
  2001.         }
  2002.     }

  2004.     return NGX_OK;

  2006. unsafe:

  2008.     if (*flags & NGX_HTTP_LOG_UNSAFE) {
  2009.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  2010.                       "unsafe URI \"%V\" was detected", uri);
  2011.     }

  2013.     return NGX_ERROR;
  2014. }


  2017. ngx_table_elt_t *
  2018. ‌ngx_http_parse_multi_header_lines(ngx_http_request_t *r,
  2019.     ngx_table_elt_t *headers, ngx_str_t *name, ngx_str_t *value)
  2020. {
  2021.     return ngx_http_parse_multi_header_lines_internal(r, headers, name, value,
  2022.                                                       ',');
  2023. }


  2026. ngx_table_elt_t *
  2027. ‌ngx_http_parse_cookie_lines(ngx_http_request_t *r,
  2028.     ngx_table_elt_t *headers, ngx_str_t *name, ngx_str_t *value)
  2029. {
  2030.     return ngx_http_parse_multi_header_lines_internal(r, headers, name, value,
  2031.                                                       ';');
  2032. }


  2035. static ngx_table_elt_t *
  2036. ‌ngx_http_parse_multi_header_lines_internal(ngx_http_request_t *r,
  2037.     ngx_table_elt_t *headers, ngx_str_t *name, ngx_str_t *value, u_char sep)
  2038. {
  2039.     u_char           *start, *last, *end, ch;
  2040.     ngx_table_elt_t  *h;

  2042.     for (h = headers; h; h = h->next) {

  2044.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2045.                        "parse header: \"%V: %V\"", &h->key, &h->value);

  2047.         if (name->len > h->value.len) {
  2048.             continue;
  2049.         }

  2051.         start = h->value.data;
  2052.         end = h->value.data + h->value.len;

  2054.         while (start < end) {

  2056.             if (ngx_strncasecmp(start, name->data, name->len) != 0) {
  2057.                 goto skip;
  2058.             }

  2060.             for (start += name->len; start < end && *start == ' '; start++) {
  2061.                 /* void */
  2062.             }

  2064.             if (value == NULL) {
  2065.                 if (start == end || *start == sep) {
  2066.                     return h;
  2067.                 }

  2069.                 goto skip;
  2070.             }

  2072.             if (start == end || *start++ != '=') {
  2073.                 /* the invalid header value */
  2074.                 goto skip;
  2075.             }

  2077.             while (start < end && *start == ' ') { start++; }

  2079.             for (last = start; last < end && *last != sep; last++) {
  2080.                 /* void */
  2081.             }

  2083.             value->len = last - start;
  2084.             value->data = start;

  2086.             return h;

  2088.         skip:

  2090.             while (start < end) {
  2091.                 ch = *start++;
  2092.                 if (ch == sep) {
  2093.                     break;
  2094.                 }
  2095.             }

  2097.             while (start < end && *start == ' ') { start++; }
  2098.         }
  2099.     }

  2101.     return NULL;
  2102. }


  2105. ngx_table_elt_t *
  2106. ‌ngx_http_parse_set_cookie_lines(ngx_http_request_t *r,
  2107.     ngx_table_elt_t *headers, ngx_str_t *name, ngx_str_t *value)
  2108. {
  2109.     u_char           *start, *last, *end;
  2110.     ngx_table_elt_t  *h;

  2112.     for (h = headers; h; h = h->next) {

  2114.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2115.                        "parse header: \"%V: %V\"", &h->key, &h->value);

  2117.         if (name->len >= h->value.len) {
  2118.             continue;
  2119.         }

  2121.         start = h->value.data;
  2122.         end = h->value.data + h->value.len;

  2124.         if (ngx_strncasecmp(start, name->data, name->len) != 0) {
  2125.             continue;
  2126.         }

  2128.         for (start += name->len; start < end && *start == ' '; start++) {
  2129.             /* void */
  2130.         }

  2132.         if (start == end || *start++ != '=') {
  2133.             /* the invalid header value */
  2134.             continue;
  2135.         }

  2137.         while (start < end && *start == ' ') { start++; }

  2139.         for (last = start; last < end && *last != ';'; last++) {
  2140.             /* void */
  2141.         }

  2143.         value->len = last - start;
  2144.         value->data = start;

  2146.         return h;
  2147.     }

  2149.     return NULL;
  2150. }


  2153. ngx_int_t
  2154. ‌ngx_http_arg(ngx_http_request_t *r, u_char *name, size_t len, ngx_str_t *value)
  2155. {
  2156.     u_char  *p, *last;

  2158.     if (r->args.len == 0) {
  2159.         return NGX_DECLINED;
  2160.     }

  2162.     p = r->args.data;
  2163.     last = p + r->args.len;

  2165.     for ( /* void */ ; p < last; p++) {

  2167.         /* we need '=' after name, so drop one char from last */

  2169.         p = ngx_strlcasestrn(p, last - 1, name, len - 1);

  2171.         if (p == NULL) {
  2172.             return NGX_DECLINED;
  2173.         }

  2175.         if ((p == r->args.data || *(p - 1) == '&') && *(p + len) == '=') {

  2177.             value->data = p + len + 1;

  2179.             p = ngx_strlchr(p, last, '&');

  2181.             if (p == NULL) {
  2182.                 p = r->args.data + r->args.len;
  2183.             }

  2185.             value->len = p - value->data;

  2187.             return NGX_OK;
  2188.         }
  2189.     }

  2191.     return NGX_DECLINED;
  2192. }


  2195. void
  2196. ‌ngx_http_split_args(ngx_http_request_t *r, ngx_str_t *uri, ngx_str_t *args)
  2197. {
  2198.     u_char  *p, *last;

  2200.     last = uri->data + uri->len;

  2202.     p = ngx_strlchr(uri->data, last, '?');

  2204.     if (p) {
  2205.         uri->len = p - uri->data;
  2206.         p++;
  2207.         args->len = last - p;
  2208.         args->data = p;

  2210.     } else {
  2211.         args->len = 0;
  2212.     }
  2213. }


  2216. ngx_int_t
  2217. ‌ngx_http_parse_chunked(ngx_http_request_t *r, ngx_buf_t *b,
  2218.     ngx_http_chunked_t *ctx, ngx_uint_t keep_trailers)
  2219. {
  2220.     u_char     *pos, ch, c;
  2221.     ngx_int_t   rc;
  2222. ‌    enum {
  2223.         sw_chunk_start = 0,
  2224.         sw_chunk_size,
  2225.         sw_chunk_extension,
  2226.         sw_chunk_extension_almost_done,
  2227.         sw_chunk_data,
  2228.         sw_after_data,
  2229.         sw_after_data_almost_done,
  2230.         sw_last_chunk_extension,
  2231.         sw_last_chunk_extension_almost_done,
  2232.         sw_trailer,
  2233.         sw_trailer_almost_done,
  2234.         sw_trailer_header,
  2235.         sw_trailer_header_almost_done
  2236.     } state;

  2238.     state = ctx->state;

  2240.     if (state == sw_chunk_data && ctx->size == 0) {
  2241.         state = sw_after_data;
  2242.     }

  2244.     rc = NGX_AGAIN;

  2246.     for (pos = b->pos; pos < b->last; pos++) {

  2248.         ch = *pos;

  2250.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  2251.                        "http chunked byte: %02Xd s:%d", ch, state);

  2253.         switch (state) {

  2255.         case sw_chunk_start:
  2256.             if (ch >= '0' && ch <= '9') {
  2257.                 state = sw_chunk_size;
  2258.                 ctx->size = ch - '0';
  2259.                 break;
  2260.             }

  2262.             c = (u_char) (ch | 0x20);

  2264.             if (c >= 'a' && c <= 'f') {
  2265.                 state = sw_chunk_size;
  2266.                 ctx->size = c - 'a' + 10;
  2267.                 break;
  2268.             }

  2270.             goto invalid;

  2272.         case sw_chunk_size:
  2273.             if (ctx->size > NGX_MAX_OFF_T_VALUE / 16) {
  2274.                 goto invalid;
  2275.             }

  2277.             if (ch >= '0' && ch <= '9') {
  2278.                 ctx->size = ctx->size * 16 + (ch - '0');
  2279.                 break;
  2280.             }

  2282.             c = (u_char) (ch | 0x20);

  2284.             if (c >= 'a' && c <= 'f') {
  2285.                 ctx->size = ctx->size * 16 + (c - 'a' + 10);
  2286.                 break;
  2287.             }

  2289.             if (ctx->size == 0) {

  2291.                 switch (ch) {
  2292.                 case CR:
  2293.                     state = sw_last_chunk_extension_almost_done;
  2294.                     break;
  2295.                 case ';':
  2296.                 case ' ':
  2297.                 case '\t':
  2298.                     state = sw_last_chunk_extension;
  2299.                     break;
  2300.                 default:
  2301.                     goto invalid;
  2302.                 }

  2304.                 break;
  2305.             }

  2307.             switch (ch) {
  2308.             case CR:
  2309.                 state = sw_chunk_extension_almost_done;
  2310.                 break;
  2311.             case ';':
  2312.             case ' ':
  2313.             case '\t':
  2314.                 state = sw_chunk_extension;
  2315.                 break;
  2316.             default:
  2317.                 goto invalid;
  2318.             }

  2320.             break;

  2322.         case sw_chunk_extension:
  2323.             switch (ch) {
  2324.             case CR:
  2325.                 state = sw_chunk_extension_almost_done;
  2326.                 break;
  2327.             case LF:
  2328.                 goto invalid;
  2329.             }
  2330.             break;

  2332.         case sw_chunk_extension_almost_done:
  2333.             if (ch == LF) {
  2334.                 state = sw_chunk_data;
  2335.                 break;
  2336.             }
  2337.             goto invalid;

  2339.         case sw_chunk_data:
  2340.             rc = NGX_OK;
  2341.             goto data;

  2343.         case sw_after_data:
  2344.             switch (ch) {
  2345.             case CR:
  2346.                 state = sw_after_data_almost_done;
  2347.                 break;
  2348.             default:
  2349.                 goto invalid;
  2350.             }
  2351.             break;

  2353.         case sw_after_data_almost_done:
  2354.             if (ch == LF) {
  2355.                 state = sw_chunk_start;
  2356.                 break;
  2357.             }
  2358.             goto invalid;

  2360.         case sw_last_chunk_extension:
  2361.             switch (ch) {
  2362.             case CR:
  2363.                 state = sw_last_chunk_extension_almost_done;
  2364.                 break;
  2365.             case LF:
  2366.                 goto invalid;
  2367.             }
  2368.             break;

  2370.         case sw_last_chunk_extension_almost_done:
  2371.             if (ch == LF) {
  2372.                 if (keep_trailers) {
  2373.                     goto done;
  2374.                 }
  2375.                 state = sw_trailer;
  2376.                 break;
  2377.             }
  2378.             goto invalid;

  2380.         case sw_trailer:
  2381.             switch (ch) {
  2382.             case CR:
  2383.                 state = sw_trailer_almost_done;
  2384.                 break;
  2385.             case LF:
  2386.                 goto invalid;
  2387.             default:
  2388.                 state = sw_trailer_header;
  2389.             }
  2390.             break;

  2392.         case sw_trailer_almost_done:
  2393.             if (ch == LF) {
  2394.                 goto done;
  2395.             }
  2396.             goto invalid;

  2398.         case sw_trailer_header:
  2399.             switch (ch) {
  2400.             case CR:
  2401.                 state = sw_trailer_header_almost_done;
  2402.                 break;
  2403.             case LF:
  2404.                 goto invalid;
  2405.             }
  2406.             break;

  2408.         case sw_trailer_header_almost_done:
  2409.             if (ch == LF) {
  2410.                 state = sw_trailer;
  2411.                 break;
  2412.             }
  2413.             goto invalid;

  2415.         }
  2416.     }

  2418. data:

  2420.     ctx->state = state;
  2421.     b->pos = pos;

  2423.     if (ctx->size > NGX_MAX_OFF_T_VALUE - 5) {
  2424.         goto invalid;
  2425.     }

  2427.     switch (state) {

  2429.     case sw_chunk_start:
  2430.         ctx->length = 5 /* "0" CRLF CRLF */;
  2431.         break;
  2432.     case sw_chunk_size:
  2433.         ctx->length = 2 /* CRLF */
  2434.                       + (ctx->size ? ctx->size + 7 /* CRLF "0" CRLF CRLF */
  2435.                                    : 2 /* CRLF */);
  2436.         break;
  2437.     case sw_chunk_extension:
  2438.         ctx->length = 2 /* CRLF */ + ctx->size + 7 /* CRLF "0" CRLF CRLF */;
  2439.         break;
  2440.     case sw_chunk_extension_almost_done:
  2441.         ctx->length = 1 /* LF */ + ctx->size + 7 /* CRLF "0" CRLF CRLF */;
  2442.         break;
  2443.     case sw_chunk_data:
  2444.         ctx->length = ctx->size + 7 /* CRLF "0" CRLF CRLF */;
  2445.         break;
  2446.     case sw_after_data:
  2447.         ctx->length = 7 /* CRLF "0" CRLF CRLF */;
  2448.         break;
  2449.     case sw_after_data_almost_done:
  2450.         ctx->length = 6 /* LF "0" CRLF CRLF */;
  2451.         break;
  2452.     case sw_last_chunk_extension:
  2453.         ctx->length = 4 /* CRLF CRLF */;
  2454.         break;
  2455.     case sw_last_chunk_extension_almost_done:
  2456.         ctx->length = 3 /* LF CRLF */;
  2457.         break;
  2458.     case sw_trailer:
  2459.         ctx->length = 2 /* CRLF */;
  2460.         break;
  2461.     case sw_trailer_almost_done:
  2462.         ctx->length = 1 /* LF */;
  2463.         break;
  2464.     case sw_trailer_header:
  2465.         ctx->length = 4 /* CRLF CRLF */;
  2466.         break;
  2467.     case sw_trailer_header_almost_done:
  2468.         ctx->length = 3 /* LF CRLF */;
  2469.         break;

  2471.     }

  2473.     return rc;

  2475. done:

  2477.     ctx->state = 0;
  2478.     b->pos = pos + 1;

  2480.     return NGX_DONE;

  2482. invalid:

  2484.     return NGX_ERROR;
  2485. }

One Level Up Top Level