One Level Up Top Level

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

Functions defined

Macros defined

Source code


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


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


  12. ‌#define NGX_HTTP_PRIORITY_DEFAULT_URGENCY  3
  13. ‌#define NGX_HTTP_PRIORITY_URGENCY_MIN      0
  14. ‌#define NGX_HTTP_PRIORITY_URGENCY_MAX      7


  17. /* bare item types we distinguish; others are parsed and discarded */

  19. ‌#define NGX_HTTP_PRIORITY_INTEGER  0
  20. ‌#define NGX_HTTP_PRIORITY_BOOLEAN  1
  21. ‌#define NGX_HTTP_PRIORITY_OTHER    2


  24. /*
  25. * Parse limits.  RFC 8941 requires parsers to support at least these many
  26. * elements and characters; bounding the counts and individual item lengths
  27. * keeps parse time proportional to a well-formed field rather than to what a
  28. * peer chooses to send.
  29. */

  31. ‌#define NGX_HTTP_PRIORITY_MAX_MEMBERS      1024
  32. ‌#define NGX_HTTP_PRIORITY_MAX_INNER_ITEMS  256
  33. ‌#define NGX_HTTP_PRIORITY_MAX_PARAMS       256
  34. ‌#define NGX_HTTP_PRIORITY_MAX_STRING       1024
  35. ‌#define NGX_HTTP_PRIORITY_MAX_TOKEN        512
  36. ‌#define NGX_HTTP_PRIORITY_MAX_BINARY       21848  /* 16384 after decoding */


  39. static ngx_int_t ngx_http_priority_parse_key(u_char **pos, u_char *end,
  40.     ngx_str_t *key);
  41. static ngx_int_t ngx_http_priority_parse_member(u_char **pos, u_char *end,
  42.     ngx_str_t *key, ngx_int_t *type, ngx_int_t *value);
  43. static ngx_int_t ngx_http_priority_parse_value(u_char **pos, u_char *end,
  44.     ngx_int_t *type, ngx_int_t *value);
  45. static ngx_int_t ngx_http_priority_parse_inner_list(u_char **pos, u_char *end);
  46. static ngx_int_t ngx_http_priority_parse_bare_item(u_char **pos, u_char *end,
  47.     ngx_int_t *type, ngx_int_t *value);
  48. static ngx_int_t ngx_http_priority_parse_params(u_char **pos, u_char *end);
  49. static ngx_int_t ngx_http_priority_parse_number(u_char **pos, u_char *end,
  50.     ngx_int_t *type, ngx_int_t *value);
  51. static ngx_int_t ngx_http_priority_parse_string(u_char **pos, u_char *end);
  52. static ngx_int_t ngx_http_priority_parse_token(u_char **pos, u_char *end);
  53. static ngx_int_t ngx_http_priority_parse_binary(u_char **pos, u_char *end);


  56. void
  57. ‌ngx_http_priority_state_init(ngx_http_priority_state_t *ps)
  58. {
  59.     ngx_memzero(ps, sizeof(ngx_http_priority_state_t));

  61.     ps->client.urgency = NGX_HTTP_PRIORITY_DEFAULT_URGENCY;
  62.     ps->server.urgency = NGX_HTTP_PRIORITY_DEFAULT_URGENCY;
  63.     ps->effective.urgency = NGX_HTTP_PRIORITY_DEFAULT_URGENCY;
  64. }


  67. /*
  68. * Parse an RFC 9218 Priority field, a Structured Fields Dictionary
  69. * (RFC 8941).  The dictionary is parsed strictly: any syntax error fails
  70. * the whole field (RFC 8941, Section 4.2), and only then are the RFC 9218
  71. * rules applied, ignoring unknown members, out-of-range urgency and members
  72. * of an unexpected type.  On error the field is treated as absent and p is
  73. * left at defaults; callers keep any previously signalled priority.
  74. */

  76. ngx_int_t
  77. ‌ngx_http_priority_parse(ngx_str_t *field, ngx_http_priority_t *p)
  78. {
  79.     u_char      *last, *end;
  80.     ngx_str_t    key;
  81.     ngx_int_t    type, value;
  82.     ngx_uint_t   members;

  84.     p->urgency = NGX_HTTP_PRIORITY_DEFAULT_URGENCY;
  85.     p->incremental = 0;
  86.     p->urgency_set = 0;
  87.     p->incremental_set = 0;

  89.     if (field == NULL) {
  90.         return NGX_OK;
  91.     }

  93.     /* RFC 8941, Section 4.2.2 */

  95.     last = field->data;
  96.     end = last + field->len;
  97.     members = 0;

  99.     /* Section 4.2, step 2: discard leading SP */

  101.     while (last < end && *last == ' ') {
  102.         last++;
  103.     }

  105.     while (last < end) {

  107.         if (++members > NGX_HTTP_PRIORITY_MAX_MEMBERS) {
  108.             return NGX_ERROR;
  109.         }

  111.         if (ngx_http_priority_parse_member(&last, end, &key, &type, &value)
  112.             != NGX_OK)
  113.         {
  114.             return NGX_ERROR;
  115.         }

  117.         /*
  118.          * RFC 8941, Section 4.2.2, step 2.4: a duplicate key replaces the
  119.          * earlier member.  RFC 9218, Section 4: unknown members and members
  120.          * of an unexpected type are ignored.  A repeated u or i therefore
  121.          * resets to the default first, so a later out-of-range or
  122.          * wrong-typed value leaves the parameter absent rather than keeping
  123.          * the earlier one.
  124.          */

  126.         if (key.len == 1 && key.data[0] == 'u') {

  128.             p->urgency = NGX_HTTP_PRIORITY_DEFAULT_URGENCY;
  129.             p->urgency_set = 0;

  131.             if (type == NGX_HTTP_PRIORITY_INTEGER
  132.                 && value >= NGX_HTTP_PRIORITY_URGENCY_MIN
  133.                 && value <= NGX_HTTP_PRIORITY_URGENCY_MAX)
  134.             {
  135.                 p->urgency = (unsigned) value;
  136.                 p->urgency_set = 1;
  137.             }

  139.         } else if (key.len == 1 && key.data[0] == 'i') {

  141.             p->incremental = 0;
  142.             p->incremental_set = 0;

  144.             if (type == NGX_HTTP_PRIORITY_BOOLEAN) {
  145.                 p->incremental = (unsigned) value;
  146.                 p->incremental_set = 1;
  147.             }
  148.         }

  150.         while (last < end && (*last == ' ' || *last == '\t')) {
  151.             last++;
  152.         }

  154.         if (last == end) {
  155.             break;
  156.         }

  158.         if (*last++ != ',') {
  159.             return NGX_ERROR;
  160.         }

  162.         while (last < end && (*last == ' ' || *last == '\t')) {
  163.             last++;
  164.         }

  166.         /* trailing comma */

  168.         if (last == end) {
  169.             return NGX_ERROR;
  170.         }
  171.     }

  173.     return NGX_OK;
  174. }


  177. /*
  178. * Parse one dictionary member and its parameters (RFC 8941, Section 4.2.2).
  179. * A bare key (no "=") is a Boolean true; type/value then describe the
  180. * member's value so the caller can pick out u and i and ignore the rest.
  181. */

  183. static ngx_int_t
  184. ‌ngx_http_priority_parse_member(u_char **pos, u_char *end, ngx_str_t *key,
  185.     ngx_int_t *type, ngx_int_t *value)
  186. {
  187.     u_char  *last;

  189.     last = *pos;

  191.     if (ngx_http_priority_parse_key(&last, end, key) != NGX_OK) {
  192.         return NGX_ERROR;
  193.     }

  195.     if (last < end && *last == '=') {
  196.         last++;

  198.         if (ngx_http_priority_parse_value(&last, end, type, value) != NGX_OK) {
  199.             return NGX_ERROR;
  200.         }

  202.     } else {
  203.         *type = NGX_HTTP_PRIORITY_BOOLEAN;
  204.         *value = 1;

  206.         if (ngx_http_priority_parse_params(&last, end) != NGX_OK) {
  207.             return NGX_ERROR;
  208.         }
  209.     }

  211.     *pos = last;

  213.     return NGX_OK;
  214. }


  217. /* RFC 8941, Section 4.2.1.1: an Item or an Inner List, each with Parameters */

  219. static ngx_int_t
  220. ‌ngx_http_priority_parse_value(u_char **pos, u_char *end, ngx_int_t *type,
  221.     ngx_int_t *value)
  222. {
  223.     u_char  *last;

  225.     last = *pos;

  227.     if (last < end && *last == '(') {
  228.         *type = NGX_HTTP_PRIORITY_OTHER;
  229.         *value = 0;

  231.         if (ngx_http_priority_parse_inner_list(&last, end) != NGX_OK) {
  232.             return NGX_ERROR;
  233.         }

  235.     } else {
  236.         if (ngx_http_priority_parse_bare_item(&last, end, type, value)
  237.             != NGX_OK)
  238.         {
  239.             return NGX_ERROR;
  240.         }
  241.     }

  243.     if (ngx_http_priority_parse_params(&last, end) != NGX_OK) {
  244.         return NGX_ERROR;
  245.     }

  247.     *pos = last;

  249.     return NGX_OK;
  250. }


  253. /* RFC 8941, Section 4.2.3.3 */

  255. static ngx_int_t
  256. ‌ngx_http_priority_parse_key(u_char **pos, u_char *end, ngx_str_t *key)
  257. {
  258.     u_char  *last, ch;

  260.     last = *pos;

  262.     if (last == end) {
  263.         return NGX_ERROR;
  264.     }

  266.     ch = *last;

  268.     if (!((ch >= 'a' && ch <= 'z') || ch == '*')) {
  269.         return NGX_ERROR;
  270.     }

  272.     key->data = last;

  274.     do {
  275.         last++;

  277.         if (last == end) {
  278.             break;
  279.         }

  281.         ch = *last;

  283.     } while ((ch >= 'a' && ch <= 'z') || (ch >= '0' && ch <= '9')
  284.              || ch == '_' || ch == '-' || ch == '.' || ch == '*');

  286.     key->len = last - *pos;
  287.     *pos = last;

  289.     return NGX_OK;
  290. }


  293. /* RFC 8941, Section 4.2.3.2 */

  295. static ngx_int_t
  296. ‌ngx_http_priority_parse_params(u_char **pos, u_char *end)
  297. {
  298.     u_char     *last;
  299.     ngx_str_t   key;
  300.     ngx_int_t   type, value;
  301.     ngx_uint_t  params;

  303.     last = *pos;
  304.     params = 0;

  306.     while (last < end && *last == ';') {
  307.         last++;

  309.         if (++params > NGX_HTTP_PRIORITY_MAX_PARAMS) {
  310.             return NGX_ERROR;
  311.         }

  313.         /* Section 4.2.3.2, step 2.3: discard leading SP */

  315.         while (last < end && *last == ' ') {
  316.             last++;
  317.         }

  319.         if (ngx_http_priority_parse_key(&last, end, &key) != NGX_OK) {
  320.             return NGX_ERROR;
  321.         }

  323.         if (last < end && *last == '=') {
  324.             last++;

  326.             if (ngx_http_priority_parse_bare_item(&last, end, &type, &value)
  327.                 != NGX_OK)
  328.             {
  329.                 return NGX_ERROR;
  330.             }
  331.         }
  332.     }

  334.     *pos = last;

  336.     return NGX_OK;
  337. }


  340. /* RFC 8941, Section 4.2.1.2: Inner List */

  342. static ngx_int_t
  343. ‌ngx_http_priority_parse_inner_list(u_char **pos, u_char *end)
  344. {
  345.     u_char     *last;
  346.     ngx_int_t   type, value;
  347.     ngx_uint_t  items;

  349.     last = *pos + 1;
  350.     items = 0;

  352.     for ( ;; ) {

  354.         while (last < end && *last == ' ') {
  355.             last++;
  356.         }

  358.         if (last < end && *last == ')') {
  359.             *pos = last + 1;
  360.             return NGX_OK;
  361.         }

  363.         if (++items > NGX_HTTP_PRIORITY_MAX_INNER_ITEMS) {
  364.             return NGX_ERROR;
  365.         }

  367.         if (ngx_http_priority_parse_bare_item(&last, end, &type, &value)
  368.             != NGX_OK)
  369.         {
  370.             return NGX_ERROR;
  371.         }

  373.         if (ngx_http_priority_parse_params(&last, end) != NGX_OK) {
  374.             return NGX_ERROR;
  375.         }

  377.         if (last == end) {
  378.             return NGX_ERROR;
  379.         }

  381.         if (*last != ' ' && *last != ')') {
  382.             return NGX_ERROR;
  383.         }
  384.     }
  385. }


  388. /* RFC 8941, Section 4.2.3.1 */

  390. static ngx_int_t
  391. ‌ngx_http_priority_parse_bare_item(u_char **pos, u_char *end, ngx_int_t *type,
  392.     ngx_int_t *value)
  393. {
  394.     u_char  ch;

  396.     if (*pos == end) {
  397.         return NGX_ERROR;
  398.     }

  400.     ch = **pos;

  402.     if (ch == '-' || (ch >= '0' && ch <= '9')) {
  403.         return ngx_http_priority_parse_number(pos, end, type, value);
  404.     }

  406.     if (ch == '?') {
  407.         (*pos)++;

  409.         if (*pos == end || (**pos != '0' && **pos != '1')) {
  410.             return NGX_ERROR;
  411.         }

  413.         *type = NGX_HTTP_PRIORITY_BOOLEAN;
  414.         *value = (**pos == '1');
  415.         (*pos)++;

  417.         return NGX_OK;
  418.     }

  420.     *type = NGX_HTTP_PRIORITY_OTHER;

  422.     if (ch == '"') {
  423.         return ngx_http_priority_parse_string(pos, end);
  424.     }

  426.     if (ch == ':') {
  427.         return ngx_http_priority_parse_binary(pos, end);
  428.     }

  430.     if (((ch | 0x20) >= 'a' && (ch | 0x20) <= 'z') || ch == '*') {
  431.         return ngx_http_priority_parse_token(pos, end);
  432.     }

  434.     return NGX_ERROR;
  435. }


  438. /* RFC 8941, Section 4.2.4: Integer or Decimal */

  440. static ngx_int_t
  441. ‌ngx_http_priority_parse_number(u_char **pos, u_char *end, ngx_int_t *type,
  442.     ngx_int_t *value)
  443. {
  444.     u_char     *last, *start;
  445.     ngx_int_t   n;
  446.     ngx_uint_t  neg, decimal, digits, frac;

  448.     last = *pos;
  449.     neg = 0;

  451.     if (*last == '-') {
  452.         neg = 1;
  453.         last++;
  454.     }

  456.     start = last;
  457.     decimal = 0;
  458.     digits = 0;
  459.     frac = 0;

  461.     /* RFC 8941, Section 4.2.4 */

  463.     while (last < end) {

  465.         if (*last >= '0' && *last <= '9') {
  466.             digits++;

  468.             /* step 7.5: an Integer has at most 15 digits */

  470.             if (!decimal && digits > 15) {
  471.                 return NGX_ERROR;
  472.             }

  474.             /* step 9.2: a Decimal has at most three fractional digits */

  476.             if (decimal && ++frac > 3) {
  477.                 return NGX_ERROR;
  478.             }

  480.             last++;
  481.             continue;
  482.         }

  484.         /* step 8: a single "." starts the fractional part of a Decimal */

  486.         if (*last == '.' && !decimal) {

  488.             /* step 8.1: at most 12 digits before the decimal point */

  490.             if (digits == 0 || digits > 12) {
  491.                 return NGX_ERROR;
  492.             }

  494.             decimal = 1;
  495.             last++;
  496.             continue;
  497.         }

  499.         break;
  500.     }

  502.     if (digits == 0) {
  503.         return NGX_ERROR;
  504.     }

  506.     if (decimal) {

  508.         /* step 9.1: a Decimal must not end with "." */

  510.         if (frac == 0) {
  511.             return NGX_ERROR;
  512.         }

  514.         /* a valid Decimal, but not an Integer: parsed and discarded */

  516.         *type = NGX_HTTP_PRIORITY_OTHER;
  517.         *value = 0;
  518.         *pos = last;
  519.         return NGX_OK;
  520.     }

  522.     n = ngx_atoi(start, last - start);
  523.     if (n == NGX_ERROR) {

  525.         /* a valid Integer exceeding ngx_int_t: parsed and discarded */

  527.         *type = NGX_HTTP_PRIORITY_OTHER;
  528.         *value = 0;
  529.         *pos = last;
  530.         return NGX_OK;
  531.     }

  533.     *type = NGX_HTTP_PRIORITY_INTEGER;
  534.     *value = neg ? -n : n;
  535.     *pos = last;

  537.     return NGX_OK;
  538. }


  541. /* RFC 8941, Section 4.2.5: String */

  543. static ngx_int_t
  544. ‌ngx_http_priority_parse_string(u_char **pos, u_char *end)
  545. {
  546.     u_char      *last, ch;
  547.     ngx_uint_t   len;

  549.     last = *pos + 1;
  550.     len = 0;

  552.     while (last < end) {
  553.         ch = *last++;

  555.         if (ch == '\\') {
  556.             if (last == end || (*last != '"' && *last != '\\')) {
  557.                 return NGX_ERROR;
  558.             }
  559.             last++;

  561.             if (++len > NGX_HTTP_PRIORITY_MAX_STRING) {
  562.                 return NGX_ERROR;
  563.             }

  565.             continue;
  566.         }

  568.         if (ch == '"') {
  569.             *pos = last;
  570.             return NGX_OK;
  571.         }

  573.         if (ch < 0x20 || ch >= 0x7f) {
  574.             return NGX_ERROR;
  575.         }

  577.         if (++len > NGX_HTTP_PRIORITY_MAX_STRING) {
  578.             return NGX_ERROR;
  579.         }
  580.     }

  582.     return NGX_ERROR;
  583. }


  586. /* RFC 8941, Section 4.2.6: Token */

  588. static ngx_int_t
  589. ‌ngx_http_priority_parse_token(u_char **pos, u_char *end)
  590. {
  591.     u_char  *last, ch;

  593.     last = *pos + 1;

  595.     while (last < end) {
  596.         ch = *last;

  598.         if (ch == ':' || ch == '/'
  599.             || ((ch | 0x20) >= 'a' && (ch | 0x20) <= 'z')
  600.             || (ch >= '0' && ch <= '9')
  601.             || ch == '!' || ch == '#' || ch == '$' || ch == '%'
  602.             || ch == '&' || ch == '\'' || ch == '*' || ch == '+'
  603.             || ch == '-' || ch == '.' || ch == '^' || ch == '_'
  604.             || ch == '`' || ch == '|' || ch == '~')
  605.         {
  606.             if ((ngx_uint_t) (last - *pos) >= NGX_HTTP_PRIORITY_MAX_TOKEN) {
  607.                 return NGX_ERROR;
  608.             }

  610.             last++;
  611.             continue;
  612.         }

  614.         break;
  615.     }

  617.     *pos = last;

  619.     return NGX_OK;
  620. }


  623. /* RFC 8941, Section 4.2.7: Byte Sequence */

  625. static ngx_int_t
  626. ‌ngx_http_priority_parse_binary(u_char **pos, u_char *end)
  627. {
  628.     u_char      *last, ch;
  629.     ngx_uint_t   len;

  631.     last = *pos + 1;
  632.     len = 0;

  634.     while (last < end) {
  635.         ch = *last++;

  637.         if (ch == ':') {

  639.             /* the content has to decode: 4n + 1 characters cannot */

  641.             if (len % 4 == 1) {
  642.                 return NGX_ERROR;
  643.             }

  645.             *pos = last;
  646.             return NGX_OK;
  647.         }

  649.         if (!(((ch | 0x20) >= 'a' && (ch | 0x20) <= 'z')
  650.               || (ch >= '0' && ch <= '9')
  651.               || ch == '+' || ch == '/' || ch == '='))
  652.         {
  653.             return NGX_ERROR;
  654.         }

  656.         if (++len > NGX_HTTP_PRIORITY_MAX_BINARY) {
  657.             return NGX_ERROR;
  658.         }
  659.     }

  661.     return NGX_ERROR;
  662. }


  665. void
  666. ‌ngx_http_priority_state_update(ngx_http_priority_state_t *ps)
  667. {
  668.     ngx_http_priority_t  *e;

  670.     e = &ps->effective;
  671.     *e = ps->client;

  673.     if (ps->server.urgency_set) {
  674.         e->urgency = ps->server.urgency;
  675.         e->urgency_set = 1;
  676.     }

  678.     if (ps->server.incremental_set) {
  679.         e->incremental = ps->server.incremental;
  680.         e->incremental_set = 1;
  681.     }
  682. }

One Level Up Top Level