1 /* Copyright (c) 2013, Vsevolod Stakhov
2 * All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are met:
6 * * Redistributions of source code must retain the above copyright
7 * notice, this list of conditions and the following disclaimer.
8 * * Redistributions in binary form must reproduce the above copyright
9 * notice, this list of conditions and the following disclaimer in the
10 * documentation and/or other materials provided with the distribution.
11 *
12 * THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY
13 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
14 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
15 * DISCLAIMED. IN NO EVENT SHALL AUTHOR BE LIABLE FOR ANY
16 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
17 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
18 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
19 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
20 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
21 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
22 */
23
24 #ifndef UCL_INTERNAL_H_
25 #define UCL_INTERNAL_H_
26
27 #ifdef HAVE_CONFIG_H
28 #include "config.h"
29 #else
30 /* Help embedded builds */
31 #define HAVE_SYS_TYPES_H
32 #define HAVE_SYS_MMAN_H
33 #define HAVE_SYS_STAT_H
34 #define HAVE_SYS_PARAM_H
35 #define HAVE_LIMITS_H
36 #define HAVE_FCNTL_H
37 #define HAVE_ERRNO_H
38 #define HAVE_UNISTD_H
39 #define HAVE_CTYPE_H
40 #define HAVE_STDIO_H
41 #define HAVE_STRING_H
42 #define HAVE_FLOAT_H
43 #define HAVE_LIBGEN_H
44 #define HAVE_MATH_H
45 #define HAVE_STDBOOL_H
46 #define HAVE_STDINT_H
47 #define HAVE_STDARG_H
48 #ifndef _WIN32
49 # define HAVE_REGEX_H
50 #endif
51 #endif
52
53 #ifdef HAVE_SYS_TYPES_H
54 #include <sys/types.h>
55 #endif
56
57 #ifdef HAVE_SYS_MMAN_H
58 # ifndef _WIN32
59 # include <sys/mman.h>
60 # endif
61 #endif
62 #ifdef HAVE_SYS_STAT_H
63 #include <sys/stat.h>
64 #endif
65 #ifdef HAVE_SYS_PARAM_H
66 #include <sys/param.h>
67 #endif
68
69 #ifdef HAVE_LIMITS_H
70 #include <limits.h>
71 #endif
72 #ifdef HAVE_FCNTL_H
73 #include <fcntl.h>
74 #endif
75 #ifdef HAVE_ERRNO_H
76 #include <errno.h>
77 #endif
78 #ifdef HAVE_UNISTD_H
79 #include <unistd.h>
80 #endif
81 #ifdef HAVE_CTYPE_H
82 #include <ctype.h>
83 #endif
84 #ifdef HAVE_STDIO_H
85 #include <stdio.h>
86 #endif
87 #ifdef HAVE_STRING_H
88 #include <string.h>
89 #endif
90
91 #include "utlist.h"
92 #include "utstring.h"
93 #include "uthash.h"
94 #include "ucl.h"
95 #include "ucl_hash.h"
96 #include "xxhash.h"
97
98 #ifdef HAVE_OPENSSL
99 #include <openssl/evp.h>
100 #endif
101
102 #ifndef __DECONST
103 #define __DECONST(type, var) ((type)(uintptr_t)(const void *)(var))
104 #endif
105
106 /**
107 * @file rcl_internal.h
108 * Internal structures and functions of UCL library
109 */
110
111 #define UCL_MAX_RECURSION 16
112 #define UCL_TRASH_KEY 0
113 #define UCL_TRASH_VALUE 1
114
115 enum ucl_parser_state {
116 UCL_STATE_INIT = 0,
117 UCL_STATE_OBJECT,
118 UCL_STATE_ARRAY,
119 UCL_STATE_KEY,
120 UCL_STATE_VALUE,
121 UCL_STATE_AFTER_VALUE,
122 UCL_STATE_ARRAY_VALUE,
123 UCL_STATE_SCOMMENT,
124 UCL_STATE_MCOMMENT,
125 UCL_STATE_MACRO_NAME,
126 UCL_STATE_MACRO,
127 UCL_STATE_ERROR
128 };
129
130 enum ucl_character_type {
131 UCL_CHARACTER_DENIED = 0,
132 UCL_CHARACTER_KEY = 1,
133 UCL_CHARACTER_KEY_START = 1 << 1,
134 UCL_CHARACTER_WHITESPACE = 1 << 2,
135 UCL_CHARACTER_WHITESPACE_UNSAFE = 1 << 3,
136 UCL_CHARACTER_VALUE_END = 1 << 4,
137 UCL_CHARACTER_VALUE_STR = 1 << 5,
138 UCL_CHARACTER_VALUE_DIGIT = 1 << 6,
139 UCL_CHARACTER_VALUE_DIGIT_START = 1 << 7,
140 UCL_CHARACTER_ESCAPE = 1 << 8,
141 UCL_CHARACTER_KEY_SEP = 1 << 9,
142 UCL_CHARACTER_JSON_UNSAFE = 1 << 10,
143 UCL_CHARACTER_UCL_UNSAFE = 1 << 11
144 };
145
146 struct ucl_macro {
147 char *name;
148 ucl_macro_handler handler;
149 void* ud;
150 UT_hash_handle hh;
151 };
152
153 struct ucl_stack {
154 ucl_object_t *obj;
155 struct ucl_stack *next;
156 int level;
157 };
158
159 struct ucl_chunk {
160 const unsigned char *begin;
161 const unsigned char *end;
162 const unsigned char *pos;
163 size_t remain;
164 unsigned int line;
165 unsigned int column;
166 struct ucl_chunk *next;
167 };
168
169 #ifdef HAVE_OPENSSL
170 struct ucl_pubkey {
171 EVP_PKEY *key;
172 struct ucl_pubkey *next;
173 };
174 #else
175 struct ucl_pubkey {
176 struct ucl_pubkey *next;
177 };
178 #endif
179
180 struct ucl_variable {
181 char *var;
182 char *value;
183 size_t var_len;
184 size_t value_len;
185 struct ucl_variable *next;
186 };
187
188 struct ucl_parser {
189 enum ucl_parser_state state;
190 enum ucl_parser_state prev_state;
191 unsigned int recursion;
192 int flags;
193 ucl_object_t *top_obj;
194 ucl_object_t *cur_obj;
195 struct ucl_macro *macroes;
196 struct ucl_stack *stack;
197 struct ucl_chunk *chunks;
198 struct ucl_pubkey *keys;
199 struct ucl_variable *variables;
200 ucl_variable_handler var_handler;
201 void *var_data;
202 UT_string *err;
203 };
204
205 /**
206 * Unescape json string inplace
207 * @param str
208 */
209 size_t ucl_unescape_json_string (char *str, size_t len);
210
211 /**
212 * Handle include macro
213 * @param data include data
214 * @param len length of data
215 * @param ud user data
216 * @param err error ptr
217 * @return
218 */
219 bool ucl_include_handler (const unsigned char *data, size_t len, void* ud);
220
221 bool ucl_try_include_handler (const unsigned char *data, size_t len, void* ud);
222
223 /**
224 * Handle includes macro
225 * @param data include data
226 * @param len length of data
227 * @param ud user data
228 * @param err error ptr
229 * @return
230 */
231 bool ucl_includes_handler (const unsigned char *data, size_t len, void* ud);
232
233 size_t ucl_strlcpy (char *dst, const char *src, size_t siz);
234 size_t ucl_strlcpy_unsafe (char *dst, const char *src, size_t siz);
235 size_t ucl_strlcpy_tolower (char *dst, const char *src, size_t siz);
236
237
238 #ifdef __GNUC__
239 static inline void
240 ucl_create_err (UT_string **err, const char *fmt, ...)
241 __attribute__ (( format( printf, 2, 3) ));
242 #endif
243
244 static inline void
ucl_create_err(UT_string ** err,const char * fmt,...)245 ucl_create_err (UT_string **err, const char *fmt, ...)
246
247 {
248 if (*err == NULL) {
249 utstring_new (*err);
250 va_list ap;
251 va_start (ap, fmt);
252 utstring_printf_va (*err, fmt, ap);
253 va_end (ap);
254 }
255 }
256
257 /**
258 * Check whether a given string contains a boolean value
259 * @param obj object to set
260 * @param start start of a string
261 * @param len length of a string
262 * @return true if a string is a boolean value
263 */
264 static inline bool
ucl_maybe_parse_boolean(ucl_object_t * obj,const unsigned char * start,size_t len)265 ucl_maybe_parse_boolean (ucl_object_t *obj, const unsigned char *start, size_t len)
266 {
267 const unsigned char *p = start;
268 bool ret = false, val = false;
269
270 if (len == 5) {
271 if ((p[0] == 'f' || p[0] == 'F') && strncasecmp (p, "false", 5) == 0) {
272 ret = true;
273 val = false;
274 }
275 }
276 else if (len == 4) {
277 if ((p[0] == 't' || p[0] == 'T') && strncasecmp (p, "true", 4) == 0) {
278 ret = true;
279 val = true;
280 }
281 }
282 else if (len == 3) {
283 if ((p[0] == 'y' || p[0] == 'Y') && strncasecmp (p, "yes", 3) == 0) {
284 ret = true;
285 val = true;
286 }
287 else if ((p[0] == 'o' || p[0] == 'O') && strncasecmp (p, "off", 3) == 0) {
288 ret = true;
289 val = false;
290 }
291 }
292 else if (len == 2) {
293 if ((p[0] == 'n' || p[0] == 'N') && strncasecmp (p, "no", 2) == 0) {
294 ret = true;
295 val = false;
296 }
297 else if ((p[0] == 'o' || p[0] == 'O') && strncasecmp (p, "on", 2) == 0) {
298 ret = true;
299 val = true;
300 }
301 }
302
303 if (ret) {
304 obj->type = UCL_BOOLEAN;
305 obj->value.iv = val;
306 }
307
308 return ret;
309 }
310
311 /**
312 * Check numeric string
313 * @param obj object to set if a string is numeric
314 * @param start start of string
315 * @param end end of string
316 * @param pos position where parsing has stopped
317 * @param allow_double allow parsing of floating point values
318 * @return 0 if string is numeric and error code (EINVAL or ERANGE) in case of conversion error
319 */
320 int ucl_maybe_parse_number (ucl_object_t *obj,
321 const char *start, const char *end, const char **pos,
322 bool allow_double, bool number_bytes, bool allow_time);
323
324
325 static inline const ucl_object_t *
ucl_hash_search_obj(ucl_hash_t * hashlin,ucl_object_t * obj)326 ucl_hash_search_obj (ucl_hash_t* hashlin, ucl_object_t *obj)
327 {
328 return (const ucl_object_t *)ucl_hash_search (hashlin, obj->key, obj->keylen);
329 }
330
331 static inline ucl_hash_t *
332 ucl_hash_insert_object (ucl_hash_t *hashlin, const ucl_object_t *obj) UCL_WARN_UNUSED_RESULT;
333
334 static inline ucl_hash_t *
ucl_hash_insert_object(ucl_hash_t * hashlin,const ucl_object_t * obj)335 ucl_hash_insert_object (ucl_hash_t *hashlin, const ucl_object_t *obj)
336 {
337 if (hashlin == NULL) {
338 hashlin = ucl_hash_create ();
339 }
340 ucl_hash_insert (hashlin, obj, obj->key, obj->keylen);
341
342 return hashlin;
343 }
344
345 /**
346 * Emit a single object to string
347 * @param obj
348 * @return
349 */
350 unsigned char * ucl_object_emit_single_json (const ucl_object_t *obj);
351
352 #endif /* UCL_INTERNAL_H_ */
353