One Level Up Top Level

src/http/ngx_http_parse.c - nginx-1.7.10

Global variables 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 uint32_t  usual[] = {
  14.     0xffffdbfe, /* 1111 1111 1111 1111  1101 1011 1111 1110 */

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

  19.                 /* _^]\ [ZYX WVUT SRQP  ONML KJIH GFED CBA@ */
  20. #if (NGX_WIN32)
  21.     0xefffffff, /* 1110 1111 1111 1111  1111 1111 1111 1111 */
  22. #else
  23.     0xffffffff, /* 1111 1111 1111 1111  1111 1111 1111 1111 */
  24. #endif

  26.                 /*  ~}| {zyx wvut srqp  onml kjih gfed cba` */
  27.     0xffffffff, /* 1111 1111 1111 1111  1111 1111 1111 1111 */

  29.     0xffffffff, /* 1111 1111 1111 1111  1111 1111 1111 1111 */
  30.     0xffffffff, /* 1111 1111 1111 1111  1111 1111 1111 1111 */
  31.     0xffffffff, /* 1111 1111 1111 1111  1111 1111 1111 1111 */
  32.     0xffffffff  /* 1111 1111 1111 1111  1111 1111 1111 1111 */
  33. };


  36. #if (NGX_HAVE_LITTLE_ENDIAN && NGX_HAVE_NONALIGNED)

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

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

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

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

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

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

  59. ‌#define ngx_str8cmp(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_str9cmp(m, c0, c1, c2, c3, c4, c5, c6, c7, c8)                    \
  64.     *(uint32_t *) m == ((c3 << 24) | (c2 << 16) | (c1 << 8) | c0)             \
  65.         && ((uint32_t *) m)[1] == ((c7 << 24) | (c6 << 16) | (c5 << 8) | c4)  \
  66.         && m[8] == c8

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

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

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

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

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

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

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

  90. ‌#define ngx_str8cmp(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 && m[7] == c7

  94. ‌#define ngx_str9cmp(m, c0, c1, c2, c3, c4, c5, c6, c7, c8)                    \
  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 && m[8] == c8

  98. #endif


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

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

  137.     state = r->state;

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

  142.         switch (state) {

  144.         /* HTTP methods: GET, HEAD, POST */
  145.         case sw_start:
  146.             r->request_start = p;

  148.             if (ch == CR || ch == LF) {
  149.                 break;
  150.             }

  152.             if ((ch < 'A' || ch > 'Z') && ch != '_') {
  153.                 return NGX_HTTP_PARSE_INVALID_METHOD;
  154.             }

  156.             state = sw_method;
  157.             break;

  159.         case sw_method:
  160.             if (ch == ' ') {
  161.                 r->method_end = p - 1;
  162.                 m = r->request_start;

  164.                 switch (p - m) {

  166.                 case 3:
  167.                     if (ngx_str3_cmp(m, 'G', 'E', 'T', ' ')) {
  168.                         r->method = NGX_HTTP_GET;
  169.                         break;
  170.                     }

  172.                     if (ngx_str3_cmp(m, 'P', 'U', 'T', ' ')) {
  173.                         r->method = NGX_HTTP_PUT;
  174.                         break;
  175.                     }

  177.                     break;

  179.                 case 4:
  180.                     if (m[1] == 'O') {

  182.                         if (ngx_str3Ocmp(m, 'P', 'O', 'S', 'T')) {
  183.                             r->method = NGX_HTTP_POST;
  184.                             break;
  185.                         }

  187.                         if (ngx_str3Ocmp(m, 'C', 'O', 'P', 'Y')) {
  188.                             r->method = NGX_HTTP_COPY;
  189.                             break;
  190.                         }

  192.                         if (ngx_str3Ocmp(m, 'M', 'O', 'V', 'E')) {
  193.                             r->method = NGX_HTTP_MOVE;
  194.                             break;
  195.                         }

  197.                         if (ngx_str3Ocmp(m, 'L', 'O', 'C', 'K')) {
  198.                             r->method = NGX_HTTP_LOCK;
  199.                             break;
  200.                         }

  202.                     } else {

  204.                         if (ngx_str4cmp(m, 'H', 'E', 'A', 'D')) {
  205.                             r->method = NGX_HTTP_HEAD;
  206.                             break;
  207.                         }
  208.                     }

  210.                     break;

  212.                 case 5:
  213.                     if (ngx_str5cmp(m, 'M', 'K', 'C', 'O', 'L')) {
  214.                         r->method = NGX_HTTP_MKCOL;
  215.                         break;
  216.                     }

  218.                     if (ngx_str5cmp(m, 'P', 'A', 'T', 'C', 'H')) {
  219.                         r->method = NGX_HTTP_PATCH;
  220.                         break;
  221.                     }

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

  228.                     break;

  230.                 case 6:
  231.                     if (ngx_str6cmp(m, 'D', 'E', 'L', 'E', 'T', 'E')) {
  232.                         r->method = NGX_HTTP_DELETE;
  233.                         break;
  234.                     }

  236.                     if (ngx_str6cmp(m, 'U', 'N', 'L', 'O', 'C', 'K')) {
  237.                         r->method = NGX_HTTP_UNLOCK;
  238.                         break;
  239.                     }

  241.                     break;

  243.                 case 7:
  244.                     if (ngx_str7_cmp(m, 'O', 'P', 'T', 'I', 'O', 'N', 'S', ' '))
  245.                     {
  246.                         r->method = NGX_HTTP_OPTIONS;
  247.                     }

  249.                     break;

  251.                 case 8:
  252.                     if (ngx_str8cmp(m, 'P', 'R', 'O', 'P', 'F', 'I', 'N', 'D'))
  253.                     {
  254.                         r->method = NGX_HTTP_PROPFIND;
  255.                     }

  257.                     break;

  259.                 case 9:
  260.                     if (ngx_str9cmp(m,
  261.                             'P', 'R', 'O', 'P', 'P', 'A', 'T', 'C', 'H'))
  262.                     {
  263.                         r->method = NGX_HTTP_PROPPATCH;
  264.                     }

  266.                     break;
  267.                 }

  269.                 state = sw_spaces_before_uri;
  270.                 break;
  271.             }

  273.             if ((ch < 'A' || ch > 'Z') && ch != '_') {
  274.                 return NGX_HTTP_PARSE_INVALID_METHOD;
  275.             }

  277.             break;

  279.         /* space* before URI */
  280.         case sw_spaces_before_uri:

  282.             if (ch == '/') {
  283.                 r->uri_start = p;
  284.                 state = sw_after_slash_in_uri;
  285.                 break;
  286.             }

  288.             c = (u_char) (ch | 0x20);
  289.             if (c >= 'a' && c <= 'z') {
  290.                 r->schema_start = p;
  291.                 state = sw_schema;
  292.                 break;
  293.             }

  295.             switch (ch) {
  296.             case ' ':
  297.                 break;
  298.             default:
  299.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  300.             }
  301.             break;

  303.         case sw_schema:

  305.             c = (u_char) (ch | 0x20);
  306.             if (c >= 'a' && c <= 'z') {
  307.                 break;
  308.             }

  310.             switch (ch) {
  311.             case ':':
  312.                 r->schema_end = p;
  313.                 state = sw_schema_slash;
  314.                 break;
  315.             default:
  316.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  317.             }
  318.             break;

  320.         case sw_schema_slash:
  321.             switch (ch) {
  322.             case '/':
  323.                 state = sw_schema_slash_slash;
  324.                 break;
  325.             default:
  326.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  327.             }
  328.             break;

  330.         case sw_schema_slash_slash:
  331.             switch (ch) {
  332.             case '/':
  333.                 state = sw_host_start;
  334.                 break;
  335.             default:
  336.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  337.             }
  338.             break;

  340.         case sw_host_start:

  342.             r->host_start = p;

  344.             if (ch == '[') {
  345.                 state = sw_host_ip_literal;
  346.                 break;
  347.             }

  349.             state = sw_host;

  351.             /* fall through */

  353.         case sw_host:

  355.             c = (u_char) (ch | 0x20);
  356.             if (c >= 'a' && c <= 'z') {
  357.                 break;
  358.             }

  360.             if ((ch >= '0' && ch <= '9') || ch == '.' || ch == '-') {
  361.                 break;
  362.             }

  364.             /* fall through */

  366.         case sw_host_end:

  368.             r->host_end = p;

  370.             switch (ch) {
  371.             case ':':
  372.                 state = sw_port;
  373.                 break;
  374.             case '/':
  375.                 r->uri_start = p;
  376.                 state = sw_after_slash_in_uri;
  377.                 break;
  378.             case ' ':
  379.                 /*
  380.                  * use single "/" from request line to preserve pointers,
  381.                  * if request line will be copied to large client buffer
  382.                  */
  383.                 r->uri_start = r->schema_end + 1;
  384.                 r->uri_end = r->schema_end + 2;
  385.                 state = sw_host_http_09;
  386.                 break;
  387.             default:
  388.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  389.             }
  390.             break;

  392.         case sw_host_ip_literal:

  394.             if (ch >= '0' && ch <= '9') {
  395.                 break;
  396.             }

  398.             c = (u_char) (ch | 0x20);
  399.             if (c >= 'a' && c <= 'z') {
  400.                 break;
  401.             }

  403.             switch (ch) {
  404.             case ':':
  405.                 break;
  406.             case ']':
  407.                 state = sw_host_end;
  408.                 break;
  409.             case '-':
  410.             case '.':
  411.             case '_':
  412.             case '~':
  413.                 /* unreserved */
  414.                 break;
  415.             case '!':
  416.             case '$':
  417.             case '&':
  418.             case '\'':
  419.             case '(':
  420.             case ')':
  421.             case '*':
  422.             case '+':
  423.             case ',':
  424.             case ';':
  425.             case '=':
  426.                 /* sub-delims */
  427.                 break;
  428.             default:
  429.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  430.             }
  431.             break;

  433.         case sw_port:
  434.             if (ch >= '0' && ch <= '9') {
  435.                 break;
  436.             }

  438.             switch (ch) {
  439.             case '/':
  440.                 r->port_end = p;
  441.                 r->uri_start = p;
  442.                 state = sw_after_slash_in_uri;
  443.                 break;
  444.             case ' ':
  445.                 r->port_end = p;
  446.                 /*
  447.                  * use single "/" from request line to preserve pointers,
  448.                  * if request line will be copied to large client buffer
  449.                  */
  450.                 r->uri_start = r->schema_end + 1;
  451.                 r->uri_end = r->schema_end + 2;
  452.                 state = sw_host_http_09;
  453.                 break;
  454.             default:
  455.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  456.             }
  457.             break;

  459.         /* space+ after "http://host[:port] " */
  460.         case sw_host_http_09:
  461.             switch (ch) {
  462.             case ' ':
  463.                 break;
  464.             case CR:
  465.                 r->http_minor = 9;
  466.                 state = sw_almost_done;
  467.                 break;
  468.             case LF:
  469.                 r->http_minor = 9;
  470.                 goto done;
  471.             case 'H':
  472.                 r->http_protocol.data = p;
  473.                 state = sw_http_H;
  474.                 break;
  475.             default:
  476.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  477.             }
  478.             break;


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

  484.             if (usual[ch >> 5] & (1 << (ch & 0x1f))) {
  485.                 state = sw_check_uri;
  486.                 break;
  487.             }

  489.             switch (ch) {
  490.             case ' ':
  491.                 r->uri_end = p;
  492.                 state = sw_check_uri_http_09;
  493.                 break;
  494.             case CR:
  495.                 r->uri_end = p;
  496.                 r->http_minor = 9;
  497.                 state = sw_almost_done;
  498.                 break;
  499.             case LF:
  500.                 r->uri_end = p;
  501.                 r->http_minor = 9;
  502.                 goto done;
  503.             case '.':
  504.                 r->complex_uri = 1;
  505.                 state = sw_uri;
  506.                 break;
  507.             case '%':
  508.                 r->quoted_uri = 1;
  509.                 state = sw_uri;
  510.                 break;
  511.             case '/':
  512.                 r->complex_uri = 1;
  513.                 state = sw_uri;
  514.                 break;
  515. #if (NGX_WIN32)
  516.             case '\\':
  517.                 r->complex_uri = 1;
  518.                 state = sw_uri;
  519.                 break;
  520. #endif
  521.             case '?':
  522.                 r->args_start = p + 1;
  523.                 state = sw_uri;
  524.                 break;
  525.             case '#':
  526.                 r->complex_uri = 1;
  527.                 state = sw_uri;
  528.                 break;
  529.             case '+':
  530.                 r->plus_in_uri = 1;
  531.                 break;
  532.             case '\0':
  533.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  534.             default:
  535.                 state = sw_check_uri;
  536.                 break;
  537.             }
  538.             break;

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

  543.             if (usual[ch >> 5] & (1 << (ch & 0x1f))) {
  544.                 break;
  545.             }

  547.             switch (ch) {
  548.             case '/':
  549. #if (NGX_WIN32)
  550.                 if (r->uri_ext == p) {
  551.                     r->complex_uri = 1;
  552.                     state = sw_uri;
  553.                     break;
  554.                 }
  555. #endif
  556.                 r->uri_ext = NULL;
  557.                 state = sw_after_slash_in_uri;
  558.                 break;
  559.             case '.':
  560.                 r->uri_ext = p + 1;
  561.                 break;
  562.             case ' ':
  563.                 r->uri_end = p;
  564.                 state = sw_check_uri_http_09;
  565.                 break;
  566.             case CR:
  567.                 r->uri_end = p;
  568.                 r->http_minor = 9;
  569.                 state = sw_almost_done;
  570.                 break;
  571.             case LF:
  572.                 r->uri_end = p;
  573.                 r->http_minor = 9;
  574.                 goto done;
  575. #if (NGX_WIN32)
  576.             case '\\':
  577.                 r->complex_uri = 1;
  578.                 state = sw_after_slash_in_uri;
  579.                 break;
  580. #endif
  581.             case '%':
  582.                 r->quoted_uri = 1;
  583.                 state = sw_uri;
  584.                 break;
  585.             case '?':
  586.                 r->args_start = p + 1;
  587.                 state = sw_uri;
  588.                 break;
  589.             case '#':
  590.                 r->complex_uri = 1;
  591.                 state = sw_uri;
  592.                 break;
  593.             case '+':
  594.                 r->plus_in_uri = 1;
  595.                 break;
  596.             case '\0':
  597.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  598.             }
  599.             break;

  601.         /* space+ after URI */
  602.         case sw_check_uri_http_09:
  603.             switch (ch) {
  604.             case ' ':
  605.                 break;
  606.             case CR:
  607.                 r->http_minor = 9;
  608.                 state = sw_almost_done;
  609.                 break;
  610.             case LF:
  611.                 r->http_minor = 9;
  612.                 goto done;
  613.             case 'H':
  614.                 r->http_protocol.data = p;
  615.                 state = sw_http_H;
  616.                 break;
  617.             default:
  618.                 r->space_in_uri = 1;
  619.                 state = sw_check_uri;
  620.                 p--;
  621.                 break;
  622.             }
  623.             break;


  626.         /* URI */
  627.         case sw_uri:

  629.             if (usual[ch >> 5] & (1 << (ch & 0x1f))) {
  630.                 break;
  631.             }

  633.             switch (ch) {
  634.             case ' ':
  635.                 r->uri_end = p;
  636.                 state = sw_http_09;
  637.                 break;
  638.             case CR:
  639.                 r->uri_end = p;
  640.                 r->http_minor = 9;
  641.                 state = sw_almost_done;
  642.                 break;
  643.             case LF:
  644.                 r->uri_end = p;
  645.                 r->http_minor = 9;
  646.                 goto done;
  647.             case '#':
  648.                 r->complex_uri = 1;
  649.                 break;
  650.             case '\0':
  651.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  652.             }
  653.             break;

  655.         /* space+ after URI */
  656.         case sw_http_09:
  657.             switch (ch) {
  658.             case ' ':
  659.                 break;
  660.             case CR:
  661.                 r->http_minor = 9;
  662.                 state = sw_almost_done;
  663.                 break;
  664.             case LF:
  665.                 r->http_minor = 9;
  666.                 goto done;
  667.             case 'H':
  668.                 r->http_protocol.data = p;
  669.                 state = sw_http_H;
  670.                 break;
  671.             default:
  672.                 r->space_in_uri = 1;
  673.                 state = sw_uri;
  674.                 p--;
  675.                 break;
  676.             }
  677.             break;

  679.         case sw_http_H:
  680.             switch (ch) {
  681.             case 'T':
  682.                 state = sw_http_HT;
  683.                 break;
  684.             default:
  685.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  686.             }
  687.             break;

  689.         case sw_http_HT:
  690.             switch (ch) {
  691.             case 'T':
  692.                 state = sw_http_HTT;
  693.                 break;
  694.             default:
  695.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  696.             }
  697.             break;

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

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

  719.         /* first digit of major HTTP version */
  720.         case sw_first_major_digit:
  721.             if (ch < '1' || ch > '9') {
  722.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  723.             }

  725.             r->http_major = ch - '0';
  726.             state = sw_major_digit;
  727.             break;

  729.         /* major HTTP version or dot */
  730.         case sw_major_digit:
  731.             if (ch == '.') {
  732.                 state = sw_first_minor_digit;
  733.                 break;
  734.             }

  736.             if (ch < '0' || ch > '9') {
  737.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  738.             }

  740.             r->http_major = r->http_major * 10 + ch - '0';
  741.             break;

  743.         /* first digit of minor HTTP version */
  744.         case sw_first_minor_digit:
  745.             if (ch < '0' || ch > '9') {
  746.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  747.             }

  749.             r->http_minor = ch - '0';
  750.             state = sw_minor_digit;
  751.             break;

  753.         /* minor HTTP version or end of request line */
  754.         case sw_minor_digit:
  755.             if (ch == CR) {
  756.                 state = sw_almost_done;
  757.                 break;
  758.             }

  760.             if (ch == LF) {
  761.                 goto done;
  762.             }

  764.             if (ch == ' ') {
  765.                 state = sw_spaces_after_digit;
  766.                 break;
  767.             }

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

  773.             r->http_minor = r->http_minor * 10 + ch - '0';
  774.             break;

  776.         case sw_spaces_after_digit:
  777.             switch (ch) {
  778.             case ' ':
  779.                 break;
  780.             case CR:
  781.                 state = sw_almost_done;
  782.                 break;
  783.             case LF:
  784.                 goto done;
  785.             default:
  786.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  787.             }
  788.             break;

  790.         /* end of request line */
  791.         case sw_almost_done:
  792.             r->request_end = p - 1;
  793.             switch (ch) {
  794.             case LF:
  795.                 goto done;
  796.             default:
  797.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  798.             }
  799.         }
  800.     }

  802.     b->pos = p;
  803.     r->state = state;

  805.     return NGX_AGAIN;

  807. done:

  809.     b->pos = p + 1;

  811.     if (r->request_end == NULL) {
  812.         r->request_end = p;
  813.     }

  815.     r->http_version = r->http_major * 1000 + r->http_minor;
  816.     r->state = sw_start;

  818.     if (r->http_version == 9 && r->method != NGX_HTTP_GET) {
  819.         return NGX_HTTP_PARSE_INVALID_09_METHOD;
  820.     }

  822.     return NGX_OK;
  823. }


  826. ngx_int_t
  827. ‌ngx_http_parse_header_line(ngx_http_request_t *r, ngx_buf_t *b,
  828.     ngx_uint_t allow_underscores)
  829. {
  830.     u_char      c, ch, *p;
  831.     ngx_uint_t  hash, i;
  832.     enum {
  833.         sw_start = 0,
  834.         sw_name,
  835.         sw_space_before_value,
  836.         sw_value,
  837.         sw_space_after_value,
  838.         sw_ignore_line,
  839.         sw_almost_done,
  840.         sw_header_almost_done
  841.     } state;

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

  845.     static u_char  lowcase[] =
  846.         "\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"
  847.         "\0\0\0\0\0\0\0\0\0\0\0\0\0-\0\0" "0123456789\0\0\0\0\0\0"
  848.         "\0abcdefghijklmnopqrstuvwxyz\0\0\0\0\0"
  849.         "\0abcdefghijklmnopqrstuvwxyz\0\0\0\0\0"
  850.         "\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"
  851.         "\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"
  852.         "\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"
  853.         "\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";

  855.     state = r->state;
  856.     hash = r->header_hash;
  857.     i = r->lowcase_index;

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

  862.         switch (state) {

  864.         /* first char */
  865.         case sw_start:
  866.             r->header_name_start = p;
  867.             r->invalid_header = 0;

  869.             switch (ch) {
  870.             case CR:
  871.                 r->header_end = p;
  872.                 state = sw_header_almost_done;
  873.                 break;
  874.             case LF:
  875.                 r->header_end = p;
  876.                 goto header_done;
  877.             default:
  878.                 state = sw_name;

  880.                 c = lowcase[ch];

  882.                 if (c) {
  883.                     hash = ngx_hash(0, c);
  884.                     r->lowcase_header[0] = c;
  885.                     i = 1;
  886.                     break;
  887.                 }

  889.                 if (ch == '_') {
  890.                     if (allow_underscores) {
  891.                         hash = ngx_hash(0, ch);
  892.                         r->lowcase_header[0] = ch;
  893.                         i = 1;

  895.                     } else {
  896.                         r->invalid_header = 1;
  897.                     }

  899.                     break;
  900.                 }

  902.                 if (ch == '\0') {
  903.                     return NGX_HTTP_PARSE_INVALID_HEADER;
  904.                 }

  906.                 r->invalid_header = 1;

  908.                 break;

  910.             }
  911.             break;

  913.         /* header name */
  914.         case sw_name:
  915.             c = lowcase[ch];

  917.             if (c) {
  918.                 hash = ngx_hash(hash, c);
  919.                 r->lowcase_header[i++] = c;
  920.                 i &= (NGX_HTTP_LC_HEADER_LEN - 1);
  921.                 break;
  922.             }

  924.             if (ch == '_') {
  925.                 if (allow_underscores) {
  926.                     hash = ngx_hash(hash, ch);
  927.                     r->lowcase_header[i++] = ch;
  928.                     i &= (NGX_HTTP_LC_HEADER_LEN - 1);

  930.                 } else {
  931.                     r->invalid_header = 1;
  932.                 }

  934.                 break;
  935.             }

  937.             if (ch == ':') {
  938.                 r->header_name_end = p;
  939.                 state = sw_space_before_value;
  940.                 break;
  941.             }

  943.             if (ch == CR) {
  944.                 r->header_name_end = p;
  945.                 r->header_start = p;
  946.                 r->header_end = p;
  947.                 state = sw_almost_done;
  948.                 break;
  949.             }

  951.             if (ch == LF) {
  952.                 r->header_name_end = p;
  953.                 r->header_start = p;
  954.                 r->header_end = p;
  955.                 goto done;
  956.             }

  958.             /* IIS may send the duplicate "HTTP/1.1 ..." lines */
  959.             if (ch == '/'
  960.                 && r->upstream
  961.                 && p - r->header_name_start == 4
  962.                 && ngx_strncmp(r->header_name_start, "HTTP", 4) == 0)
  963.             {
  964.                 state = sw_ignore_line;
  965.                 break;
  966.             }

  968.             if (ch == '\0') {
  969.                 return NGX_HTTP_PARSE_INVALID_HEADER;
  970.             }

  972.             r->invalid_header = 1;

  974.             break;

  976.         /* space* before header value */
  977.         case sw_space_before_value:
  978.             switch (ch) {
  979.             case ' ':
  980.                 break;
  981.             case CR:
  982.                 r->header_start = p;
  983.                 r->header_end = p;
  984.                 state = sw_almost_done;
  985.                 break;
  986.             case LF:
  987.                 r->header_start = p;
  988.                 r->header_end = p;
  989.                 goto done;
  990.             case '\0':
  991.                 return NGX_HTTP_PARSE_INVALID_HEADER;
  992.             default:
  993.                 r->header_start = p;
  994.                 state = sw_value;
  995.                 break;
  996.             }
  997.             break;

  999.         /* header value */
  1000.         case sw_value:
  1001.             switch (ch) {
  1002.             case ' ':
  1003.                 r->header_end = p;
  1004.                 state = sw_space_after_value;
  1005.                 break;
  1006.             case CR:
  1007.                 r->header_end = p;
  1008.                 state = sw_almost_done;
  1009.                 break;
  1010.             case LF:
  1011.                 r->header_end = p;
  1012.                 goto done;
  1013.             case '\0':
  1014.                 return NGX_HTTP_PARSE_INVALID_HEADER;
  1015.             }
  1016.             break;

  1018.         /* space* before end of header line */
  1019.         case sw_space_after_value:
  1020.             switch (ch) {
  1021.             case ' ':
  1022.                 break;
  1023.             case CR:
  1024.                 state = sw_almost_done;
  1025.                 break;
  1026.             case LF:
  1027.                 goto done;
  1028.             case '\0':
  1029.                 return NGX_HTTP_PARSE_INVALID_HEADER;
  1030.             default:
  1031.                 state = sw_value;
  1032.                 break;
  1033.             }
  1034.             break;

  1036.         /* ignore header line */
  1037.         case sw_ignore_line:
  1038.             switch (ch) {
  1039.             case LF:
  1040.                 state = sw_start;
  1041.                 break;
  1042.             default:
  1043.                 break;
  1044.             }
  1045.             break;

  1047.         /* end of header line */
  1048.         case sw_almost_done:
  1049.             switch (ch) {
  1050.             case LF:
  1051.                 goto done;
  1052.             case CR:
  1053.                 break;
  1054.             default:
  1055.                 return NGX_HTTP_PARSE_INVALID_HEADER;
  1056.             }
  1057.             break;

  1059.         /* end of header */
  1060.         case sw_header_almost_done:
  1061.             switch (ch) {
  1062.             case LF:
  1063.                 goto header_done;
  1064.             default:
  1065.                 return NGX_HTTP_PARSE_INVALID_HEADER;
  1066.             }
  1067.         }
  1068.     }

  1070.     b->pos = p;
  1071.     r->state = state;
  1072.     r->header_hash = hash;
  1073.     r->lowcase_index = i;

  1075.     return NGX_AGAIN;

  1077. done:

  1079.     b->pos = p + 1;
  1080.     r->state = sw_start;
  1081.     r->header_hash = hash;
  1082.     r->lowcase_index = i;

  1084.     return NGX_OK;

  1086. header_done:

  1088.     b->pos = p + 1;
  1089.     r->state = sw_start;

  1091.     return NGX_HTTP_PARSE_HEADER_DONE;
  1092. }


  1095. ngx_int_t
  1096. ‌ngx_http_parse_uri(ngx_http_request_t *r)
  1097. {
  1098.     u_char  *p, ch;
  1099.     enum {
  1100.         sw_start = 0,
  1101.         sw_after_slash_in_uri,
  1102.         sw_check_uri,
  1103.         sw_uri
  1104.     } state;

  1106.     state = sw_start;

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

  1110.         ch = *p;

  1112.         switch (state) {

  1114.         case sw_start:

  1116.             if (ch != '/') {
  1117.                 return NGX_ERROR;
  1118.             }

  1120.             state = sw_after_slash_in_uri;
  1121.             break;

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

  1126.             if (usual[ch >> 5] & (1 << (ch & 0x1f))) {
  1127.                 state = sw_check_uri;
  1128.                 break;
  1129.             }

  1131.             switch (ch) {
  1132.             case ' ':
  1133.                 r->space_in_uri = 1;
  1134.                 state = sw_check_uri;
  1135.                 break;
  1136.             case '.':
  1137.                 r->complex_uri = 1;
  1138.                 state = sw_uri;
  1139.                 break;
  1140.             case '%':
  1141.                 r->quoted_uri = 1;
  1142.                 state = sw_uri;
  1143.                 break;
  1144.             case '/':
  1145.                 r->complex_uri = 1;
  1146.                 state = sw_uri;
  1147.                 break;
  1148. #if (NGX_WIN32)
  1149.             case '\\':
  1150.                 r->complex_uri = 1;
  1151.                 state = sw_uri;
  1152.                 break;
  1153. #endif
  1154.             case '?':
  1155.                 r->args_start = p + 1;
  1156.                 state = sw_uri;
  1157.                 break;
  1158.             case '#':
  1159.                 r->complex_uri = 1;
  1160.                 state = sw_uri;
  1161.                 break;
  1162.             case '+':
  1163.                 r->plus_in_uri = 1;
  1164.                 break;
  1165.             default:
  1166.                 state = sw_check_uri;
  1167.                 break;
  1168.             }
  1169.             break;

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

  1174.             if (usual[ch >> 5] & (1 << (ch & 0x1f))) {
  1175.                 break;
  1176.             }

  1178.             switch (ch) {
  1179.             case '/':
  1180. #if (NGX_WIN32)
  1181.                 if (r->uri_ext == p) {
  1182.                     r->complex_uri = 1;
  1183.                     state = sw_uri;
  1184.                     break;
  1185.                 }
  1186. #endif
  1187.                 r->uri_ext = NULL;
  1188.                 state = sw_after_slash_in_uri;
  1189.                 break;
  1190.             case '.':
  1191.                 r->uri_ext = p + 1;
  1192.                 break;
  1193.             case ' ':
  1194.                 r->space_in_uri = 1;
  1195.                 break;
  1196. #if (NGX_WIN32)
  1197.             case '\\':
  1198.                 r->complex_uri = 1;
  1199.                 state = sw_after_slash_in_uri;
  1200.                 break;
  1201. #endif
  1202.             case '%':
  1203.                 r->quoted_uri = 1;
  1204.                 state = sw_uri;
  1205.                 break;
  1206.             case '?':
  1207.                 r->args_start = p + 1;
  1208.                 state = sw_uri;
  1209.                 break;
  1210.             case '#':
  1211.                 r->complex_uri = 1;
  1212.                 state = sw_uri;
  1213.                 break;
  1214.             case '+':
  1215.                 r->plus_in_uri = 1;
  1216.                 break;
  1217.             }
  1218.             break;

  1220.         /* URI */
  1221.         case sw_uri:

  1223.             if (usual[ch >> 5] & (1 << (ch & 0x1f))) {
  1224.                 break;
  1225.             }

  1227.             switch (ch) {
  1228.             case ' ':
  1229.                 r->space_in_uri = 1;
  1230.                 break;
  1231.             case '#':
  1232.                 r->complex_uri = 1;
  1233.                 break;
  1234.             }
  1235.             break;
  1236.         }
  1237.     }

  1239.     return NGX_OK;
  1240. }


  1243. ngx_int_t
  1244. ‌ngx_http_parse_complex_uri(ngx_http_request_t *r, ngx_uint_t merge_slashes)
  1245. {
  1246.     u_char  c, ch, decoded, *p, *u;
  1247.     enum {
  1248.         sw_usual = 0,
  1249.         sw_slash,
  1250.         sw_dot,
  1251.         sw_dot_dot,
  1252.         sw_quoted,
  1253.         sw_quoted_second
  1254.     } state, quoted_state;

  1256. #if (NGX_SUPPRESS_WARN)
  1257.     decoded = '\0';
  1258.     quoted_state = sw_usual;
  1259. #endif

  1261.     state = sw_usual;
  1262.     p = r->uri_start;
  1263.     u = r->uri.data;
  1264.     r->uri_ext = NULL;
  1265.     r->args_start = NULL;

  1267.     ch = *p++;

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

  1271.         /*
  1272.          * we use "ch = *p++" inside the cycle, but this operation is safe,
  1273.          * because after the URI there is always at least one character:
  1274.          * the line feed
  1275.          */

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

  1280.         switch (state) {

  1282.         case sw_usual:

  1284.             if (usual[ch >> 5] & (1 << (ch & 0x1f))) {
  1285.                 *u++ = ch;
  1286.                 ch = *p++;
  1287.                 break;
  1288.             }

  1290.             switch (ch) {
  1291. #if (NGX_WIN32)
  1292.             case '\\':
  1293.                 if (u - 2 >= r->uri.data
  1294.                     && *(u - 1) == '.' && *(u - 2) != '.')
  1295.                 {
  1296.                     u--;
  1297.                 }

  1299.                 r->uri_ext = NULL;

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

  1303.                     /*
  1304.                      * we omit the last "\" to cause redirect because
  1305.                      * the browsers do not treat "\" as "/" in relative URL path
  1306.                      */

  1308.                     break;
  1309.                 }

  1311.                 state = sw_slash;
  1312.                 *u++ = '/';
  1313.                 break;
  1314. #endif
  1315.             case '/':
  1316. #if (NGX_WIN32)
  1317.                 if (u - 2 >= r->uri.data
  1318.                     && *(u - 1) == '.' && *(u - 2) != '.')
  1319.                 {
  1320.                     u--;
  1321.                 }
  1322. #endif
  1323.                 r->uri_ext = NULL;
  1324.                 state = sw_slash;
  1325.                 *u++ = ch;
  1326.                 break;
  1327.             case '%':
  1328.                 quoted_state = state;
  1329.                 state = sw_quoted;
  1330.                 break;
  1331.             case '?':
  1332.                 r->args_start = p;
  1333.                 goto args;
  1334.             case '#':
  1335.                 goto done;
  1336.             case '.':
  1337.                 r->uri_ext = u + 1;
  1338.                 *u++ = ch;
  1339.                 break;
  1340.             case '+':
  1341.                 r->plus_in_uri = 1;
  1342.                 /* fall through */
  1343.             default:
  1344.                 *u++ = ch;
  1345.                 break;
  1346.             }

  1348.             ch = *p++;
  1349.             break;

  1351.         case sw_slash:

  1353.             if (usual[ch >> 5] & (1 << (ch & 0x1f))) {
  1354.                 state = sw_usual;
  1355.                 *u++ = ch;
  1356.                 ch = *p++;
  1357.                 break;
  1358.             }

  1360.             switch (ch) {
  1361. #if (NGX_WIN32)
  1362.             case '\\':
  1363.                 break;
  1364. #endif
  1365.             case '/':
  1366.                 if (!merge_slashes) {
  1367.                     *u++ = ch;
  1368.                 }
  1369.                 break;
  1370.             case '.':
  1371.                 state = sw_dot;
  1372.                 *u++ = ch;
  1373.                 break;
  1374.             case '%':
  1375.                 quoted_state = state;
  1376.                 state = sw_quoted;
  1377.                 break;
  1378.             case '?':
  1379.                 r->args_start = p;
  1380.                 goto args;
  1381.             case '#':
  1382.                 goto done;
  1383.             case '+':
  1384.                 r->plus_in_uri = 1;
  1385.             default:
  1386.                 state = sw_usual;
  1387.                 *u++ = ch;
  1388.                 break;
  1389.             }

  1391.             ch = *p++;
  1392.             break;

  1394.         case sw_dot:

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

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

  1432.             ch = *p++;
  1433.             break;

  1435.         case sw_dot_dot:

  1437.             if (usual[ch >> 5] & (1 << (ch & 0x1f))) {
  1438.                 state = sw_usual;
  1439.                 *u++ = ch;
  1440.                 ch = *p++;
  1441.                 break;
  1442.             }

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

  1479.             ch = *p++;
  1480.             break;

  1482.         case sw_quoted:
  1483.             r->quoted_uri = 1;

  1485.             if (ch >= '0' && ch <= '9') {
  1486.                 decoded = (u_char) (ch - '0');
  1487.                 state = sw_quoted_second;
  1488.                 ch = *p++;
  1489.                 break;
  1490.             }

  1492.             c = (u_char) (ch | 0x20);
  1493.             if (c >= 'a' && c <= 'f') {
  1494.                 decoded = (u_char) (c - 'a' + 10);
  1495.                 state = sw_quoted_second;
  1496.                 ch = *p++;
  1497.                 break;
  1498.             }

  1500.             return NGX_HTTP_PARSE_INVALID_REQUEST;

  1502.         case sw_quoted_second:
  1503.             if (ch >= '0' && ch <= '9') {
  1504.                 ch = (u_char) ((decoded << 4) + ch - '0');

  1506.                 if (ch == '%' || ch == '#') {
  1507.                     state = sw_usual;
  1508.                     *u++ = ch;
  1509.                     ch = *p++;
  1510.                     break;

  1512.                 } else if (ch == '\0') {
  1513.                     return NGX_HTTP_PARSE_INVALID_REQUEST;
  1514.                 }

  1516.                 state = quoted_state;
  1517.                 break;
  1518.             }

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

  1524.                 if (ch == '?') {
  1525.                     state = sw_usual;
  1526.                     *u++ = ch;
  1527.                     ch = *p++;
  1528.                     break;

  1530.                 } else if (ch == '+') {
  1531.                     r->plus_in_uri = 1;
  1532.                 }

  1534.                 state = quoted_state;
  1535.                 break;
  1536.             }

  1538.             return NGX_HTTP_PARSE_INVALID_REQUEST;
  1539.         }
  1540.     }

  1542. done:

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

  1546.     if (r->uri_ext) {
  1547.         r->exten.len = u - r->uri_ext;
  1548.         r->exten.data = r->uri_ext;
  1549.     }

  1551.     r->uri_ext = NULL;

  1553.     return NGX_OK;

  1555. args:

  1557.     while (p < r->uri_end) {
  1558.         if (*p++ != '#') {
  1559.             continue;
  1560.         }

  1562.         r->args.len = p - 1 - r->args_start;
  1563.         r->args.data = r->args_start;
  1564.         r->args_start = NULL;

  1566.         break;
  1567.     }

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

  1571.     if (r->uri_ext) {
  1572.         r->exten.len = u - r->uri_ext;
  1573.         r->exten.data = r->uri_ext;
  1574.     }

  1576.     r->uri_ext = NULL;

  1578.     return NGX_OK;
  1579. }


  1582. ngx_int_t
  1583. ‌ngx_http_parse_status_line(ngx_http_request_t *r, ngx_buf_t *b,
  1584.     ngx_http_status_t *status)
  1585. {
  1586.     u_char   ch;
  1587.     u_char  *p;
  1588.     enum {
  1589.         sw_start = 0,
  1590.         sw_H,
  1591.         sw_HT,
  1592.         sw_HTT,
  1593.         sw_HTTP,
  1594.         sw_first_major_digit,
  1595.         sw_major_digit,
  1596.         sw_first_minor_digit,
  1597.         sw_minor_digit,
  1598.         sw_status,
  1599.         sw_space_after_status,
  1600.         sw_status_text,
  1601.         sw_almost_done
  1602.     } state;

  1604.     state = r->state;

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

  1609.         switch (state) {

  1611.         /* "HTTP/" */
  1612.         case sw_start:
  1613.             switch (ch) {
  1614.             case 'H':
  1615.                 state = sw_H;
  1616.                 break;
  1617.             default:
  1618.                 return NGX_ERROR;
  1619.             }
  1620.             break;

  1622.         case sw_H:
  1623.             switch (ch) {
  1624.             case 'T':
  1625.                 state = sw_HT;
  1626.                 break;
  1627.             default:
  1628.                 return NGX_ERROR;
  1629.             }
  1630.             break;

  1632.         case sw_HT:
  1633.             switch (ch) {
  1634.             case 'T':
  1635.                 state = sw_HTT;
  1636.                 break;
  1637.             default:
  1638.                 return NGX_ERROR;
  1639.             }
  1640.             break;

  1642.         case sw_HTT:
  1643.             switch (ch) {
  1644.             case 'P':
  1645.                 state = sw_HTTP;
  1646.                 break;
  1647.             default:
  1648.                 return NGX_ERROR;
  1649.             }
  1650.             break;

  1652.         case sw_HTTP:
  1653.             switch (ch) {
  1654.             case '/':
  1655.                 state = sw_first_major_digit;
  1656.                 break;
  1657.             default:
  1658.                 return NGX_ERROR;
  1659.             }
  1660.             break;

  1662.         /* the first digit of major HTTP version */
  1663.         case sw_first_major_digit:
  1664.             if (ch < '1' || ch > '9') {
  1665.                 return NGX_ERROR;
  1666.             }

  1668.             r->http_major = ch - '0';
  1669.             state = sw_major_digit;
  1670.             break;

  1672.         /* the major HTTP version or dot */
  1673.         case sw_major_digit:
  1674.             if (ch == '.') {
  1675.                 state = sw_first_minor_digit;
  1676.                 break;
  1677.             }

  1679.             if (ch < '0' || ch > '9') {
  1680.                 return NGX_ERROR;
  1681.             }

  1683.             r->http_major = r->http_major * 10 + ch - '0';
  1684.             break;

  1686.         /* the first digit of minor HTTP version */
  1687.         case sw_first_minor_digit:
  1688.             if (ch < '0' || ch > '9') {
  1689.                 return NGX_ERROR;
  1690.             }

  1692.             r->http_minor = ch - '0';
  1693.             state = sw_minor_digit;
  1694.             break;

  1696.         /* the minor HTTP version or the end of the request line */
  1697.         case sw_minor_digit:
  1698.             if (ch == ' ') {
  1699.                 state = sw_status;
  1700.                 break;
  1701.             }

  1703.             if (ch < '0' || ch > '9') {
  1704.                 return NGX_ERROR;
  1705.             }

  1707.             r->http_minor = r->http_minor * 10 + ch - '0';
  1708.             break;

  1710.         /* HTTP status code */
  1711.         case sw_status:
  1712.             if (ch == ' ') {
  1713.                 break;
  1714.             }

  1716.             if (ch < '0' || ch > '9') {
  1717.                 return NGX_ERROR;
  1718.             }

  1720.             status->code = status->code * 10 + ch - '0';

  1722.             if (++status->count == 3) {
  1723.                 state = sw_space_after_status;
  1724.                 status->start = p - 2;
  1725.             }

  1727.             break;

  1729.         /* space or end of line */
  1730.         case sw_space_after_status:
  1731.             switch (ch) {
  1732.             case ' ':
  1733.                 state = sw_status_text;
  1734.                 break;
  1735.             case '.':                    /* IIS may send 403.1, 403.2, etc */
  1736.                 state = sw_status_text;
  1737.                 break;
  1738.             case CR:
  1739.                 state = sw_almost_done;
  1740.                 break;
  1741.             case LF:
  1742.                 goto done;
  1743.             default:
  1744.                 return NGX_ERROR;
  1745.             }
  1746.             break;

  1748.         /* any text until end of line */
  1749.         case sw_status_text:
  1750.             switch (ch) {
  1751.             case CR:
  1752.                 state = sw_almost_done;

  1754.                 break;
  1755.             case LF:
  1756.                 goto done;
  1757.             }
  1758.             break;

  1760.         /* end of status line */
  1761.         case sw_almost_done:
  1762.             status->end = p - 1;
  1763.             switch (ch) {
  1764.             case LF:
  1765.                 goto done;
  1766.             default:
  1767.                 return NGX_ERROR;
  1768.             }
  1769.         }
  1770.     }

  1772.     b->pos = p;
  1773.     r->state = state;

  1775.     return NGX_AGAIN;

  1777. done:

  1779.     b->pos = p + 1;

  1781.     if (status->end == NULL) {
  1782.         status->end = p;
  1783.     }

  1785.     status->http_version = r->http_major * 1000 + r->http_minor;
  1786.     r->state = sw_start;

  1788.     return NGX_OK;
  1789. }


  1792. ngx_int_t
  1793. ‌ngx_http_parse_unsafe_uri(ngx_http_request_t *r, ngx_str_t *uri,
  1794.     ngx_str_t *args, ngx_uint_t *flags)
  1795. {
  1796.     u_char      ch, *p, *src, *dst;
  1797.     size_t      len;
  1798.     ngx_uint_t  quoted;

  1800.     len = uri->len;
  1801.     p = uri->data;
  1802.     quoted = 0;

  1804.     if (len == 0 || p[0] == '?') {
  1805.         goto unsafe;
  1806.     }

  1808.     if (p[0] == '.' && len > 1 && p[1] == '.'
  1809.         && (len == 2 || ngx_path_separator(p[2])))
  1810.     {
  1811.         goto unsafe;
  1812.     }

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

  1816.         ch = *p++;

  1818.         if (ch == '%') {
  1819.             quoted = 1;
  1820.             continue;
  1821.         }

  1823.         if (usual[ch >> 5] & (1 << (ch & 0x1f))) {
  1824.             continue;
  1825.         }

  1827.         if (ch == '?') {
  1828.             args->len = len - 1;
  1829.             args->data = p;
  1830.             uri->len -= len;

  1832.             break;
  1833.         }

  1835.         if (ch == '\0') {
  1836.             goto unsafe;
  1837.         }

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

  1841.             /* detect "/../" and "/.." */

  1843.             if (p[0] == '.' && p[1] == '.'
  1844.                 && (len == 3 || ngx_path_separator(p[2])))
  1845.             {
  1846.                 goto unsafe;
  1847.             }
  1848.         }
  1849.     }

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

  1855.         src = uri->data;

  1857.         dst = ngx_pnalloc(r->pool, uri->len);
  1858.         if (dst == NULL) {
  1859.             return NGX_ERROR;
  1860.         }

  1862.         uri->data = dst;

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

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

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

  1871.         len = uri->len;
  1872.         p = uri->data;

  1874.         if (p[0] == '.' && len > 1 && p[1] == '.'
  1875.             && (len == 2 || ngx_path_separator(p[2])))
  1876.         {
  1877.             goto unsafe;
  1878.         }

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

  1882.             ch = *p++;

  1884.             if (ch == '\0') {
  1885.                 goto unsafe;
  1886.             }

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

  1890.                 /* detect "/../" and "/.." */

  1892.                 if (p[0] == '.' && p[1] == '.'
  1893.                     && (len == 3 || ngx_path_separator(p[2])))
  1894.                 {
  1895.                     goto unsafe;
  1896.                 }
  1897.             }
  1898.         }
  1899.     }

  1901.     return NGX_OK;

  1903. unsafe:

  1905.     if (*flags & NGX_HTTP_LOG_UNSAFE) {
  1906.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1907.                       "unsafe URI \"%V\" was detected", uri);
  1908.     }

  1910.     return NGX_ERROR;
  1911. }


  1914. ngx_int_t
  1915. ‌ngx_http_parse_multi_header_lines(ngx_array_t *headers, ngx_str_t *name,
  1916.     ngx_str_t *value)
  1917. {
  1918.     ngx_uint_t         i;
  1919.     u_char            *start, *last, *end, ch;
  1920.     ngx_table_elt_t  **h;

  1922.     h = headers->elts;

  1924.     for (i = 0; i < headers->nelts; i++) {

  1926.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, headers->pool->log, 0,
  1927.                        "parse header: \"%V: %V\"", &h[i]->key, &h[i]->value);

  1929.         if (name->len > h[i]->value.len) {
  1930.             continue;
  1931.         }

  1933.         start = h[i]->value.data;
  1934.         end = h[i]->value.data + h[i]->value.len;

  1936.         while (start < end) {

  1938.             if (ngx_strncasecmp(start, name->data, name->len) != 0) {
  1939.                 goto skip;
  1940.             }

  1942.             for (start += name->len; start < end && *start == ' '; start++) {
  1943.                 /* void */
  1944.             }

  1946.             if (value == NULL) {
  1947.                 if (start == end || *start == ',') {
  1948.                     return i;
  1949.                 }

  1951.                 goto skip;
  1952.             }

  1954.             if (start == end || *start++ != '=') {
  1955.                 /* the invalid header value */
  1956.                 goto skip;
  1957.             }

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

  1961.             for (last = start; last < end && *last != ';'; last++) {
  1962.                 /* void */
  1963.             }

  1965.             value->len = last - start;
  1966.             value->data = start;

  1968.             return i;

  1970.         skip:

  1972.             while (start < end) {
  1973.                 ch = *start++;
  1974.                 if (ch == ';' || ch == ',') {
  1975.                     break;
  1976.                 }
  1977.             }

  1979.             while (start < end && *start == ' ') { start++; }
  1980.         }
  1981.     }

  1983.     return NGX_DECLINED;
  1984. }


  1987. ngx_int_t
  1988. ‌ngx_http_parse_set_cookie_lines(ngx_array_t *headers, ngx_str_t *name,
  1989.     ngx_str_t *value)
  1990. {
  1991.     ngx_uint_t         i;
  1992.     u_char            *start, *last, *end;
  1993.     ngx_table_elt_t  **h;

  1995.     h = headers->elts;

  1997.     for (i = 0; i < headers->nelts; i++) {

  1999.         ngx_log_debug2(NGX_LOG_DEBUG_HTTP, headers->pool->log, 0,
  2000.                        "parse header: \"%V: %V\"", &h[i]->key, &h[i]->value);

  2002.         if (name->len >= h[i]->value.len) {
  2003.             continue;
  2004.         }

  2006.         start = h[i]->value.data;
  2007.         end = h[i]->value.data + h[i]->value.len;

  2009.         if (ngx_strncasecmp(start, name->data, name->len) != 0) {
  2010.             continue;
  2011.         }

  2013.         for (start += name->len; start < end && *start == ' '; start++) {
  2014.             /* void */
  2015.         }

  2017.         if (start == end || *start++ != '=') {
  2018.             /* the invalid header value */
  2019.             continue;
  2020.         }

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

  2024.         for (last = start; last < end && *last != ';'; last++) {
  2025.             /* void */
  2026.         }

  2028.         value->len = last - start;
  2029.         value->data = start;

  2031.         return i;
  2032.     }

  2034.     return NGX_DECLINED;
  2035. }


  2038. ngx_int_t
  2039. ‌ngx_http_arg(ngx_http_request_t *r, u_char *name, size_t len, ngx_str_t *value)
  2040. {
  2041.     u_char  *p, *last;

  2043.     if (r->args.len == 0) {
  2044.         return NGX_DECLINED;
  2045.     }

  2047.     p = r->args.data;
  2048.     last = p + r->args.len;

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

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

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

  2056.         if (p == NULL) {
  2057.             return NGX_DECLINED;
  2058.         }

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

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

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

  2066.             if (p == NULL) {
  2067.                 p = r->args.data + r->args.len;
  2068.             }

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

  2072.             return NGX_OK;
  2073.         }
  2074.     }

  2076.     return NGX_DECLINED;
  2077. }


  2080. void
  2081. ‌ngx_http_split_args(ngx_http_request_t *r, ngx_str_t *uri, ngx_str_t *args)
  2082. {
  2083.     u_char  *p, *last;

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

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

  2089.     if (p) {
  2090.         uri->len = p - uri->data;
  2091.         p++;
  2092.         args->len = last - p;
  2093.         args->data = p;

  2095.     } else {
  2096.         args->len = 0;
  2097.     }
  2098. }


  2101. ngx_int_t
  2102. ‌ngx_http_parse_chunked(ngx_http_request_t *r, ngx_buf_t *b,
  2103.     ngx_http_chunked_t *ctx)
  2104. {
  2105.     u_char     *pos, ch, c;
  2106.     ngx_int_t   rc;
  2107.     enum {
  2108.         sw_chunk_start = 0,
  2109.         sw_chunk_size,
  2110.         sw_chunk_extension,
  2111.         sw_chunk_extension_almost_done,
  2112.         sw_chunk_data,
  2113.         sw_after_data,
  2114.         sw_after_data_almost_done,
  2115.         sw_last_chunk_extension,
  2116.         sw_last_chunk_extension_almost_done,
  2117.         sw_trailer,
  2118.         sw_trailer_almost_done,
  2119.         sw_trailer_header,
  2120.         sw_trailer_header_almost_done
  2121.     } state;

  2123.     state = ctx->state;

  2125.     if (state == sw_chunk_data && ctx->size == 0) {
  2126.         state = sw_after_data;
  2127.     }

  2129.     rc = NGX_AGAIN;

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

  2133.         ch = *pos;

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

  2138.         switch (state) {

  2140.         case sw_chunk_start:
  2141.             if (ch >= '0' && ch <= '9') {
  2142.                 state = sw_chunk_size;
  2143.                 ctx->size = ch - '0';
  2144.                 break;
  2145.             }

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

  2149.             if (c >= 'a' && c <= 'f') {
  2150.                 state = sw_chunk_size;
  2151.                 ctx->size = c - 'a' + 10;
  2152.                 break;
  2153.             }

  2155.             goto invalid;

  2157.         case sw_chunk_size:
  2158.             if (ch >= '0' && ch <= '9') {
  2159.                 ctx->size = ctx->size * 16 + (ch - '0');
  2160.                 break;
  2161.             }

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

  2165.             if (c >= 'a' && c <= 'f') {
  2166.                 ctx->size = ctx->size * 16 + (c - 'a' + 10);
  2167.                 break;
  2168.             }

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

  2172.                 switch (ch) {
  2173.                 case CR:
  2174.                     state = sw_last_chunk_extension_almost_done;
  2175.                     break;
  2176.                 case LF:
  2177.                     state = sw_trailer;
  2178.                     break;
  2179.                 case ';':
  2180.                 case ' ':
  2181.                 case '\t':
  2182.                     state = sw_last_chunk_extension;
  2183.                     break;
  2184.                 default:
  2185.                     goto invalid;
  2186.                 }

  2188.                 break;
  2189.             }

  2191.             switch (ch) {
  2192.             case CR:
  2193.                 state = sw_chunk_extension_almost_done;
  2194.                 break;
  2195.             case LF:
  2196.                 state = sw_chunk_data;
  2197.                 break;
  2198.             case ';':
  2199.             case ' ':
  2200.             case '\t':
  2201.                 state = sw_chunk_extension;
  2202.                 break;
  2203.             default:
  2204.                 goto invalid;
  2205.             }

  2207.             break;

  2209.         case sw_chunk_extension:
  2210.             switch (ch) {
  2211.             case CR:
  2212.                 state = sw_chunk_extension_almost_done;
  2213.                 break;
  2214.             case LF:
  2215.                 state = sw_chunk_data;
  2216.             }
  2217.             break;

  2219.         case sw_chunk_extension_almost_done:
  2220.             if (ch == LF) {
  2221.                 state = sw_chunk_data;
  2222.                 break;
  2223.             }
  2224.             goto invalid;

  2226.         case sw_chunk_data:
  2227.             rc = NGX_OK;
  2228.             goto data;

  2230.         case sw_after_data:
  2231.             switch (ch) {
  2232.             case CR:
  2233.                 state = sw_after_data_almost_done;
  2234.                 break;
  2235.             case LF:
  2236.                 state = sw_chunk_start;
  2237.             }
  2238.             break;

  2240.         case sw_after_data_almost_done:
  2241.             if (ch == LF) {
  2242.                 state = sw_chunk_start;
  2243.                 break;
  2244.             }
  2245.             goto invalid;

  2247.         case sw_last_chunk_extension:
  2248.             switch (ch) {
  2249.             case CR:
  2250.                 state = sw_last_chunk_extension_almost_done;
  2251.                 break;
  2252.             case LF:
  2253.                 state = sw_trailer;
  2254.             }
  2255.             break;

  2257.         case sw_last_chunk_extension_almost_done:
  2258.             if (ch == LF) {
  2259.                 state = sw_trailer;
  2260.                 break;
  2261.             }
  2262.             goto invalid;

  2264.         case sw_trailer:
  2265.             switch (ch) {
  2266.             case CR:
  2267.                 state = sw_trailer_almost_done;
  2268.                 break;
  2269.             case LF:
  2270.                 goto done;
  2271.             default:
  2272.                 state = sw_trailer_header;
  2273.             }
  2274.             break;

  2276.         case sw_trailer_almost_done:
  2277.             if (ch == LF) {
  2278.                 goto done;
  2279.             }
  2280.             goto invalid;

  2282.         case sw_trailer_header:
  2283.             switch (ch) {
  2284.             case CR:
  2285.                 state = sw_trailer_header_almost_done;
  2286.                 break;
  2287.             case LF:
  2288.                 state = sw_trailer;
  2289.             }
  2290.             break;

  2292.         case sw_trailer_header_almost_done:
  2293.             if (ch == LF) {
  2294.                 state = sw_trailer;
  2295.                 break;
  2296.             }
  2297.             goto invalid;

  2299.         }
  2300.     }

  2302. data:

  2304.     ctx->state = state;
  2305.     b->pos = pos;

  2307.     switch (state) {

  2309.     case sw_chunk_start:
  2310.         ctx->length = 3 /* "0" LF LF */;
  2311.         break;
  2312.     case sw_chunk_size:
  2313.         ctx->length = 1 /* LF */
  2314.                       + (ctx->size ? ctx->size + 4 /* LF "0" LF LF */
  2315.                                    : 1 /* LF */);
  2316.         break;
  2317.     case sw_chunk_extension:
  2318.     case sw_chunk_extension_almost_done:
  2319.         ctx->length = 1 /* LF */ + ctx->size + 4 /* LF "0" LF LF */;
  2320.         break;
  2321.     case sw_chunk_data:
  2322.         ctx->length = ctx->size + 4 /* LF "0" LF LF */;
  2323.         break;
  2324.     case sw_after_data:
  2325.     case sw_after_data_almost_done:
  2326.         ctx->length = 4 /* LF "0" LF LF */;
  2327.         break;
  2328.     case sw_last_chunk_extension:
  2329.     case sw_last_chunk_extension_almost_done:
  2330.         ctx->length = 2 /* LF LF */;
  2331.         break;
  2332.     case sw_trailer:
  2333.     case sw_trailer_almost_done:
  2334.         ctx->length = 1 /* LF */;
  2335.         break;
  2336.     case sw_trailer_header:
  2337.     case sw_trailer_header_almost_done:
  2338.         ctx->length = 2 /* LF LF */;
  2339.         break;

  2341.     }

  2343.     if (ctx->size < 0 || ctx->length < 0) {
  2344.         goto invalid;
  2345.     }

  2347.     return rc;

  2349. done:

  2351.     ctx->state = 0;
  2352.     b->pos = pos + 1;

  2354.     return NGX_DONE;

  2356. invalid:

  2358.     return NGX_ERROR;
  2359. }

One Level Up Top Level