One Level Up Top Level

src/http/ngx_http_parse.c - nginx-1.31.9 nginx/ @ 2a3a19c6f

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.             /* IIS may send the duplicate "HTTP/1.1 ..." lines */
  993.             if (ch == '/'
  994.                 && r->upstream
  995.                 && p - r->header_name_start == 4
  996.                 && ngx_strncmp(r->header_name_start, "HTTP", 4) == 0)
  997.             {
  998.                 state = sw_ignore_line;
  999.                 break;
  1000.             }

  1002.             if (ch <= 0x20 || ch == 0x7f) {
  1003.                 r->header_end = p;
  1004.                 return NGX_HTTP_PARSE_INVALID_HEADER;
  1005.             }

  1007.             r->invalid_header = 1;

  1009.             break;

  1011.         /* space* before header value */
  1012.         case sw_space_before_value:
  1013.             switch (ch) {
  1014.             case ' ':
  1015.                 break;
  1016.             case CR:
  1017.                 r->header_start = p;
  1018.                 r->header_end = p;
  1019.                 state = sw_almost_done;
  1020.                 break;
  1021.             case LF:
  1022.                 r->header_start = p;
  1023.                 r->header_end = p;
  1024.                 goto done;
  1025.             case '\0':
  1026.                 r->header_end = p;
  1027.                 return NGX_HTTP_PARSE_INVALID_HEADER;
  1028.             default:
  1029.                 r->header_start = p;
  1030.                 state = sw_value;
  1031.                 break;
  1032.             }
  1033.             break;

  1035.         /* header value */
  1036.         case sw_value:
  1037.             switch (ch) {
  1038.             case ' ':
  1039.                 r->header_end = p;
  1040.                 state = sw_space_after_value;
  1041.                 break;
  1042.             case CR:
  1043.                 r->header_end = p;
  1044.                 state = sw_almost_done;
  1045.                 break;
  1046.             case LF:
  1047.                 r->header_end = p;
  1048.                 goto done;
  1049.             case '\0':
  1050.                 r->header_end = p;
  1051.                 return NGX_HTTP_PARSE_INVALID_HEADER;
  1052.             }
  1053.             break;

  1055.         /* space* before end of header line */
  1056.         case sw_space_after_value:
  1057.             switch (ch) {
  1058.             case ' ':
  1059.                 break;
  1060.             case CR:
  1061.                 state = sw_almost_done;
  1062.                 break;
  1063.             case LF:
  1064.                 goto done;
  1065.             case '\0':
  1066.                 r->header_end = p;
  1067.                 return NGX_HTTP_PARSE_INVALID_HEADER;
  1068.             default:
  1069.                 state = sw_value;
  1070.                 break;
  1071.             }
  1072.             break;

  1074.         /* ignore header line */
  1075.         case sw_ignore_line:
  1076.             switch (ch) {
  1077.             case LF:
  1078.                 state = sw_start;
  1079.                 break;
  1080.             default:
  1081.                 break;
  1082.             }
  1083.             break;

  1085.         /* end of header line */
  1086.         case sw_almost_done:
  1087.             switch (ch) {
  1088.             case LF:
  1089.                 goto done;
  1090.             case CR:
  1091.                 break;
  1092.             default:
  1093.                 return NGX_HTTP_PARSE_INVALID_HEADER;
  1094.             }
  1095.             break;

  1097.         /* end of header */
  1098.         case sw_header_almost_done:
  1099.             switch (ch) {
  1100.             case LF:
  1101.                 goto header_done;
  1102.             default:
  1103.                 return NGX_HTTP_PARSE_INVALID_HEADER;
  1104.             }
  1105.         }
  1106.     }

  1108.     b->pos = p;
  1109.     r->state = state;
  1110.     r->header_hash = hash;
  1111.     r->lowcase_index = i;

  1113.     return NGX_AGAIN;

  1115. done:

  1117.     b->pos = p + 1;
  1118.     r->state = sw_start;
  1119.     r->header_hash = hash;
  1120.     r->lowcase_index = i;

  1122.     return NGX_OK;

  1124. header_done:

  1126.     b->pos = p + 1;
  1127.     r->state = sw_start;

  1129.     return NGX_HTTP_PARSE_HEADER_DONE;
  1130. }


  1133. ngx_int_t
  1134. ‌ngx_http_parse_uri(ngx_http_request_t *r)
  1135. {
  1136.     u_char  *p, ch;
  1137. ‌    enum {
  1138.         sw_start = 0,
  1139.         sw_after_slash_in_uri,
  1140.         sw_check_uri,
  1141.         sw_uri
  1142.     } state;

  1144.     state = sw_start;

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

  1148.         ch = *p;

  1150.         switch (state) {

  1152.         case sw_start:

  1154.             if (ch != '/') {
  1155.                 return NGX_ERROR;
  1156.             }

  1158.             state = sw_after_slash_in_uri;
  1159.             break;

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

  1164.             if (usual[ch >> 5] & (1U << (ch & 0x1f))) {
  1165.                 state = sw_check_uri;
  1166.                 break;
  1167.             }

  1169.             switch (ch) {
  1170.             case '.':
  1171.                 r->complex_uri = 1;
  1172.                 state = sw_uri;
  1173.                 break;
  1174.             case '%':
  1175.                 r->quoted_uri = 1;
  1176.                 state = sw_uri;
  1177.                 break;
  1178.             case '/':
  1179.                 r->complex_uri = 1;
  1180.                 state = sw_uri;
  1181.                 break;
  1182. #if (NGX_WIN32)
  1183.             case '\\':
  1184.                 r->complex_uri = 1;
  1185.                 state = sw_uri;
  1186.                 break;
  1187. #endif
  1188.             case '?':
  1189.                 r->args_start = p + 1;
  1190.                 state = sw_uri;
  1191.                 break;
  1192.             case '#':
  1193.                 r->complex_uri = 1;
  1194.                 state = sw_uri;
  1195.                 break;
  1196.             case '+':
  1197.                 r->plus_in_uri = 1;
  1198.                 break;
  1199.             default:
  1200.                 if (ch <= 0x20 || ch == 0x7f) {
  1201.                     return NGX_ERROR;
  1202.                 }
  1203.                 state = sw_check_uri;
  1204.                 break;
  1205.             }
  1206.             break;

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

  1211.             if (usual[ch >> 5] & (1U << (ch & 0x1f))) {
  1212.                 break;
  1213.             }

  1215.             switch (ch) {
  1216.             case '/':
  1217. #if (NGX_WIN32)
  1218.                 if (r->uri_ext == p) {
  1219.                     r->complex_uri = 1;
  1220.                     state = sw_uri;
  1221.                     break;
  1222.                 }
  1223. #endif
  1224.                 r->uri_ext = NULL;
  1225.                 state = sw_after_slash_in_uri;
  1226.                 break;
  1227.             case '.':
  1228.                 r->uri_ext = p + 1;
  1229.                 break;
  1230. #if (NGX_WIN32)
  1231.             case '\\':
  1232.                 r->complex_uri = 1;
  1233.                 state = sw_after_slash_in_uri;
  1234.                 break;
  1235. #endif
  1236.             case '%':
  1237.                 r->quoted_uri = 1;
  1238.                 state = sw_uri;
  1239.                 break;
  1240.             case '?':
  1241.                 r->args_start = p + 1;
  1242.                 state = sw_uri;
  1243.                 break;
  1244.             case '#':
  1245.                 r->complex_uri = 1;
  1246.                 state = sw_uri;
  1247.                 break;
  1248.             case '+':
  1249.                 r->plus_in_uri = 1;
  1250.                 break;
  1251.             default:
  1252.                 if (ch <= 0x20 || ch == 0x7f) {
  1253.                     return NGX_ERROR;
  1254.                 }
  1255.                 break;
  1256.             }
  1257.             break;

  1259.         /* URI */
  1260.         case sw_uri:

  1262.             if (usual[ch >> 5] & (1U << (ch & 0x1f))) {
  1263.                 break;
  1264.             }

  1266.             switch (ch) {
  1267.             case '#':
  1268.                 r->complex_uri = 1;
  1269.                 break;
  1270.             default:
  1271.                 if (ch <= 0x20 || ch == 0x7f) {
  1272.                     return NGX_ERROR;
  1273.                 }
  1274.                 break;
  1275.             }
  1276.             break;
  1277.         }
  1278.     }

  1280.     return NGX_OK;
  1281. }


  1284. ngx_int_t
  1285. ‌ngx_http_parse_complex_uri(ngx_http_request_t *r, ngx_uint_t merge_slashes)
  1286. {
  1287.     u_char  c, ch, decoded, *p, *u;
  1288. ‌    enum {
  1289.         sw_usual = 0,
  1290.         sw_slash,
  1291.         sw_dot,
  1292.         sw_dot_dot,
  1293.         sw_quoted,
  1294.         sw_quoted_second
  1295.     } state, quoted_state;

  1297. #if (NGX_SUPPRESS_WARN)
  1298.     decoded = '\0';
  1299.     quoted_state = sw_usual;
  1300. #endif

  1302.     state = sw_usual;
  1303.     p = r->uri_start;
  1304.     u = r->uri.data;
  1305.     r->uri_ext = NULL;
  1306.     r->args_start = NULL;

  1308.     if (r->empty_path_in_uri) {
  1309.         *u++ = '/';
  1310.     }

  1312.     ch = *p++;

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

  1316.         /*
  1317.          * we use "ch = *p++" inside the cycle, but this operation is safe,
  1318.          * because after the URI there is always at least one character:
  1319.          * the line feed
  1320.          */

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

  1325.         switch (state) {

  1327.         case sw_usual:

  1329.             if (usual[ch >> 5] & (1U << (ch & 0x1f))) {
  1330.                 *u++ = ch;
  1331.                 ch = *p++;
  1332.                 break;
  1333.             }

  1335.             switch (ch) {
  1336. #if (NGX_WIN32)
  1337.             case '\\':
  1338.                 if (u - 2 >= r->uri.data
  1339.                     && *(u - 1) == '.' && *(u - 2) != '.')
  1340.                 {
  1341.                     u--;
  1342.                 }

  1344.                 r->uri_ext = NULL;

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

  1348.                     /*
  1349.                      * we omit the last "\" to cause redirect because
  1350.                      * the browsers do not treat "\" as "/" in relative URL path
  1351.                      */

  1353.                     break;
  1354.                 }

  1356.                 state = sw_slash;
  1357.                 *u++ = '/';
  1358.                 break;
  1359. #endif
  1360.             case '/':
  1361. #if (NGX_WIN32)
  1362.                 if (u - 2 >= r->uri.data
  1363.                     && *(u - 1) == '.' && *(u - 2) != '.')
  1364.                 {
  1365.                     u--;
  1366.                 }
  1367. #endif
  1368.                 r->uri_ext = NULL;
  1369.                 state = sw_slash;
  1370.                 *u++ = ch;
  1371.                 break;
  1372.             case '%':
  1373.                 quoted_state = state;
  1374.                 state = sw_quoted;
  1375.                 break;
  1376.             case '?':
  1377.                 r->args_start = p;
  1378.                 goto args;
  1379.             case '#':
  1380.                 goto done;
  1381.             case '.':
  1382.                 r->uri_ext = u + 1;
  1383.                 *u++ = ch;
  1384.                 break;
  1385.             case '+':
  1386.                 r->plus_in_uri = 1;
  1387.                 /* fall through */
  1388.             default:
  1389.                 *u++ = ch;
  1390.                 break;
  1391.             }

  1393.             ch = *p++;
  1394.             break;

  1396.         case sw_slash:

  1398.             if (usual[ch >> 5] & (1U << (ch & 0x1f))) {
  1399.                 state = sw_usual;
  1400.                 *u++ = ch;
  1401.                 ch = *p++;
  1402.                 break;
  1403.             }

  1405.             switch (ch) {
  1406. #if (NGX_WIN32)
  1407.             case '\\':
  1408.                 break;
  1409. #endif
  1410.             case '/':
  1411.                 if (!merge_slashes) {
  1412.                     *u++ = ch;
  1413.                 }
  1414.                 break;
  1415.             case '.':
  1416.                 state = sw_dot;
  1417.                 *u++ = ch;
  1418.                 break;
  1419.             case '%':
  1420.                 quoted_state = state;
  1421.                 state = sw_quoted;
  1422.                 break;
  1423.             case '?':
  1424.                 r->args_start = p;
  1425.                 goto args;
  1426.             case '#':
  1427.                 goto done;
  1428.             case '+':
  1429.                 r->plus_in_uri = 1;
  1430.                 /* fall through */
  1431.             default:
  1432.                 state = sw_usual;
  1433.                 *u++ = ch;
  1434.                 break;
  1435.             }

  1437.             ch = *p++;
  1438.             break;

  1440.         case sw_dot:

  1442.             if (usual[ch >> 5] & (1U << (ch & 0x1f))) {
  1443.                 state = sw_usual;
  1444.                 *u++ = ch;
  1445.                 ch = *p++;
  1446.                 break;
  1447.             }

  1449.             switch (ch) {
  1450. #if (NGX_WIN32)
  1451.             case '\\':
  1452. #endif
  1453.             case '/':
  1454.                 state = sw_slash;
  1455.                 u--;
  1456.                 break;
  1457.             case '.':
  1458.                 state = sw_dot_dot;
  1459.                 *u++ = ch;
  1460.                 break;
  1461.             case '%':
  1462.                 quoted_state = state;
  1463.                 state = sw_quoted;
  1464.                 break;
  1465.             case '?':
  1466.                 u--;
  1467.                 r->args_start = p;
  1468.                 goto args;
  1469.             case '#':
  1470.                 u--;
  1471.                 goto done;
  1472.             case '+':
  1473.                 r->plus_in_uri = 1;
  1474.                 /* fall through */
  1475.             default:
  1476.                 state = sw_usual;
  1477.                 *u++ = ch;
  1478.                 break;
  1479.             }

  1481.             ch = *p++;
  1482.             break;

  1484.         case sw_dot_dot:

  1486.             if (usual[ch >> 5] & (1U << (ch & 0x1f))) {
  1487.                 state = sw_usual;
  1488.                 *u++ = ch;
  1489.                 ch = *p++;
  1490.                 break;
  1491.             }

  1493.             switch (ch) {
  1494. #if (NGX_WIN32)
  1495.             case '\\':
  1496. #endif
  1497.             case '/':
  1498.             case '?':
  1499.             case '#':
  1500.                 u -= 4;
  1501.                 for ( ;; ) {
  1502.                     if (u < r->uri.data) {
  1503.                         return NGX_HTTP_PARSE_INVALID_REQUEST;
  1504.                     }
  1505.                     if (*u == '/') {
  1506.                         u++;
  1507.                         break;
  1508.                     }
  1509.                     u--;
  1510.                 }
  1511.                 if (ch == '?') {
  1512.                     r->args_start = p;
  1513.                     goto args;
  1514.                 }
  1515.                 if (ch == '#') {
  1516.                     goto done;
  1517.                 }
  1518.                 state = sw_slash;
  1519.                 break;
  1520.             case '%':
  1521.                 quoted_state = state;
  1522.                 state = sw_quoted;
  1523.                 break;
  1524.             case '+':
  1525.                 r->plus_in_uri = 1;
  1526.                 /* fall through */
  1527.             default:
  1528.                 state = sw_usual;
  1529.                 *u++ = ch;
  1530.                 break;
  1531.             }

  1533.             ch = *p++;
  1534.             break;

  1536.         case sw_quoted:
  1537.             r->quoted_uri = 1;

  1539.             if (ch >= '0' && ch <= '9') {
  1540.                 decoded = (u_char) (ch - '0');
  1541.                 state = sw_quoted_second;
  1542.                 ch = *p++;
  1543.                 break;
  1544.             }

  1546.             c = (u_char) (ch | 0x20);
  1547.             if (c >= 'a' && c <= 'f') {
  1548.                 decoded = (u_char) (c - 'a' + 10);
  1549.                 state = sw_quoted_second;
  1550.                 ch = *p++;
  1551.                 break;
  1552.             }

  1554.             return NGX_HTTP_PARSE_INVALID_REQUEST;

  1556.         case sw_quoted_second:
  1557.             if (ch >= '0' && ch <= '9') {
  1558.                 ch = (u_char) ((decoded << 4) + (ch - '0'));

  1560.                 if (ch == '%' || ch == '#') {
  1561.                     state = sw_usual;
  1562.                     *u++ = ch;
  1563.                     ch = *p++;
  1564.                     break;

  1566.                 } else if (ch == '\0') {
  1567.                     return NGX_HTTP_PARSE_INVALID_REQUEST;
  1568.                 }

  1570.                 state = quoted_state;
  1571.                 break;
  1572.             }

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

  1578.                 if (ch == '?') {
  1579.                     state = sw_usual;
  1580.                     *u++ = ch;
  1581.                     ch = *p++;
  1582.                     break;

  1584.                 } else if (ch == '+') {
  1585.                     r->plus_in_uri = 1;
  1586.                 }

  1588.                 state = quoted_state;
  1589.                 break;
  1590.             }

  1592.             return NGX_HTTP_PARSE_INVALID_REQUEST;
  1593.         }
  1594.     }

  1596.     if (state == sw_quoted || state == sw_quoted_second) {
  1597.         return NGX_HTTP_PARSE_INVALID_REQUEST;
  1598.     }

  1600.     if (state == sw_dot) {
  1601.         u--;

  1603.     } else if (state == sw_dot_dot) {
  1604.         u -= 4;

  1606.         for ( ;; ) {
  1607.             if (u < r->uri.data) {
  1608.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  1609.             }

  1611.             if (*u == '/') {
  1612.                 u++;
  1613.                 break;
  1614.             }

  1616.             u--;
  1617.         }
  1618.     }

  1620. done:

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

  1624.     if (r->uri_ext) {
  1625.         r->exten.len = u - r->uri_ext;
  1626.         r->exten.data = r->uri_ext;
  1627.     }

  1629.     r->uri_ext = NULL;

  1631.     return NGX_OK;

  1633. args:

  1635.     while (p < r->uri_end) {
  1636.         if (*p++ != '#') {
  1637.             continue;
  1638.         }

  1640.         r->args.len = p - 1 - r->args_start;
  1641.         r->args.data = r->args_start;
  1642.         r->args_start = NULL;

  1644.         break;
  1645.     }

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

  1649.     if (r->uri_ext) {
  1650.         r->exten.len = u - r->uri_ext;
  1651.         r->exten.data = r->uri_ext;
  1652.     }

  1654.     r->uri_ext = NULL;

  1656.     return NGX_OK;
  1657. }


  1660. ngx_int_t
  1661. ‌ngx_http_parse_status_line(ngx_http_request_t *r, ngx_buf_t *b,
  1662.     ngx_http_status_t *status)
  1663. {
  1664.     u_char   ch;
  1665.     u_char  *p;
  1666. ‌    enum {
  1667.         sw_start = 0,
  1668.         sw_H,
  1669.         sw_HT,
  1670.         sw_HTT,
  1671.         sw_HTTP,
  1672.         sw_first_major_digit,
  1673.         sw_major_digit,
  1674.         sw_first_minor_digit,
  1675.         sw_minor_digit,
  1676.         sw_status,
  1677.         sw_space_after_status,
  1678.         sw_status_text,
  1679.         sw_almost_done
  1680.     } state;

  1682.     state = r->state;

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

  1687.         switch (state) {

  1689.         /* "HTTP/" */
  1690.         case sw_start:
  1691.             status->line_start = p;

  1693.             switch (ch) {
  1694.             case 'H':
  1695.                 state = sw_H;
  1696.                 break;
  1697.             default:
  1698.                 return NGX_ERROR;
  1699.             }
  1700.             break;

  1702.         case sw_H:
  1703.             switch (ch) {
  1704.             case 'T':
  1705.                 state = sw_HT;
  1706.                 break;
  1707.             default:
  1708.                 return NGX_ERROR;
  1709.             }
  1710.             break;

  1712.         case sw_HT:
  1713.             switch (ch) {
  1714.             case 'T':
  1715.                 state = sw_HTT;
  1716.                 break;
  1717.             default:
  1718.                 return NGX_ERROR;
  1719.             }
  1720.             break;

  1722.         case sw_HTT:
  1723.             switch (ch) {
  1724.             case 'P':
  1725.                 state = sw_HTTP;
  1726.                 break;
  1727.             default:
  1728.                 return NGX_ERROR;
  1729.             }
  1730.             break;

  1732.         case sw_HTTP:
  1733.             switch (ch) {
  1734.             case '/':
  1735.                 state = sw_first_major_digit;
  1736.                 break;
  1737.             default:
  1738.                 return NGX_ERROR;
  1739.             }
  1740.             break;

  1742.         /* the first digit of major HTTP version */
  1743.         case sw_first_major_digit:
  1744.             if (ch < '1' || ch > '9') {
  1745.                 return NGX_ERROR;
  1746.             }

  1748.             r->http_major = ch - '0';
  1749.             state = sw_major_digit;
  1750.             break;

  1752.         /* the major HTTP version or dot */
  1753.         case sw_major_digit:
  1754.             if (ch == '.') {
  1755.                 state = sw_first_minor_digit;
  1756.                 break;
  1757.             }

  1759.             if (ch < '0' || ch > '9') {
  1760.                 return NGX_ERROR;
  1761.             }

  1763.             if (r->http_major > 99) {
  1764.                 return NGX_ERROR;
  1765.             }

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

  1770.         /* the first digit of minor HTTP version */
  1771.         case sw_first_minor_digit:
  1772.             if (ch < '0' || ch > '9') {
  1773.                 return NGX_ERROR;
  1774.             }

  1776.             r->http_minor = ch - '0';
  1777.             state = sw_minor_digit;
  1778.             break;

  1780.         /* the minor HTTP version or the end of the request line */
  1781.         case sw_minor_digit:
  1782.             if (ch == ' ') {
  1783.                 state = sw_status;
  1784.                 break;
  1785.             }

  1787.             if (ch < '0' || ch > '9') {
  1788.                 return NGX_ERROR;
  1789.             }

  1791.             if (r->http_minor > 99) {
  1792.                 return NGX_ERROR;
  1793.             }

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

  1798.         /* HTTP status code */
  1799.         case sw_status:
  1800.             if (ch == ' ') {
  1801.                 break;
  1802.             }

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

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

  1810.             if (++status->count == 3) {
  1811.                 state = sw_space_after_status;
  1812.                 status->start = p - 2;
  1813.             }

  1815.             break;

  1817.         /* space or end of line */
  1818.         case sw_space_after_status:
  1819.             switch (ch) {
  1820.             case ' ':
  1821.                 state = sw_status_text;
  1822.                 break;
  1823.             case '.':                    /* IIS may send 403.1, 403.2, etc */
  1824.                 state = sw_status_text;
  1825.                 break;
  1826.             case CR:
  1827.                 state = sw_almost_done;
  1828.                 break;
  1829.             case LF:
  1830.                 goto done;
  1831.             default:
  1832.                 return NGX_ERROR;
  1833.             }
  1834.             break;

  1836.         /* any text until end of line */
  1837.         case sw_status_text:
  1838.             switch (ch) {
  1839.             case CR:
  1840.                 state = sw_almost_done;

  1842.                 break;
  1843.             case LF:
  1844.                 goto done;
  1845.             }
  1846.             break;

  1848.         /* end of status line */
  1849.         case sw_almost_done:
  1850.             status->end = p - 1;
  1851.             switch (ch) {
  1852.             case LF:
  1853.                 goto done;
  1854.             default:
  1855.                 return NGX_ERROR;
  1856.             }
  1857.         }
  1858.     }

  1860.     b->pos = p;
  1861.     r->state = state;

  1863.     return NGX_AGAIN;

  1865. done:

  1867.     b->pos = p + 1;

  1869.     if (status->end == NULL) {
  1870.         status->end = p;
  1871.     }

  1873.     status->http_version = r->http_major * 1000 + r->http_minor;
  1874.     r->state = sw_start;

  1876.     return NGX_OK;
  1877. }


  1880. ngx_int_t
  1881. ‌ngx_http_parse_unsafe_uri(ngx_http_request_t *r, ngx_str_t *uri,
  1882.     ngx_str_t *args, ngx_uint_t *flags)
  1883. {
  1884.     u_char      ch, *p, *src, *dst;
  1885.     size_t      len;
  1886.     ngx_uint_t  quoted;

  1888.     len = uri->len;
  1889.     p = uri->data;
  1890.     quoted = 0;

  1892.     if (len == 0 || p[0] == '?') {
  1893.         goto unsafe;
  1894.     }

  1896.     if (p[0] == '.' && len > 1 && p[1] == '.'
  1897.         && (len == 2 || ngx_path_separator(p[2])))
  1898.     {
  1899.         goto unsafe;
  1900.     }

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

  1904.         ch = *p++;

  1906.         if (ch == '%') {
  1907.             quoted = 1;
  1908.             continue;
  1909.         }

  1911.         if (usual[ch >> 5] & (1U << (ch & 0x1f))) {
  1912.             continue;
  1913.         }

  1915.         if (ch == '?') {
  1916.             args->len = len - 1;
  1917.             args->data = p;
  1918.             uri->len -= len;

  1920.             break;
  1921.         }

  1923.         if (ch == '\0') {
  1924.             goto unsafe;
  1925.         }

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

  1929.             /* detect "/../" and "/.." */

  1931.             if (p[0] == '.' && p[1] == '.'
  1932.                 && (len == 3 || ngx_path_separator(p[2])))
  1933.             {
  1934.                 goto unsafe;
  1935.             }
  1936.         }
  1937.     }

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

  1943.         src = uri->data;

  1945.         dst = ngx_pnalloc(r->pool, uri->len);
  1946.         if (dst == NULL) {
  1947.             return NGX_ERROR;
  1948.         }

  1950.         uri->data = dst;

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

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

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

  1959.         len = uri->len;
  1960.         p = uri->data;

  1962.         if (p[0] == '.' && len > 1 && p[1] == '.'
  1963.             && (len == 2 || ngx_path_separator(p[2])))
  1964.         {
  1965.             goto unsafe;
  1966.         }

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

  1970.             ch = *p++;

  1972.             if (ch == '\0') {
  1973.                 goto unsafe;
  1974.             }

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

  1978.                 /* detect "/../" and "/.." */

  1980.                 if (p[0] == '.' && p[1] == '.'
  1981.                     && (len == 3 || ngx_path_separator(p[2])))
  1982.                 {
  1983.                     goto unsafe;
  1984.                 }
  1985.             }
  1986.         }
  1987.     }

  1989.     return NGX_OK;

  1991. unsafe:

  1993.     if (*flags & NGX_HTTP_LOG_UNSAFE) {
  1994.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1995.                       "unsafe URI \"%V\" was detected", uri);
  1996.     }

  1998.     return NGX_ERROR;
  1999. }


  2002. ngx_table_elt_t *
  2003. ‌ngx_http_parse_multi_header_lines(ngx_http_request_t *r,
  2004.     ngx_table_elt_t *headers, ngx_str_t *name, ngx_str_t *value)
  2005. {
  2006.     return ngx_http_parse_multi_header_lines_internal(r, headers, name, value,
  2007.                                                       ',');
  2008. }


  2011. ngx_table_elt_t *
  2012. ‌ngx_http_parse_cookie_lines(ngx_http_request_t *r,
  2013.     ngx_table_elt_t *headers, ngx_str_t *name, ngx_str_t *value)
  2014. {
  2015.     return ngx_http_parse_multi_header_lines_internal(r, headers, name, value,
  2016.                                                       ';');
  2017. }


  2020. static ngx_table_elt_t *
  2021. ‌ngx_http_parse_multi_header_lines_internal(ngx_http_request_t *r,
  2022.     ngx_table_elt_t *headers, ngx_str_t *name, ngx_str_t *value, u_char sep)
  2023. {
  2024.     u_char           *start, *last, *end, ch;
  2025.     ngx_table_elt_t  *h;

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

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

  2032.         if (name->len > h->value.len) {
  2033.             continue;
  2034.         }

  2036.         start = h->value.data;
  2037.         end = h->value.data + h->value.len;

  2039.         while (start < end) {

  2041.             if (ngx_strncasecmp(start, name->data, name->len) != 0) {
  2042.                 goto skip;
  2043.             }

  2045.             for (start += name->len; start < end && *start == ' '; start++) {
  2046.                 /* void */
  2047.             }

  2049.             if (value == NULL) {
  2050.                 if (start == end || *start == sep) {
  2051.                     return h;
  2052.                 }

  2054.                 goto skip;
  2055.             }

  2057.             if (start == end || *start != '=') {
  2058.                 /* the invalid header value */
  2059.                 goto skip;
  2060.             }

  2062.             start++;

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

  2066.             for (last = start; last < end && *last != sep; last++) {
  2067.                 /* void */
  2068.             }

  2070.             value->len = last - start;
  2071.             value->data = start;

  2073.             return h;

  2075.         skip:

  2077.             while (start < end) {
  2078.                 ch = *start++;
  2079.                 if (ch == sep) {
  2080.                     break;
  2081.                 }
  2082.             }

  2084.             while (start < end && *start == ' ') { start++; }
  2085.         }
  2086.     }

  2088.     return NULL;
  2089. }


  2092. ngx_table_elt_t *
  2093. ‌ngx_http_parse_set_cookie_lines(ngx_http_request_t *r,
  2094.     ngx_table_elt_t *headers, ngx_str_t *name, ngx_str_t *value)
  2095. {
  2096.     u_char           *start, *last, *end;
  2097.     ngx_table_elt_t  *h;

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

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

  2104.         if (name->len >= h->value.len) {
  2105.             continue;
  2106.         }

  2108.         start = h->value.data;
  2109.         end = h->value.data + h->value.len;

  2111.         if (ngx_strncasecmp(start, name->data, name->len) != 0) {
  2112.             continue;
  2113.         }

  2115.         for (start += name->len; start < end && *start == ' '; start++) {
  2116.             /* void */
  2117.         }

  2119.         if (start == end || *start++ != '=') {
  2120.             /* the invalid header value */
  2121.             continue;
  2122.         }

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

  2126.         for (last = start; last < end && *last != ';'; last++) {
  2127.             /* void */
  2128.         }

  2130.         value->len = last - start;
  2131.         value->data = start;

  2133.         return h;
  2134.     }

  2136.     return NULL;
  2137. }


  2140. ngx_int_t
  2141. ‌ngx_http_arg(ngx_http_request_t *r, u_char *name, size_t len, ngx_str_t *value)
  2142. {
  2143.     u_char  *p, *last;

  2145.     if (r->args.len == 0) {
  2146.         return NGX_DECLINED;
  2147.     }

  2149.     p = r->args.data;
  2150.     last = p + r->args.len;

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

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

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

  2158.         if (p == NULL) {
  2159.             return NGX_DECLINED;
  2160.         }

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

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

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

  2168.             if (p == NULL) {
  2169.                 p = r->args.data + r->args.len;
  2170.             }

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

  2174.             return NGX_OK;
  2175.         }
  2176.     }

  2178.     return NGX_DECLINED;
  2179. }


  2182. void
  2183. ‌ngx_http_split_args(ngx_http_request_t *r, ngx_str_t *uri, ngx_str_t *args)
  2184. {
  2185.     u_char  *p, *last;

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

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

  2191.     if (p) {
  2192.         uri->len = p - uri->data;
  2193.         p++;
  2194.         args->len = last - p;
  2195.         args->data = p;

  2197.     } else {
  2198.         args->len = 0;
  2199.     }
  2200. }


  2203. ngx_int_t
  2204. ‌ngx_http_parse_chunked(ngx_http_request_t *r, ngx_buf_t *b,
  2205.     ngx_http_chunked_t *ctx, ngx_uint_t keep_trailers)
  2206. {
  2207.     u_char     *pos, ch, c;
  2208.     ngx_int_t   rc;
  2209. ‌    enum {
  2210.         sw_chunk_start = 0,
  2211.         sw_chunk_size,
  2212.         sw_chunk_extension,
  2213.         sw_chunk_extension_almost_done,
  2214.         sw_chunk_data,
  2215.         sw_after_data,
  2216.         sw_after_data_almost_done,
  2217.         sw_last_chunk_extension,
  2218.         sw_last_chunk_extension_almost_done,
  2219.         sw_trailer,
  2220.         sw_trailer_almost_done,
  2221.         sw_trailer_header,
  2222.         sw_trailer_header_almost_done
  2223.     } state;

  2225.     state = ctx->state;

  2227.     if (state == sw_chunk_data && ctx->size == 0) {
  2228.         state = sw_after_data;
  2229.     }

  2231.     rc = NGX_AGAIN;

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

  2235.         ch = *pos;

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

  2240.         switch (state) {

  2242.         case sw_chunk_start:
  2243.             if (ch >= '0' && ch <= '9') {
  2244.                 state = sw_chunk_size;
  2245.                 ctx->size = ch - '0';
  2246.                 break;
  2247.             }

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

  2251.             if (c >= 'a' && c <= 'f') {
  2252.                 state = sw_chunk_size;
  2253.                 ctx->size = c - 'a' + 10;
  2254.                 break;
  2255.             }

  2257.             goto invalid;

  2259.         case sw_chunk_size:
  2260.             if (ctx->size > NGX_MAX_OFF_T_VALUE / 16) {
  2261.                 goto invalid;
  2262.             }

  2264.             if (ch >= '0' && ch <= '9') {
  2265.                 ctx->size = ctx->size * 16 + (ch - '0');
  2266.                 break;
  2267.             }

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

  2271.             if (c >= 'a' && c <= 'f') {
  2272.                 ctx->size = ctx->size * 16 + (c - 'a' + 10);
  2273.                 break;
  2274.             }

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

  2278.                 switch (ch) {
  2279.                 case CR:
  2280.                     state = sw_last_chunk_extension_almost_done;
  2281.                     break;
  2282.                 case ';':
  2283.                 case ' ':
  2284.                 case '\t':
  2285.                     state = sw_last_chunk_extension;
  2286.                     break;
  2287.                 default:
  2288.                     goto invalid;
  2289.                 }

  2291.                 break;
  2292.             }

  2294.             switch (ch) {
  2295.             case CR:
  2296.                 state = sw_chunk_extension_almost_done;
  2297.                 break;
  2298.             case ';':
  2299.             case ' ':
  2300.             case '\t':
  2301.                 state = sw_chunk_extension;
  2302.                 break;
  2303.             default:
  2304.                 goto invalid;
  2305.             }

  2307.             break;

  2309.         case sw_chunk_extension:
  2310.             switch (ch) {
  2311.             case CR:
  2312.                 state = sw_chunk_extension_almost_done;
  2313.                 break;
  2314.             case LF:
  2315.                 goto invalid;
  2316.             }
  2317.             break;

  2319.         case sw_chunk_extension_almost_done:
  2320.             if (ch == LF) {
  2321.                 state = sw_chunk_data;
  2322.                 break;
  2323.             }
  2324.             goto invalid;

  2326.         case sw_chunk_data:
  2327.             rc = NGX_OK;
  2328.             goto data;

  2330.         case sw_after_data:
  2331.             switch (ch) {
  2332.             case CR:
  2333.                 state = sw_after_data_almost_done;
  2334.                 break;
  2335.             default:
  2336.                 goto invalid;
  2337.             }
  2338.             break;

  2340.         case sw_after_data_almost_done:
  2341.             if (ch == LF) {
  2342.                 state = sw_chunk_start;
  2343.                 break;
  2344.             }
  2345.             goto invalid;

  2347.         case sw_last_chunk_extension:
  2348.             switch (ch) {
  2349.             case CR:
  2350.                 state = sw_last_chunk_extension_almost_done;
  2351.                 break;
  2352.             case LF:
  2353.                 goto invalid;
  2354.             }
  2355.             break;

  2357.         case sw_last_chunk_extension_almost_done:
  2358.             if (ch == LF) {
  2359.                 if (keep_trailers) {
  2360.                     goto done;
  2361.                 }
  2362.                 state = sw_trailer;
  2363.                 break;
  2364.             }
  2365.             goto invalid;

  2367.         case sw_trailer:
  2368.             switch (ch) {
  2369.             case CR:
  2370.                 state = sw_trailer_almost_done;
  2371.                 break;
  2372.             case LF:
  2373.                 goto invalid;
  2374.             default:
  2375.                 state = sw_trailer_header;
  2376.             }
  2377.             break;

  2379.         case sw_trailer_almost_done:
  2380.             if (ch == LF) {
  2381.                 goto done;
  2382.             }
  2383.             goto invalid;

  2385.         case sw_trailer_header:
  2386.             switch (ch) {
  2387.             case CR:
  2388.                 state = sw_trailer_header_almost_done;
  2389.                 break;
  2390.             case LF:
  2391.                 goto invalid;
  2392.             }
  2393.             break;

  2395.         case sw_trailer_header_almost_done:
  2396.             if (ch == LF) {
  2397.                 state = sw_trailer;
  2398.                 break;
  2399.             }
  2400.             goto invalid;

  2402.         }
  2403.     }

  2405. data:

  2407.     ctx->state = state;
  2408.     b->pos = pos;

  2410.     if (ctx->size > NGX_MAX_OFF_T_VALUE - 9) {
  2411.         goto invalid;
  2412.     }

  2414.     switch (state) {

  2416.     case sw_chunk_start:
  2417.         ctx->length = 5 /* "0" CRLF CRLF */;
  2418.         break;
  2419.     case sw_chunk_size:
  2420.         ctx->length = 2 /* CRLF */
  2421.                       + (ctx->size ? ctx->size + 7 /* CRLF "0" CRLF CRLF */
  2422.                                    : 2 /* CRLF */);
  2423.         break;
  2424.     case sw_chunk_extension:
  2425.         ctx->length = 2 /* CRLF */ + ctx->size + 7 /* CRLF "0" CRLF CRLF */;
  2426.         break;
  2427.     case sw_chunk_extension_almost_done:
  2428.         ctx->length = 1 /* LF */ + ctx->size + 7 /* CRLF "0" CRLF CRLF */;
  2429.         break;
  2430.     case sw_chunk_data:
  2431.         ctx->length = ctx->size + 7 /* CRLF "0" CRLF CRLF */;
  2432.         break;
  2433.     case sw_after_data:
  2434.         ctx->length = 7 /* CRLF "0" CRLF CRLF */;
  2435.         break;
  2436.     case sw_after_data_almost_done:
  2437.         ctx->length = 6 /* LF "0" CRLF CRLF */;
  2438.         break;
  2439.     case sw_last_chunk_extension:
  2440.         ctx->length = 4 /* CRLF CRLF */;
  2441.         break;
  2442.     case sw_last_chunk_extension_almost_done:
  2443.         ctx->length = 3 /* LF CRLF */;
  2444.         break;
  2445.     case sw_trailer:
  2446.         ctx->length = 2 /* CRLF */;
  2447.         break;
  2448.     case sw_trailer_almost_done:
  2449.         ctx->length = 1 /* LF */;
  2450.         break;
  2451.     case sw_trailer_header:
  2452.         ctx->length = 4 /* CRLF CRLF */;
  2453.         break;
  2454.     case sw_trailer_header_almost_done:
  2455.         ctx->length = 3 /* LF CRLF */;
  2456.         break;

  2458.     }

  2460.     return rc;

  2462. done:

  2464.     ctx->state = 0;
  2465.     b->pos = pos + 1;

  2467.     return NGX_DONE;

  2469. invalid:

  2471.     return NGX_ERROR;
  2472. }

One Level Up Top Level