One Level Up Top Level

src/http/ngx_http_parse.c - nginx source code

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 uint32_t  usual[] = {
  14.     0x00000000, /* 0000 0000 0000 0000  0000 0000 0000 0000 */

  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.     0x7fffffff, /* 0111 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_after_slash_in_uri,
  120.         sw_check_uri,
  121.         sw_uri,
  122.         sw_http_09,
  123.         sw_http_H,
  124.         sw_http_HT,
  125.         sw_http_HTT,
  126.         sw_http_HTTP,
  127.         sw_first_major_digit,
  128.         sw_major_digit,
  129.         sw_first_minor_digit,
  130.         sw_minor_digit,
  131.         sw_spaces_after_digit,
  132.         sw_almost_done
  133.     } state;

  135.     state = r->state;

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

  140.         switch (state) {

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

  146.             if (ch == CR || ch == LF) {
  147.                 break;
  148.             }

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

  154.             state = sw_method;
  155.             break;

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

  162.                 switch (p - m) {

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

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

  175.                     break;

  177.                 case 4:
  178.                     if (m[1] == 'O') {

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

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

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

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

  200.                     } else {

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

  208.                     break;

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

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

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

  226.                     break;

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

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

  239.                     break;

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

  247.                     if (ngx_str7_cmp(m, 'C', 'O', 'N', 'N', 'E', 'C', 'T', ' '))
  248.                     {
  249.                         r->method = NGX_HTTP_CONNECT;
  250.                     }

  252.                     break;

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

  260.                     break;

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

  269.                     break;
  270.                 }

  272.                 state = sw_spaces_before_uri;
  273.                 break;
  274.             }

  276.             if ((ch < 'A' || ch > 'Z') && ch != '_' && ch != '-') {
  277.                 return NGX_HTTP_PARSE_INVALID_METHOD;
  278.             }

  280.             break;

  282.         /* space* before URI */
  283.         case sw_spaces_before_uri:

  285.             if (ch == '/') {
  286.                 r->uri_start = p;
  287.                 state = sw_after_slash_in_uri;
  288.                 break;
  289.             }

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

  298.             switch (ch) {
  299.             case ' ':
  300.                 break;
  301.             default:
  302.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  303.             }
  304.             break;

  306.         case sw_schema:

  308.             c = (u_char) (ch | 0x20);
  309.             if (c >= 'a' && c <= 'z') {
  310.                 break;
  311.             }

  313.             if ((ch >= '0' && ch <= '9') || ch == '+' || ch == '-' || ch == '.')
  314.             {
  315.                 break;
  316.             }

  318.             switch (ch) {
  319.             case ':':
  320.                 r->schema_end = p;
  321.                 state = sw_schema_slash;
  322.                 break;
  323.             default:
  324.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  325.             }
  326.             break;

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

  338.         case sw_schema_slash_slash:
  339.             switch (ch) {
  340.             case '/':
  341.                 state = sw_host_start;
  342.                 break;
  343.             default:
  344.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  345.             }
  346.             break;

  348.         case sw_host_start:

  350.             r->host_start = p;

  352.             if (ch == '[') {
  353.                 state = sw_host_ip_literal;
  354.                 break;
  355.             }

  357.             state = sw_host;

  359.             /* fall through */

  361.         case sw_host:

  363.             c = (u_char) (ch | 0x20);
  364.             if (c >= 'a' && c <= 'z') {
  365.                 break;
  366.             }

  368.             if ((ch >= '0' && ch <= '9') || ch == '.' || ch == '-') {
  369.                 break;
  370.             }

  372.             /* fall through */

  374.         case sw_host_end:

  376.             r->host_end = p;

  378.             switch (ch) {
  379.             case ':':
  380.                 state = sw_port;
  381.                 break;
  382.             case '/':
  383.                 r->uri_start = p;
  384.                 state = sw_after_slash_in_uri;
  385.                 break;
  386.             case '?':
  387.                 r->uri_start = p;
  388.                 r->args_start = p + 1;
  389.                 r->empty_path_in_uri = 1;
  390.                 state = sw_uri;
  391.                 break;
  392.             case ' ':
  393.                 /*
  394.                  * use single "/" from request line to preserve pointers,
  395.                  * if request line will be copied to large client buffer
  396.                  */
  397.                 r->uri_start = r->schema_end + 1;
  398.                 r->uri_end = r->schema_end + 2;
  399.                 state = sw_http_09;
  400.                 break;
  401.             default:
  402.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  403.             }
  404.             break;

  406.         case sw_host_ip_literal:

  408.             if (ch >= '0' && ch <= '9') {
  409.                 break;
  410.             }

  412.             c = (u_char) (ch | 0x20);
  413.             if (c >= 'a' && c <= 'z') {
  414.                 break;
  415.             }

  417.             switch (ch) {
  418.             case ':':
  419.                 break;
  420.             case ']':
  421.                 state = sw_host_end;
  422.                 break;
  423.             case '-':
  424.             case '.':
  425.             case '_':
  426.             case '~':
  427.                 /* unreserved */
  428.                 break;
  429.             case '!':
  430.             case '$':
  431.             case '&':
  432.             case '\'':
  433.             case '(':
  434.             case ')':
  435.             case '*':
  436.             case '+':
  437.             case ',':
  438.             case ';':
  439.             case '=':
  440.                 /* sub-delims */
  441.                 break;
  442.             default:
  443.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  444.             }
  445.             break;

  447.         case sw_port:
  448.             if (ch >= '0' && ch <= '9') {
  449.                 break;
  450.             }

  452.             switch (ch) {
  453.             case '/':
  454.                 r->uri_start = p;
  455.                 state = sw_after_slash_in_uri;
  456.                 break;
  457.             case '?':
  458.                 r->uri_start = p;
  459.                 r->args_start = p + 1;
  460.                 r->empty_path_in_uri = 1;
  461.                 state = sw_uri;
  462.                 break;
  463.             case ' ':
  464.                 /*
  465.                  * use single "/" from request line to preserve pointers,
  466.                  * if request line will be copied to large client buffer
  467.                  */
  468.                 r->uri_start = r->schema_end + 1;
  469.                 r->uri_end = r->schema_end + 2;
  470.                 state = sw_http_09;
  471.                 break;
  472.             default:
  473.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  474.             }
  475.             break;

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

  480.             if (usual[ch >> 5] & (1U << (ch & 0x1f))) {
  481.                 state = sw_check_uri;
  482.                 break;
  483.             }

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

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

  540.             if (usual[ch >> 5] & (1U << (ch & 0x1f))) {
  541.                 break;
  542.             }

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

  601.         /* URI */
  602.         case sw_uri:

  604.             if (usual[ch >> 5] & (1U << (ch & 0x1f))) {
  605.                 break;
  606.             }

  608.             switch (ch) {
  609.             case ' ':
  610.                 r->uri_end = p;
  611.                 state = sw_http_09;
  612.                 break;
  613.             case CR:
  614.                 r->uri_end = p;
  615.                 r->http_minor = 9;
  616.                 state = sw_almost_done;
  617.                 break;
  618.             case LF:
  619.                 r->uri_end = p;
  620.                 r->http_minor = 9;
  621.                 goto done;
  622.             case '#':
  623.                 r->complex_uri = 1;
  624.                 break;
  625.             default:
  626.                 if (ch < 0x20 || ch == 0x7f) {
  627.                     return NGX_HTTP_PARSE_INVALID_REQUEST;
  628.                 }
  629.                 break;
  630.             }
  631.             break;

  633.         /* space+ after URI */
  634.         case sw_http_09:
  635.             switch (ch) {
  636.             case ' ':
  637.                 break;
  638.             case CR:
  639.                 r->http_minor = 9;
  640.                 state = sw_almost_done;
  641.                 break;
  642.             case LF:
  643.                 r->http_minor = 9;
  644.                 goto done;
  645.             case 'H':
  646.                 r->http_protocol.data = p;
  647.                 state = sw_http_H;
  648.                 break;
  649.             default:
  650.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  651.             }
  652.             break;

  654.         case sw_http_H:
  655.             switch (ch) {
  656.             case 'T':
  657.                 state = sw_http_HT;
  658.                 break;
  659.             default:
  660.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  661.             }
  662.             break;

  664.         case sw_http_HT:
  665.             switch (ch) {
  666.             case 'T':
  667.                 state = sw_http_HTT;
  668.                 break;
  669.             default:
  670.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  671.             }
  672.             break;

  674.         case sw_http_HTT:
  675.             switch (ch) {
  676.             case 'P':
  677.                 state = sw_http_HTTP;
  678.                 break;
  679.             default:
  680.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  681.             }
  682.             break;

  684.         case sw_http_HTTP:
  685.             switch (ch) {
  686.             case '/':
  687.                 state = sw_first_major_digit;
  688.                 break;
  689.             default:
  690.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  691.             }
  692.             break;

  694.         /* first digit of major HTTP version */
  695.         case sw_first_major_digit:
  696.             if (ch < '1' || ch > '9') {
  697.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  698.             }

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

  702.             if (r->http_major > 1) {
  703.                 return NGX_HTTP_PARSE_INVALID_VERSION;
  704.             }

  706.             state = sw_major_digit;
  707.             break;

  709.         /* major HTTP version or dot */
  710.         case sw_major_digit:
  711.             if (ch == '.') {
  712.                 state = sw_first_minor_digit;
  713.                 break;
  714.             }

  716.             if (ch < '0' || ch > '9') {
  717.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  718.             }

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

  722.             if (r->http_major > 1) {
  723.                 return NGX_HTTP_PARSE_INVALID_VERSION;
  724.             }

  726.             break;

  728.         /* first digit of minor HTTP version */
  729.         case sw_first_minor_digit:
  730.             if (ch < '0' || ch > '9') {
  731.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  732.             }

  734.             r->http_minor = ch - '0';
  735.             state = sw_minor_digit;
  736.             break;

  738.         /* minor HTTP version or end of request line */
  739.         case sw_minor_digit:
  740.             if (ch == CR) {
  741.                 state = sw_almost_done;
  742.                 break;
  743.             }

  745.             if (ch == LF) {
  746.                 goto done;
  747.             }

  749.             if (ch == ' ') {
  750.                 state = sw_spaces_after_digit;
  751.                 break;
  752.             }

  754.             if (ch < '0' || ch > '9') {
  755.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  756.             }

  758.             if (r->http_minor > 99) {
  759.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  760.             }

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

  765.         case sw_spaces_after_digit:
  766.             switch (ch) {
  767.             case ' ':
  768.                 break;
  769.             case CR:
  770.                 state = sw_almost_done;
  771.                 break;
  772.             case LF:
  773.                 goto done;
  774.             default:
  775.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  776.             }
  777.             break;

  779.         /* end of request line */
  780.         case sw_almost_done:
  781.             r->request_end = p - 1;
  782.             switch (ch) {
  783.             case LF:
  784.                 goto done;
  785.             default:
  786.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  787.             }
  788.         }
  789.     }

  791.     b->pos = p;
  792.     r->state = state;

  794.     return NGX_AGAIN;

  796. done:

  798.     b->pos = p + 1;

  800.     if (r->request_end == NULL) {
  801.         r->request_end = p;
  802.     }

  804.     r->http_version = r->http_major * 1000 + r->http_minor;
  805.     r->state = sw_start;

  807.     if (r->http_version == 9 && r->method != NGX_HTTP_GET) {
  808.         return NGX_HTTP_PARSE_INVALID_09_METHOD;
  809.     }

  811.     return NGX_OK;
  812. }


  815. ngx_int_t
  816. ‌ngx_http_parse_header_line(ngx_http_request_t *r, ngx_buf_t *b,
  817.     ngx_uint_t allow_underscores)
  818. {
  819.     u_char      c, ch, *p;
  820.     ngx_uint_t  hash, i;
  821. ‌    enum {
  822.         sw_start = 0,
  823.         sw_name,
  824.         sw_space_before_value,
  825.         sw_value,
  826.         sw_space_after_value,
  827.         sw_ignore_line,
  828.         sw_almost_done,
  829.         sw_header_almost_done
  830.     } state;

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

  834.     static u_char  lowcase[] =
  835.         "\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"
  836.         "\0\0\0\0\0\0\0\0\0\0\0\0\0-\0\0" "0123456789\0\0\0\0\0\0"
  837.         "\0abcdefghijklmnopqrstuvwxyz\0\0\0\0\0"
  838.         "\0abcdefghijklmnopqrstuvwxyz\0\0\0\0\0"
  839.         "\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"
  840.         "\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"
  841.         "\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"
  842.         "\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";

  844.     state = r->state;
  845.     hash = r->header_hash;
  846.     i = r->lowcase_index;

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

  851.         switch (state) {

  853.         /* first char */
  854.         case sw_start:
  855.             r->header_name_start = p;
  856.             r->invalid_header = 0;

  858.             switch (ch) {
  859.             case CR:
  860.                 r->header_end = p;
  861.                 state = sw_header_almost_done;
  862.                 break;
  863.             case LF:
  864.                 r->header_end = p;
  865.                 goto header_done;
  866.             default:
  867.                 state = sw_name;

  869.                 c = lowcase[ch];

  871.                 if (c) {
  872.                     hash = ngx_hash(0, c);
  873.                     r->lowcase_header[0] = c;
  874.                     i = 1;
  875.                     break;
  876.                 }

  878.                 if (ch == '_') {
  879.                     if (allow_underscores) {
  880.                         hash = ngx_hash(0, ch);
  881.                         r->lowcase_header[0] = ch;
  882.                         i = 1;

  884.                     } else {
  885.                         hash = 0;
  886.                         i = 0;
  887.                         r->invalid_header = 1;
  888.                     }

  890.                     break;
  891.                 }

  893.                 if (ch <= 0x20 || ch == 0x7f || ch == ':') {
  894.                     r->header_end = p;
  895.                     return NGX_HTTP_PARSE_INVALID_HEADER;
  896.                 }

  898.                 hash = 0;
  899.                 i = 0;
  900.                 r->invalid_header = 1;

  902.                 break;

  904.             }
  905.             break;

  907.         /* header name */
  908.         case sw_name:
  909.             c = lowcase[ch];

  911.             if (c) {
  912.                 hash = ngx_hash(hash, c);
  913.                 r->lowcase_header[i++] = c;
  914.                 i &= (NGX_HTTP_LC_HEADER_LEN - 1);
  915.                 break;
  916.             }

  918.             if (ch == '_') {
  919.                 if (allow_underscores) {
  920.                     hash = ngx_hash(hash, ch);
  921.                     r->lowcase_header[i++] = ch;
  922.                     i &= (NGX_HTTP_LC_HEADER_LEN - 1);

  924.                 } else {
  925.                     r->invalid_header = 1;
  926.                 }

  928.                 break;
  929.             }

  931.             if (ch == ':') {
  932.                 r->header_name_end = p;
  933.                 state = sw_space_before_value;
  934.                 break;
  935.             }

  937.             if (ch == CR) {
  938.                 r->header_name_end = p;
  939.                 r->header_start = p;
  940.                 r->header_end = p;
  941.                 state = sw_almost_done;
  942.                 break;
  943.             }

  945.             if (ch == LF) {
  946.                 r->header_name_end = p;
  947.                 r->header_start = p;
  948.                 r->header_end = p;
  949.                 goto done;
  950.             }

  952.             /* IIS may send the duplicate "HTTP/1.1 ..." lines */
  953.             if (ch == '/'
  954.                 && r->upstream
  955.                 && p - r->header_name_start == 4
  956.                 && ngx_strncmp(r->header_name_start, "HTTP", 4) == 0)
  957.             {
  958.                 state = sw_ignore_line;
  959.                 break;
  960.             }

  962.             if (ch <= 0x20 || ch == 0x7f) {
  963.                 r->header_end = p;
  964.                 return NGX_HTTP_PARSE_INVALID_HEADER;
  965.             }

  967.             r->invalid_header = 1;

  969.             break;

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

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

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

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

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

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

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

  1073.     return NGX_AGAIN;

  1075. done:

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

  1082.     return NGX_OK;

  1084. header_done:

  1086.     b->pos = p + 1;
  1087.     r->state = sw_start;

  1089.     return NGX_HTTP_PARSE_HEADER_DONE;
  1090. }


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

  1104.     state = sw_start;

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

  1108.         ch = *p;

  1110.         switch (state) {

  1112.         case sw_start:

  1114.             if (ch != '/') {
  1115.                 return NGX_ERROR;
  1116.             }

  1118.             state = sw_after_slash_in_uri;
  1119.             break;

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

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

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

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

  1171.             if (usual[ch >> 5] & (1U << (ch & 0x1f))) {
  1172.                 break;
  1173.             }

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

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

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

  1226.             switch (ch) {
  1227.             case '#':
  1228.                 r->complex_uri = 1;
  1229.                 break;
  1230.             default:
  1231.                 if (ch <= 0x20 || ch == 0x7f) {
  1232.                     return NGX_ERROR;
  1233.                 }
  1234.                 break;
  1235.             }
  1236.             break;
  1237.         }
  1238.     }

  1240.     return NGX_OK;
  1241. }


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

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

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

  1268.     if (r->empty_path_in_uri) {
  1269.         *u++ = '/';
  1270.     }

  1272.     ch = *p++;

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

  1276.         /*
  1277.          * we use "ch = *p++" inside the cycle, but this operation is safe,
  1278.          * because after the URI there is always at least one character:
  1279.          * the line feed
  1280.          */

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

  1285.         switch (state) {

  1287.         case sw_usual:

  1289.             if (usual[ch >> 5] & (1U << (ch & 0x1f))) {
  1290.                 *u++ = ch;
  1291.                 ch = *p++;
  1292.                 break;
  1293.             }

  1295.             switch (ch) {
  1296. #if (NGX_WIN32)
  1297.             case '\\':
  1298.                 if (u - 2 >= r->uri.data
  1299.                     && *(u - 1) == '.' && *(u - 2) != '.')
  1300.                 {
  1301.                     u--;
  1302.                 }

  1304.                 r->uri_ext = NULL;

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

  1308.                     /*
  1309.                      * we omit the last "\" to cause redirect because
  1310.                      * the browsers do not treat "\" as "/" in relative URL path
  1311.                      */

  1313.                     break;
  1314.                 }

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

  1353.             ch = *p++;
  1354.             break;

  1356.         case sw_slash:

  1358.             if (usual[ch >> 5] & (1U << (ch & 0x1f))) {
  1359.                 state = sw_usual;
  1360.                 *u++ = ch;
  1361.                 ch = *p++;
  1362.                 break;
  1363.             }

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

  1397.             ch = *p++;
  1398.             break;

  1400.         case sw_dot:

  1402.             if (usual[ch >> 5] & (1U << (ch & 0x1f))) {
  1403.                 state = sw_usual;
  1404.                 *u++ = ch;
  1405.                 ch = *p++;
  1406.                 break;
  1407.             }

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

  1441.             ch = *p++;
  1442.             break;

  1444.         case sw_dot_dot:

  1446.             if (usual[ch >> 5] & (1U << (ch & 0x1f))) {
  1447.                 state = sw_usual;
  1448.                 *u++ = ch;
  1449.                 ch = *p++;
  1450.                 break;
  1451.             }

  1453.             switch (ch) {
  1454. #if (NGX_WIN32)
  1455.             case '\\':
  1456. #endif
  1457.             case '/':
  1458.             case '?':
  1459.             case '#':
  1460.                 u -= 4;
  1461.                 for ( ;; ) {
  1462.                     if (u < r->uri.data) {
  1463.                         return NGX_HTTP_PARSE_INVALID_REQUEST;
  1464.                     }
  1465.                     if (*u == '/') {
  1466.                         u++;
  1467.                         break;
  1468.                     }
  1469.                     u--;
  1470.                 }
  1471.                 if (ch == '?') {
  1472.                     r->args_start = p;
  1473.                     goto args;
  1474.                 }
  1475.                 if (ch == '#') {
  1476.                     goto done;
  1477.                 }
  1478.                 state = sw_slash;
  1479.                 break;
  1480.             case '%':
  1481.                 quoted_state = state;
  1482.                 state = sw_quoted;
  1483.                 break;
  1484.             case '+':
  1485.                 r->plus_in_uri = 1;
  1486.                 /* fall through */
  1487.             default:
  1488.                 state = sw_usual;
  1489.                 *u++ = ch;
  1490.                 break;
  1491.             }

  1493.             ch = *p++;
  1494.             break;

  1496.         case sw_quoted:
  1497.             r->quoted_uri = 1;

  1499.             if (ch >= '0' && ch <= '9') {
  1500.                 decoded = (u_char) (ch - '0');
  1501.                 state = sw_quoted_second;
  1502.                 ch = *p++;
  1503.                 break;
  1504.             }

  1506.             c = (u_char) (ch | 0x20);
  1507.             if (c >= 'a' && c <= 'f') {
  1508.                 decoded = (u_char) (c - 'a' + 10);
  1509.                 state = sw_quoted_second;
  1510.                 ch = *p++;
  1511.                 break;
  1512.             }

  1514.             return NGX_HTTP_PARSE_INVALID_REQUEST;

  1516.         case sw_quoted_second:
  1517.             if (ch >= '0' && ch <= '9') {
  1518.                 ch = (u_char) ((decoded << 4) + (ch - '0'));

  1520.                 if (ch == '%' || ch == '#') {
  1521.                     state = sw_usual;
  1522.                     *u++ = ch;
  1523.                     ch = *p++;
  1524.                     break;

  1526.                 } else if (ch == '\0') {
  1527.                     return NGX_HTTP_PARSE_INVALID_REQUEST;
  1528.                 }

  1530.                 state = quoted_state;
  1531.                 break;
  1532.             }

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

  1538.                 if (ch == '?') {
  1539.                     state = sw_usual;
  1540.                     *u++ = ch;
  1541.                     ch = *p++;
  1542.                     break;

  1544.                 } else if (ch == '+') {
  1545.                     r->plus_in_uri = 1;
  1546.                 }

  1548.                 state = quoted_state;
  1549.                 break;
  1550.             }

  1552.             return NGX_HTTP_PARSE_INVALID_REQUEST;
  1553.         }
  1554.     }

  1556.     if (state == sw_quoted || state == sw_quoted_second) {
  1557.         return NGX_HTTP_PARSE_INVALID_REQUEST;
  1558.     }

  1560.     if (state == sw_dot) {
  1561.         u--;

  1563.     } else if (state == sw_dot_dot) {
  1564.         u -= 4;

  1566.         for ( ;; ) {
  1567.             if (u < r->uri.data) {
  1568.                 return NGX_HTTP_PARSE_INVALID_REQUEST;
  1569.             }

  1571.             if (*u == '/') {
  1572.                 u++;
  1573.                 break;
  1574.             }

  1576.             u--;
  1577.         }
  1578.     }

  1580. done:

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

  1584.     if (r->uri_ext) {
  1585.         r->exten.len = u - r->uri_ext;
  1586.         r->exten.data = r->uri_ext;
  1587.     }

  1589.     r->uri_ext = NULL;

  1591.     return NGX_OK;

  1593. args:

  1595.     while (p < r->uri_end) {
  1596.         if (*p++ != '#') {
  1597.             continue;
  1598.         }

  1600.         r->args.len = p - 1 - r->args_start;
  1601.         r->args.data = r->args_start;
  1602.         r->args_start = NULL;

  1604.         break;
  1605.     }

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

  1609.     if (r->uri_ext) {
  1610.         r->exten.len = u - r->uri_ext;
  1611.         r->exten.data = r->uri_ext;
  1612.     }

  1614.     r->uri_ext = NULL;

  1616.     return NGX_OK;
  1617. }


  1620. ngx_int_t
  1621. ‌ngx_http_parse_status_line(ngx_http_request_t *r, ngx_buf_t *b,
  1622.     ngx_http_status_t *status)
  1623. {
  1624.     u_char   ch;
  1625.     u_char  *p;
  1626. ‌    enum {
  1627.         sw_start = 0,
  1628.         sw_H,
  1629.         sw_HT,
  1630.         sw_HTT,
  1631.         sw_HTTP,
  1632.         sw_first_major_digit,
  1633.         sw_major_digit,
  1634.         sw_first_minor_digit,
  1635.         sw_minor_digit,
  1636.         sw_status,
  1637.         sw_space_after_status,
  1638.         sw_status_text,
  1639.         sw_almost_done
  1640.     } state;

  1642.     state = r->state;

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

  1647.         switch (state) {

  1649.         /* "HTTP/" */
  1650.         case sw_start:
  1651.             switch (ch) {
  1652.             case 'H':
  1653.                 state = sw_H;
  1654.                 break;
  1655.             default:
  1656.                 return NGX_ERROR;
  1657.             }
  1658.             break;

  1660.         case sw_H:
  1661.             switch (ch) {
  1662.             case 'T':
  1663.                 state = sw_HT;
  1664.                 break;
  1665.             default:
  1666.                 return NGX_ERROR;
  1667.             }
  1668.             break;

  1670.         case sw_HT:
  1671.             switch (ch) {
  1672.             case 'T':
  1673.                 state = sw_HTT;
  1674.                 break;
  1675.             default:
  1676.                 return NGX_ERROR;
  1677.             }
  1678.             break;

  1680.         case sw_HTT:
  1681.             switch (ch) {
  1682.             case 'P':
  1683.                 state = sw_HTTP;
  1684.                 break;
  1685.             default:
  1686.                 return NGX_ERROR;
  1687.             }
  1688.             break;

  1690.         case sw_HTTP:
  1691.             switch (ch) {
  1692.             case '/':
  1693.                 state = sw_first_major_digit;
  1694.                 break;
  1695.             default:
  1696.                 return NGX_ERROR;
  1697.             }
  1698.             break;

  1700.         /* the first digit of major HTTP version */
  1701.         case sw_first_major_digit:
  1702.             if (ch < '1' || ch > '9') {
  1703.                 return NGX_ERROR;
  1704.             }

  1706.             r->http_major = ch - '0';
  1707.             state = sw_major_digit;
  1708.             break;

  1710.         /* the major HTTP version or dot */
  1711.         case sw_major_digit:
  1712.             if (ch == '.') {
  1713.                 state = sw_first_minor_digit;
  1714.                 break;
  1715.             }

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

  1721.             if (r->http_major > 99) {
  1722.                 return NGX_ERROR;
  1723.             }

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

  1728.         /* the first digit of minor HTTP version */
  1729.         case sw_first_minor_digit:
  1730.             if (ch < '0' || ch > '9') {
  1731.                 return NGX_ERROR;
  1732.             }

  1734.             r->http_minor = ch - '0';
  1735.             state = sw_minor_digit;
  1736.             break;

  1738.         /* the minor HTTP version or the end of the request line */
  1739.         case sw_minor_digit:
  1740.             if (ch == ' ') {
  1741.                 state = sw_status;
  1742.                 break;
  1743.             }

  1745.             if (ch < '0' || ch > '9') {
  1746.                 return NGX_ERROR;
  1747.             }

  1749.             if (r->http_minor > 99) {
  1750.                 return NGX_ERROR;
  1751.             }

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

  1756.         /* HTTP status code */
  1757.         case sw_status:
  1758.             if (ch == ' ') {
  1759.                 break;
  1760.             }

  1762.             if (ch < '0' || ch > '9') {
  1763.                 return NGX_ERROR;
  1764.             }

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

  1768.             if (++status->count == 3) {
  1769.                 state = sw_space_after_status;
  1770.                 status->start = p - 2;
  1771.             }

  1773.             break;

  1775.         /* space or end of line */
  1776.         case sw_space_after_status:
  1777.             switch (ch) {
  1778.             case ' ':
  1779.                 state = sw_status_text;
  1780.                 break;
  1781.             case '.':                    /* IIS may send 403.1, 403.2, etc */
  1782.                 state = sw_status_text;
  1783.                 break;
  1784.             case CR:
  1785.                 state = sw_almost_done;
  1786.                 break;
  1787.             case LF:
  1788.                 goto done;
  1789.             default:
  1790.                 return NGX_ERROR;
  1791.             }
  1792.             break;

  1794.         /* any text until end of line */
  1795.         case sw_status_text:
  1796.             switch (ch) {
  1797.             case CR:
  1798.                 state = sw_almost_done;

  1800.                 break;
  1801.             case LF:
  1802.                 goto done;
  1803.             }
  1804.             break;

  1806.         /* end of status line */
  1807.         case sw_almost_done:
  1808.             status->end = p - 1;
  1809.             switch (ch) {
  1810.             case LF:
  1811.                 goto done;
  1812.             default:
  1813.                 return NGX_ERROR;
  1814.             }
  1815.         }
  1816.     }

  1818.     b->pos = p;
  1819.     r->state = state;

  1821.     return NGX_AGAIN;

  1823. done:

  1825.     b->pos = p + 1;

  1827.     if (status->end == NULL) {
  1828.         status->end = p;
  1829.     }

  1831.     status->http_version = r->http_major * 1000 + r->http_minor;
  1832.     r->state = sw_start;

  1834.     return NGX_OK;
  1835. }


  1838. ngx_int_t
  1839. ‌ngx_http_parse_unsafe_uri(ngx_http_request_t *r, ngx_str_t *uri,
  1840.     ngx_str_t *args, ngx_uint_t *flags)
  1841. {
  1842.     u_char      ch, *p, *src, *dst;
  1843.     size_t      len;
  1844.     ngx_uint_t  quoted;

  1846.     len = uri->len;
  1847.     p = uri->data;
  1848.     quoted = 0;

  1850.     if (len == 0 || p[0] == '?') {
  1851.         goto unsafe;
  1852.     }

  1854.     if (p[0] == '.' && len > 1 && p[1] == '.'
  1855.         && (len == 2 || ngx_path_separator(p[2])))
  1856.     {
  1857.         goto unsafe;
  1858.     }

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

  1862.         ch = *p++;

  1864.         if (ch == '%') {
  1865.             quoted = 1;
  1866.             continue;
  1867.         }

  1869.         if (usual[ch >> 5] & (1U << (ch & 0x1f))) {
  1870.             continue;
  1871.         }

  1873.         if (ch == '?') {
  1874.             args->len = len - 1;
  1875.             args->data = p;
  1876.             uri->len -= len;

  1878.             break;
  1879.         }

  1881.         if (ch == '\0') {
  1882.             goto unsafe;
  1883.         }

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

  1887.             /* detect "/../" and "/.." */

  1889.             if (p[0] == '.' && p[1] == '.'
  1890.                 && (len == 3 || ngx_path_separator(p[2])))
  1891.             {
  1892.                 goto unsafe;
  1893.             }
  1894.         }
  1895.     }

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

  1901.         src = uri->data;

  1903.         dst = ngx_pnalloc(r->pool, uri->len);
  1904.         if (dst == NULL) {
  1905.             return NGX_ERROR;
  1906.         }

  1908.         uri->data = dst;

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

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

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

  1917.         len = uri->len;
  1918.         p = uri->data;

  1920.         if (p[0] == '.' && len > 1 && p[1] == '.'
  1921.             && (len == 2 || ngx_path_separator(p[2])))
  1922.         {
  1923.             goto unsafe;
  1924.         }

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

  1928.             ch = *p++;

  1930.             if (ch == '\0') {
  1931.                 goto unsafe;
  1932.             }

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

  1936.                 /* detect "/../" and "/.." */

  1938.                 if (p[0] == '.' && p[1] == '.'
  1939.                     && (len == 3 || ngx_path_separator(p[2])))
  1940.                 {
  1941.                     goto unsafe;
  1942.                 }
  1943.             }
  1944.         }
  1945.     }

  1947.     return NGX_OK;

  1949. unsafe:

  1951.     if (*flags & NGX_HTTP_LOG_UNSAFE) {
  1952.         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
  1953.                       "unsafe URI \"%V\" was detected", uri);
  1954.     }

  1956.     return NGX_ERROR;
  1957. }


  1960. ngx_table_elt_t *
  1961. ‌ngx_http_parse_multi_header_lines(ngx_http_request_t *r,
  1962.     ngx_table_elt_t *headers, ngx_str_t *name, ngx_str_t *value)
  1963. {
  1964.     u_char           *start, *last, *end, ch;
  1965.     ngx_table_elt_t  *h;

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

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

  1972.         if (name->len > h->value.len) {
  1973.             continue;
  1974.         }

  1976.         start = h->value.data;
  1977.         end = h->value.data + h->value.len;

  1979.         while (start < end) {

  1981.             if (ngx_strncasecmp(start, name->data, name->len) != 0) {
  1982.                 goto skip;
  1983.             }

  1985.             for (start += name->len; start < end && *start == ' '; start++) {
  1986.                 /* void */
  1987.             }

  1989.             if (value == NULL) {
  1990.                 if (start == end || *start == ',') {
  1991.                     return h;
  1992.                 }

  1994.                 goto skip;
  1995.             }

  1997.             if (start == end || *start++ != '=') {
  1998.                 /* the invalid header value */
  1999.                 goto skip;
  2000.             }

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

  2004.             for (last = start; last < end && *last != ';'; last++) {
  2005.                 /* void */
  2006.             }

  2008.             value->len = last - start;
  2009.             value->data = start;

  2011.             return h;

  2013.         skip:

  2015.             while (start < end) {
  2016.                 ch = *start++;
  2017.                 if (ch == ';' || ch == ',') {
  2018.                     break;
  2019.                 }
  2020.             }

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

  2026.     return NULL;
  2027. }


  2030. ngx_table_elt_t *
  2031. ‌ngx_http_parse_set_cookie_lines(ngx_http_request_t *r,
  2032.     ngx_table_elt_t *headers, ngx_str_t *name, ngx_str_t *value)
  2033. {
  2034.     u_char           *start, *last, *end;
  2035.     ngx_table_elt_t  *h;

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

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

  2042.         if (name->len >= h->value.len) {
  2043.             continue;
  2044.         }

  2046.         start = h->value.data;
  2047.         end = h->value.data + h->value.len;

  2049.         if (ngx_strncasecmp(start, name->data, name->len) != 0) {
  2050.             continue;
  2051.         }

  2053.         for (start += name->len; start < end && *start == ' '; start++) {
  2054.             /* void */
  2055.         }

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

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

  2064.         for (last = start; last < end && *last != ';'; last++) {
  2065.             /* void */
  2066.         }

  2068.         value->len = last - start;
  2069.         value->data = start;

  2071.         return h;
  2072.     }

  2074.     return NULL;
  2075. }


  2078. ngx_int_t
  2079. ‌ngx_http_arg(ngx_http_request_t *r, u_char *name, size_t len, ngx_str_t *value)
  2080. {
  2081.     u_char  *p, *last;

  2083.     if (r->args.len == 0) {
  2084.         return NGX_DECLINED;
  2085.     }

  2087.     p = r->args.data;
  2088.     last = p + r->args.len;

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

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

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

  2096.         if (p == NULL) {
  2097.             return NGX_DECLINED;
  2098.         }

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

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

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

  2106.             if (p == NULL) {
  2107.                 p = r->args.data + r->args.len;
  2108.             }

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

  2112.             return NGX_OK;
  2113.         }
  2114.     }

  2116.     return NGX_DECLINED;
  2117. }


  2120. void
  2121. ‌ngx_http_split_args(ngx_http_request_t *r, ngx_str_t *uri, ngx_str_t *args)
  2122. {
  2123.     u_char  *p, *last;

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

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

  2129.     if (p) {
  2130.         uri->len = p - uri->data;
  2131.         p++;
  2132.         args->len = last - p;
  2133.         args->data = p;

  2135.     } else {
  2136.         args->len = 0;
  2137.     }
  2138. }


  2141. ngx_int_t
  2142. ‌ngx_http_parse_chunked(ngx_http_request_t *r, ngx_buf_t *b,
  2143.     ngx_http_chunked_t *ctx, ngx_uint_t keep_trailers)
  2144. {
  2145.     u_char     *pos, ch, c;
  2146.     ngx_int_t   rc;
  2147. ‌    enum {
  2148.         sw_chunk_start = 0,
  2149.         sw_chunk_size,
  2150.         sw_chunk_extension,
  2151.         sw_chunk_extension_almost_done,
  2152.         sw_chunk_data,
  2153.         sw_after_data,
  2154.         sw_after_data_almost_done,
  2155.         sw_last_chunk_extension,
  2156.         sw_last_chunk_extension_almost_done,
  2157.         sw_trailer,
  2158.         sw_trailer_almost_done,
  2159.         sw_trailer_header,
  2160.         sw_trailer_header_almost_done
  2161.     } state;

  2163.     state = ctx->state;

  2165.     if (state == sw_chunk_data && ctx->size == 0) {
  2166.         state = sw_after_data;
  2167.     }

  2169.     rc = NGX_AGAIN;

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

  2173.         ch = *pos;

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

  2178.         switch (state) {

  2180.         case sw_chunk_start:
  2181.             if (ch >= '0' && ch <= '9') {
  2182.                 state = sw_chunk_size;
  2183.                 ctx->size = ch - '0';
  2184.                 break;
  2185.             }

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

  2189.             if (c >= 'a' && c <= 'f') {
  2190.                 state = sw_chunk_size;
  2191.                 ctx->size = c - 'a' + 10;
  2192.                 break;
  2193.             }

  2195.             goto invalid;

  2197.         case sw_chunk_size:
  2198.             if (ctx->size > NGX_MAX_OFF_T_VALUE / 16) {
  2199.                 goto invalid;
  2200.             }

  2202.             if (ch >= '0' && ch <= '9') {
  2203.                 ctx->size = ctx->size * 16 + (ch - '0');
  2204.                 break;
  2205.             }

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

  2209.             if (c >= 'a' && c <= 'f') {
  2210.                 ctx->size = ctx->size * 16 + (c - 'a' + 10);
  2211.                 break;
  2212.             }

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

  2216.                 switch (ch) {
  2217.                 case CR:
  2218.                     state = sw_last_chunk_extension_almost_done;
  2219.                     break;
  2220.                 case LF:
  2221.                     if (keep_trailers) {
  2222.                         goto done;
  2223.                     }
  2224.                     state = sw_trailer;
  2225.                     break;
  2226.                 case ';':
  2227.                 case ' ':
  2228.                 case '\t':
  2229.                     state = sw_last_chunk_extension;
  2230.                     break;
  2231.                 default:
  2232.                     goto invalid;
  2233.                 }

  2235.                 break;
  2236.             }

  2238.             switch (ch) {
  2239.             case CR:
  2240.                 state = sw_chunk_extension_almost_done;
  2241.                 break;
  2242.             case LF:
  2243.                 state = sw_chunk_data;
  2244.                 break;
  2245.             case ';':
  2246.             case ' ':
  2247.             case '\t':
  2248.                 state = sw_chunk_extension;
  2249.                 break;
  2250.             default:
  2251.                 goto invalid;
  2252.             }

  2254.             break;

  2256.         case sw_chunk_extension:
  2257.             switch (ch) {
  2258.             case CR:
  2259.                 state = sw_chunk_extension_almost_done;
  2260.                 break;
  2261.             case LF:
  2262.                 state = sw_chunk_data;
  2263.             }
  2264.             break;

  2266.         case sw_chunk_extension_almost_done:
  2267.             if (ch == LF) {
  2268.                 state = sw_chunk_data;
  2269.                 break;
  2270.             }
  2271.             goto invalid;

  2273.         case sw_chunk_data:
  2274.             rc = NGX_OK;
  2275.             goto data;

  2277.         case sw_after_data:
  2278.             switch (ch) {
  2279.             case CR:
  2280.                 state = sw_after_data_almost_done;
  2281.                 break;
  2282.             case LF:
  2283.                 state = sw_chunk_start;
  2284.                 break;
  2285.             default:
  2286.                 goto invalid;
  2287.             }
  2288.             break;

  2290.         case sw_after_data_almost_done:
  2291.             if (ch == LF) {
  2292.                 state = sw_chunk_start;
  2293.                 break;
  2294.             }
  2295.             goto invalid;

  2297.         case sw_last_chunk_extension:
  2298.             switch (ch) {
  2299.             case CR:
  2300.                 state = sw_last_chunk_extension_almost_done;
  2301.                 break;
  2302.             case LF:
  2303.                 if (keep_trailers) {
  2304.                     goto done;
  2305.                 }
  2306.                 state = sw_trailer;
  2307.             }
  2308.             break;

  2310.         case sw_last_chunk_extension_almost_done:
  2311.             if (ch == LF) {
  2312.                 if (keep_trailers) {
  2313.                     goto done;
  2314.                 }
  2315.                 state = sw_trailer;
  2316.                 break;
  2317.             }
  2318.             goto invalid;

  2320.         case sw_trailer:
  2321.             switch (ch) {
  2322.             case CR:
  2323.                 state = sw_trailer_almost_done;
  2324.                 break;
  2325.             case LF:
  2326.                 goto done;
  2327.             default:
  2328.                 state = sw_trailer_header;
  2329.             }
  2330.             break;

  2332.         case sw_trailer_almost_done:
  2333.             if (ch == LF) {
  2334.                 goto done;
  2335.             }
  2336.             goto invalid;

  2338.         case sw_trailer_header:
  2339.             switch (ch) {
  2340.             case CR:
  2341.                 state = sw_trailer_header_almost_done;
  2342.                 break;
  2343.             case LF:
  2344.                 state = sw_trailer;
  2345.             }
  2346.             break;

  2348.         case sw_trailer_header_almost_done:
  2349.             if (ch == LF) {
  2350.                 state = sw_trailer;
  2351.                 break;
  2352.             }
  2353.             goto invalid;

  2355.         }
  2356.     }

  2358. data:

  2360.     ctx->state = state;
  2361.     b->pos = pos;

  2363.     if (ctx->size > NGX_MAX_OFF_T_VALUE - 5) {
  2364.         goto invalid;
  2365.     }

  2367.     switch (state) {

  2369.     case sw_chunk_start:
  2370.         ctx->length = 3 /* "0" LF LF */;
  2371.         break;
  2372.     case sw_chunk_size:
  2373.         ctx->length = 1 /* LF */
  2374.                       + (ctx->size ? ctx->size + 4 /* LF "0" LF LF */
  2375.                                    : 1 /* LF */);
  2376.         break;
  2377.     case sw_chunk_extension:
  2378.     case sw_chunk_extension_almost_done:
  2379.         ctx->length = 1 /* LF */ + ctx->size + 4 /* LF "0" LF LF */;
  2380.         break;
  2381.     case sw_chunk_data:
  2382.         ctx->length = ctx->size + 4 /* LF "0" LF LF */;
  2383.         break;
  2384.     case sw_after_data:
  2385.     case sw_after_data_almost_done:
  2386.         ctx->length = 4 /* LF "0" LF LF */;
  2387.         break;
  2388.     case sw_last_chunk_extension:
  2389.     case sw_last_chunk_extension_almost_done:
  2390.         ctx->length = 2 /* LF LF */;
  2391.         break;
  2392.     case sw_trailer:
  2393.     case sw_trailer_almost_done:
  2394.         ctx->length = 1 /* LF */;
  2395.         break;
  2396.     case sw_trailer_header:
  2397.     case sw_trailer_header_almost_done:
  2398.         ctx->length = 2 /* LF LF */;
  2399.         break;

  2401.     }

  2403.     return rc;

  2405. done:

  2407.     ctx->state = 0;
  2408.     b->pos = pos + 1;

  2410.     return NGX_DONE;

  2412. invalid:

  2414.     return NGX_ERROR;
  2415. }

One Level Up Top Level