Inside Bitcoin

1// Copyright 2014 BitPay Inc.
2// Copyright (c) 2015-present The Bitcoin Core developers
3// Distributed under the MIT software license, see the accompanying
4// file COPYING or https://opensource.org/licenses/mit-license.php.
5
6#include <univalue.h>
7#include <univalue_utffilter.h>
8
9#include <cstdint>
10#include <cstring>
11#include <string>
12#include <string_view>
13#include <utility>
14#include <vector>
15
16/*
17 * According to stackexchange, the original json test suite wanted
18 * to limit depth to 22.  Widely-deployed PHP bails at depth 512,
19 * so we will follow PHP's lead, which should be more than sufficient
20 * (further stackexchange comments indicate depth > 32 rarely occurs).
21 */
22static constexpr size_t MAX_JSON_DEPTH = 512;
23
24static bool json_isdigit(int ch)
25{
26    return ((ch >= '0') && (ch <= '9'));
27}
28
29// convert hexadecimal string to unsigned integer
30static const char *hatoui(const char *first, const char *last,
31                          unsigned int& out)
32{
33    unsigned int result = 0;
34    for (; first != last; ++first)
35    {
36        int digit;
37        if (json_isdigit(*first))
38            digit = *first - '0';
39
40        else if (*first >= 'a' && *first <= 'f')
41            digit = *first - 'a' + 10;
42
43        else if (*first >= 'A' && *first <= 'F')
44            digit = *first - 'A' + 10;
45
46        else
47            break;
48
49        result = 16 * result + digit;
50    }
51    out = result;
52
53    return first;
54}
55
56enum jtokentype getJsonToken(std::string& tokenVal, unsigned int& consumed,
57                            const char *raw, const char *end)
58{
59    tokenVal.clear();
60    consumed = 0;
61
62    const char *rawStart = raw;
63
64    while (raw < end && (json_isspace(*raw)))          // skip whitespace
65        raw++;
66
67    if (raw >= end)
68        return JTOK_NONE;
69
70    switch (*raw) {
71
72    case '{':
73        raw++;
74        consumed = (raw - rawStart);
75        return JTOK_OBJ_OPEN;
76    case '}':
77        raw++;
78        consumed = (raw - rawStart);
79        return JTOK_OBJ_CLOSE;
80    case '[':
81        raw++;
82        consumed = (raw - rawStart);
83        return JTOK_ARR_OPEN;
84    case ']':
85        raw++;
86        consumed = (raw - rawStart);
87        return JTOK_ARR_CLOSE;
88
89    case ':':
90        raw++;
91        consumed = (raw - rawStart);
92        return JTOK_COLON;
93    case ',':
94        raw++;
95        consumed = (raw - rawStart);
96        return JTOK_COMMA;
97
98    case 'n':
99    case 't':
100    case 'f':
101        if (!strncmp(raw, "null", 4)) {
102            raw += 4;
103            consumed = (raw - rawStart);
104            return JTOK_KW_NULL;
105        } else if (!strncmp(raw, "true", 4)) {
106            raw += 4;
107            consumed = (raw - rawStart);
108            return JTOK_KW_TRUE;
109        } else if (!strncmp(raw, "false", 5)) {
110            raw += 5;
111            consumed = (raw - rawStart);
112            return JTOK_KW_FALSE;
113        } else
114            return JTOK_ERR;
115
116    case '-':
117    case '0':
118    case '1':
119    case '2':
120    case '3':
121    case '4':
122    case '5':
123    case '6':
124    case '7':
125    case '8':
126    case '9': {
127        // part 1: int
128        std::string numStr;
129
130        const char *first = raw;
131
132        const char *firstDigit = first;
133        if (!json_isdigit(*firstDigit))
134            firstDigit++;
135        if ((*firstDigit == '0') && json_isdigit(firstDigit[1]))
136            return JTOK_ERR;
137
138        numStr += *raw;                       // copy first char
139        raw++;
140
141        if ((*first == '-') && (raw < end) && (!json_isdigit(*raw)))
142            return JTOK_ERR;
143
144        while (raw < end && json_isdigit(*raw)) {  // copy digits
145            numStr += *raw;
146            raw++;
147        }
148
149        // part 2: frac
150        if (raw < end && *raw == '.') {
151            numStr += *raw;                   // copy .
152            raw++;
153
154            if (raw >= end || !json_isdigit(*raw))
155                return JTOK_ERR;
156            while (raw < end && json_isdigit(*raw)) { // copy digits
157                numStr += *raw;
158                raw++;
159            }
160        }
161
162        // part 3: exp
163        if (raw < end && (*raw == 'e' || *raw == 'E')) {
164            numStr += *raw;                   // copy E
165            raw++;
166
167            if (raw < end && (*raw == '-' || *raw == '+')) { // copy +/-
168                numStr += *raw;
169                raw++;
170            }
171
172            if (raw >= end || !json_isdigit(*raw))
173                return JTOK_ERR;
174            while (raw < end && json_isdigit(*raw)) { // copy digits
175                numStr += *raw;
176                raw++;
177            }
178        }
179
180        tokenVal = numStr;
181        consumed = (raw - rawStart);
182        return JTOK_NUMBER;
183        }
184
185    case '"': {
186        raw++;                                // skip "
187
188        std::string valStr;
189        JSONUTF8StringFilter writer(valStr);
190
191        while (true) {
192            if (raw >= end || (unsigned char)*raw < 0x20)
193                return JTOK_ERR;
194
195            else if (*raw == '\\') {
196                raw++;                        // skip backslash
197
198                if (raw >= end)
199                    return JTOK_ERR;
200
201                switch (*raw) {
202                case '"':  writer.push_back('\"'); break;
203                case '\\': writer.push_back('\\'); break;
204                case '/':  writer.push_back('/'); break;
205                case 'b':  writer.push_back('\b'); break;
206                case 'f':  writer.push_back('\f'); break;
207                case 'n':  writer.push_back('\n'); break;
208                case 'r':  writer.push_back('\r'); break;
209                case 't':  writer.push_back('\t'); break;
210
211                case 'u': {
212                    unsigned int codepoint;
213                    if (raw + 1 + 4 >= end ||
214                        hatoui(raw + 1, raw + 1 + 4, codepoint) !=
215                               raw + 1 + 4)
216                        return JTOK_ERR;
217                    writer.push_back_u(codepoint);
218                    raw += 4;
219                    break;
220                    }
221                default:
222                    return JTOK_ERR;
223
224                }
225
226                raw++;                        // skip esc'd char
227            }
228
229            else if (*raw == '"') {
230                raw++;                        // skip "
231                break;                        // stop scanning
232            }
233
234            else {
235                writer.push_back(static_cast<unsigned char>(*raw));
236                raw++;
237            }
238        }
239
240        if (!writer.finalize())
241            return JTOK_ERR;
242        tokenVal = valStr;
243        consumed = (raw - rawStart);
244        return JTOK_STRING;
245        }
246
247    default:
248        return JTOK_ERR;
249    }
250}