One Level Up Top Level

src/core/ngx_json_unescape.c - nginx-1.31.9 nginx/ @ 2a3a19c6f

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 *dst, ngx_str_t *src)
  24. {
  25.     size_t       size;
  26.     u_char      *d, *s, 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).
  63.      */

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

  70.     if (dst->len < src->len) {
  71.         return NGX_ERROR;
  72.     }

  74.     s = src->data;
  75.     d = dst->data;
  76.     size = src->len;


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

  84.     while (size--) {

  86.         ch = *s++;

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

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

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

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

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

  108.         case sw_quoted:

  110.             switch (ch) {

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

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

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

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

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

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

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

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

  154.             break;

  156.         case sw_hex:

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

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

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

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

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

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

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

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

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

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

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

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

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

  231.     dst->len = d - dst->data;

  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