One Level Up Top Level

src/core/ngx_json_unescape.c - nginx-1.31.7 nginx/ @ 939334eff

Data types defined

Functions defined

Source code


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


  7. /*
  8. * JSON string unescape.  Decodes escape sequences defined by
  9. * RFC 8259, Section 7, including \uXXXX and UTF-16 surrogate pairs.
  10. */


  13. #include <ngx_config.h>
  14. #include <ngx_core.h>
  15. #include <ngx_json_unescape.h>


  18. static ngx_inline u_char *ngx_json_utf8_encode(u_char *dst,
  19.     uint32_t codepoint);


  22. ngx_int_t
  23. ‌ngx_json_unescape_string(ngx_str_t *str)
  24. {
  25.     size_t       size;
  26.     u_char      *d, *s, *start, ch;
  27.     uint32_t     codepoint, high_surrogate;
  28.     ngx_int_t    n;
  29.     ngx_uint_t   hex_left;

  31. ‌    enum {
  32.         sw_usual = 0,
  33.         sw_quoted,
  34.         sw_hex,
  35.         sw_surrogate_start,   /* expect '\' of \uDCxx after high surrogate */
  36.         sw_surrogate_u        /* expect 'u' */
  37.     } state;

  39.     /*
  40.      * RFC 8259, Section 7:
  41.      *
  42.      * string = quotation-mark *char quotation-mark
  43.      *
  44.      * char = unescaped /
  45.      *        escape (
  46.      *            %x22 /          ; "    quotation mark  U+0022
  47.      *            %x5C /          ; \    reverse solidus U+005C
  48.      *            %x2F /          ; /    solidus         U+002F
  49.      *            %x62 /          ; b    backspace       U+0008
  50.      *            %x66 /          ; f    form feed       U+000C
  51.      *            %x6E /          ; n    line feed       U+000A
  52.      *            %x72 /          ; r    carriage return U+000D
  53.      *            %x74 /          ; t    tab             U+0009
  54.      *            %x75 4HEXDIG )  ; uXXXX                U+XXXX
  55.      *
  56.      * Non-BMP code points are encoded as a UTF-16 surrogate pair:
  57.      *   \uD800..\uDBFF  high surrogate
  58.      *   \uDC00..\uDFFF  low  surrogate
  59.      * The pair decodes to U+10000 + (high - 0xD800) * 0x400
  60.      *                              + (low  - 0xDC00).
  61.      * The input is an unquoted JSON string body (the bytes between the
  62.      * surrounding double quotes); it is decoded in place.
  63.      */

  65.     if (str->len == 0) {
  66.         return NGX_OK;
  67.     }

  69.     if (str->data == NULL) {
  70.         return NGX_ERROR;
  71.     }

  73.     start = str->data;
  74.     size = str->len;

  76.     d = s = start;

  78.     state = sw_usual;
  79.     codepoint = 0;
  80.     high_surrogate = 0;
  81.     hex_left = 0;

  83.     while (size--) {

  85.         ch = *s++;

  87.         switch (state) {
  88.         case sw_usual:

  90.             if (ch == '"') {
  91.                 return NGX_ERROR;
  92.             }

  94.             if (ch == '\\') {
  95.                 state = sw_quoted;
  96.                 break;
  97.             }

  99.             if (ch < 0x20) {
  100.                 /* RFC 8259: control characters must be escaped */
  101.                 return NGX_ERROR;
  102.             }

  104.             *d++ = ch;
  105.             break;

  107.         case sw_quoted:

  109.             switch (ch) {

  111.             case 'u':
  112.                 codepoint = 0;
  113.                 hex_left = 4;
  114.                 state = sw_hex;
  115.                 break;

  117.             case '"':
  118.             case '/':
  119.             case '\\':
  120.                 *d++ = ch;
  121.                 state = sw_usual;
  122.                 break;

  124.             case 'b':
  125.                 *d++ = '\b';
  126.                 state = sw_usual;
  127.                 break;

  129.             case 'f':
  130.                 *d++ = '\f';
  131.                 state = sw_usual;
  132.                 break;

  134.             case 'n':
  135.                 *d++ = '\n';
  136.                 state = sw_usual;
  137.                 break;

  139.             case 'r':
  140.                 *d++ = '\r';
  141.                 state = sw_usual;
  142.                 break;

  144.             case 't':
  145.                 *d++ = '\t';
  146.                 state = sw_usual;
  147.                 break;

  149.             default:
  150.                 return NGX_ERROR;
  151.             }

  153.             break;

  155.         case sw_hex:

  157.             n = ngx_json_hex_digit(ch);
  158.             if (n == NGX_ERROR) {
  159.                 return NGX_ERROR;
  160.             }

  162.             codepoint = (codepoint << 4) | (uint32_t) n;

  164.             if (--hex_left > 0) {
  165.                 break;
  166.             }

  168.             if (high_surrogate) {
  169.                 if (codepoint < 0xDC00 || codepoint > 0xDFFF) {
  170.                     return NGX_ERROR;
  171.                 }

  173.                 codepoint = 0x10000
  174.                             + ((high_surrogate - 0xD800) << 10)
  175.                             + (codepoint - 0xDC00);
  176.                 d = ngx_json_utf8_encode(d, codepoint);
  177.                 high_surrogate = 0;
  178.                 state = sw_usual;
  179.                 break;
  180.             }

  182.             if (codepoint >= 0xD800 && codepoint <= 0xDBFF) {
  183.                 /* high surrogate - wait for the low surrogate */
  184.                 high_surrogate = codepoint;
  185.                 state = sw_surrogate_start;
  186.                 break;
  187.             }

  189.             if (codepoint >= 0xDC00 && codepoint <= 0xDFFF) {
  190.                 /* lone low surrogate */
  191.                 return NGX_ERROR;
  192.             }

  194.             d = ngx_json_utf8_encode(d, codepoint);
  195.             state = sw_usual;
  196.             break;

  198.         case sw_surrogate_start:
  199.             /*
  200.              * Expect '\' to begin the low-surrogate escape.
  201.              * Lone surrogates are not valid Unicode scalar values
  202.              * (RFC 8259, Section 8.2).
  203.              */
  204.             if (ch == '\\') {
  205.                 state = sw_surrogate_u;
  206.                 break;
  207.             }

  209.             /* lone high surrogate */
  210.             return NGX_ERROR;

  212.         case sw_surrogate_u:
  213.             if (ch == 'u') {
  214.                 codepoint = 0;
  215.                 hex_left = 4;
  216.                 state = sw_hex;
  217.                 break;
  218.             }

  220.             /* lone high surrogate */
  221.             return NGX_ERROR;
  222.         }
  223.     }

  225.     if (state != sw_usual) {
  226.         /* truncated escape sequence or unpaired high surrogate */
  227.         return NGX_ERROR;
  228.     }

  230.     str->data = start;
  231.     str->len = d - start;

  233.     return NGX_OK;
  234. }


  237. static ngx_inline u_char *
  238. ‌ngx_json_utf8_encode(u_char *dst, uint32_t codepoint)
  239. {
  240.     if (codepoint <= 0x7F) {
  241.         *dst++ = (u_char) codepoint;

  243.     } else if (codepoint <= 0x7FF) {
  244.         *dst++ = (u_char) (0xC0 | (codepoint >> 6));
  245.         *dst++ = (u_char) (0x80 | (codepoint & 0x3F));

  247.     } else if (codepoint <= 0xFFFF) {
  248.         *dst++ = (u_char) (0xE0 | (codepoint >> 12));
  249.         *dst++ = (u_char) (0x80 | ((codepoint >> 6) & 0x3F));
  250.         *dst++ = (u_char) (0x80 | (codepoint & 0x3F));

  252.     } else {
  253.         *dst++ = (u_char) (0xF0 | (codepoint >> 18));
  254.         *dst++ = (u_char) (0x80 | ((codepoint >> 12) & 0x3F));
  255.         *dst++ = (u_char) (0x80 | ((codepoint >> 6) & 0x3F));
  256.         *dst++ = (u_char) (0x80 | (codepoint & 0x3F));
  257.     }

  259.     return dst;
  260. }


  263. ngx_int_t
  264. ‌ngx_json_hex_digit(u_char ch)
  265. {
  266.     if (ch >= '0' && ch <= '9') {
  267.         return ch - '0';
  268.     }

  270.     ch = (u_char) (ch | 0x20);

  272.     if (ch >= 'a' && ch <= 'f') {
  273.         return ch - 'a' + 10;
  274.     }

  276.     return NGX_ERROR;
  277. }

One Level Up Top Level