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 97 #ifdef HAVE_OPENSSL 98 #include <openssl/evp.h> 99 #endif 100 101 #ifndef __DECONST 102 #define __DECONST(type, var) ((type)(uintptr_t)(const void *)(var)) 103 #endif 104 105 /** 106 * @file rcl_internal.h 107 * Internal structures and functions of UCL library 108 */ 109 110 #define UCL_MAX_RECURSION 16 111 #define UCL_TRASH_KEY 0 112 #define UCL_TRASH_VALUE 1 113 114 enum ucl_parser_state { 115 UCL_STATE_INIT = 0, 116 UCL_STATE_OBJECT, 117 UCL_STATE_ARRAY, 118 UCL_STATE_KEY, 119 UCL_STATE_VALUE, 120 UCL_STATE_AFTER_VALUE, 121 UCL_STATE_ARRAY_VALUE, 122 UCL_STATE_SCOMMENT, 123 UCL_STATE_MCOMMENT, 124 UCL_STATE_MACRO_NAME, 125 UCL_STATE_MACRO, 126 UCL_STATE_ERROR 127 }; 128 129 enum ucl_character_type { 130 UCL_CHARACTER_DENIED = 0, 131 UCL_CHARACTER_KEY = 1, 132 UCL_CHARACTER_KEY_START = 1 << 1, 133 UCL_CHARACTER_WHITESPACE = 1 << 2, 134 UCL_CHARACTER_WHITESPACE_UNSAFE = 1 << 3, 135 UCL_CHARACTER_VALUE_END = 1 << 4, 136 UCL_CHARACTER_VALUE_STR = 1 << 5, 137 UCL_CHARACTER_VALUE_DIGIT = 1 << 6, 138 UCL_CHARACTER_VALUE_DIGIT_START = 1 << 7, 139 UCL_CHARACTER_ESCAPE = 1 << 8, 140 UCL_CHARACTER_KEY_SEP = 1 << 9, 141 UCL_CHARACTER_JSON_UNSAFE = 1 << 10, 142 UCL_CHARACTER_UCL_UNSAFE = 1 << 11 143 }; 144 145 struct ucl_macro { 146 char *name; 147 union { 148 ucl_macro_handler handler; 149 ucl_context_macro_handler context_handler; 150 } h; 151 void* ud; 152 bool is_context; 153 UT_hash_handle hh; 154 }; 155 156 struct ucl_stack { 157 ucl_object_t *obj; 158 struct ucl_stack *next; 159 uint64_t level; 160 }; 161 162 struct ucl_chunk { 163 const unsigned char *begin; 164 const unsigned char *end; 165 const unsigned char *pos; 166 size_t remain; 167 unsigned int line; 168 unsigned int column; 169 unsigned priority; 170 enum ucl_duplicate_strategy strategy; 171 enum ucl_parse_type parse_type; 172 struct ucl_chunk *next; 173 }; 174 175 #ifdef HAVE_OPENSSL 176 struct ucl_pubkey { 177 EVP_PKEY *key; 178 struct ucl_pubkey *next; 179 }; 180 #else 181 struct ucl_pubkey { 182 struct ucl_pubkey *next; 183 }; 184 #endif 185 186 struct ucl_variable { 187 char *var; 188 char *value; 189 size_t var_len; 190 size_t value_len; 191 struct ucl_variable *prev, *next; 192 }; 193 194 struct ucl_parser { 195 enum ucl_parser_state state; 196 enum ucl_parser_state prev_state; 197 unsigned int recursion; 198 int flags; 199 unsigned default_priority; 200 int err_code; 201 ucl_object_t *top_obj; 202 ucl_object_t *cur_obj; 203 ucl_object_t *trash_objs; 204 ucl_object_t *includepaths; 205 char *cur_file; 206 struct ucl_macro *macroes; 207 struct ucl_stack *stack; 208 struct ucl_chunk *chunks; 209 struct ucl_pubkey *keys; 210 struct ucl_variable *variables; 211 ucl_variable_handler var_handler; 212 void *var_data; 213 ucl_object_t *comments; 214 ucl_object_t *last_comment; 215 UT_string *err; 216 }; 217 218 struct ucl_object_userdata { 219 ucl_object_t obj; 220 ucl_userdata_dtor dtor; 221 ucl_userdata_emitter emitter; 222 }; 223 224 /** 225 * Unescape json string inplace 226 * @param str 227 */ 228 size_t ucl_unescape_json_string (char *str, size_t len); 229 230 /** 231 * Handle include macro 232 * @param data include data 233 * @param len length of data 234 * @param args UCL object representing arguments to the macro 235 * @param ud user data 236 * @return 237 */ 238 bool ucl_include_handler (const unsigned char *data, size_t len, 239 const ucl_object_t *args, void* ud); 240 241 /** 242 * Handle tryinclude macro 243 * @param data include data 244 * @param len length of data 245 * @param args UCL object representing arguments to the macro 246 * @param ud user data 247 * @return 248 */ 249 bool ucl_try_include_handler (const unsigned char *data, size_t len, 250 const ucl_object_t *args, void* ud); 251 252 /** 253 * Handle includes macro 254 * @param data include data 255 * @param len length of data 256 * @param args UCL object representing arguments to the macro 257 * @param ud user data 258 * @return 259 */ 260 bool ucl_includes_handler (const unsigned char *data, size_t len, 261 const ucl_object_t *args, void* ud); 262 263 /** 264 * Handle priority macro 265 * @param data include data 266 * @param len length of data 267 * @param args UCL object representing arguments to the macro 268 * @param ud user data 269 * @return 270 */ 271 bool ucl_priority_handler (const unsigned char *data, size_t len, 272 const ucl_object_t *args, void* ud); 273 274 /** 275 * Handle load macro 276 * @param data include data 277 * @param len length of data 278 * @param args UCL object representing arguments to the macro 279 * @param ud user data 280 * @return 281 */ 282 bool ucl_load_handler (const unsigned char *data, size_t len, 283 const ucl_object_t *args, void* ud); 284 /** 285 * Handle inherit macro 286 * @param data include data 287 * @param len length of data 288 * @param args UCL object representing arguments to the macro 289 * @param ctx the current context object 290 * @param ud user data 291 * @return 292 */ 293 bool ucl_inherit_handler (const unsigned char *data, size_t len, 294 const ucl_object_t *args, const ucl_object_t *ctx, void* ud); 295 296 size_t ucl_strlcpy (char *dst, const char *src, size_t siz); 297 size_t ucl_strlcpy_unsafe (char *dst, const char *src, size_t siz); 298 size_t ucl_strlcpy_tolower (char *dst, const char *src, size_t siz); 299 300 char *ucl_strnstr (const char *s, const char *find, int len); 301 char *ucl_strncasestr (const char *s, const char *find, int len); 302 303 #ifdef __GNUC__ 304 static inline void 305 ucl_create_err (UT_string **err, const char *fmt, ...) 306 __attribute__ (( format( printf, 2, 3) )); 307 #endif 308 309 #undef UCL_FATAL_ERRORS 310 311 static inline void 312 ucl_create_err (UT_string **err, const char *fmt, ...) 313 { 314 if (*err == NULL) { 315 utstring_new (*err); 316 va_list ap; 317 va_start (ap, fmt); 318 utstring_printf_va (*err, fmt, ap); 319 va_end (ap); 320 } 321 322 #ifdef UCL_FATAL_ERRORS 323 assert (0); 324 #endif 325 } 326 327 /** 328 * Check whether a given string contains a boolean value 329 * @param obj object to set 330 * @param start start of a string 331 * @param len length of a string 332 * @return true if a string is a boolean value 333 */ 334 static inline bool 335 ucl_maybe_parse_boolean (ucl_object_t *obj, const unsigned char *start, size_t len) 336 { 337 const char *p = (const char *)start; 338 bool ret = false, val = false; 339 340 if (len == 5) { 341 if ((p[0] == 'f' || p[0] == 'F') && strncasecmp (p, "false", 5) == 0) { 342 ret = true; 343 val = false; 344 } 345 } 346 else if (len == 4) { 347 if ((p[0] == 't' || p[0] == 'T') && strncasecmp (p, "true", 4) == 0) { 348 ret = true; 349 val = true; 350 } 351 } 352 else if (len == 3) { 353 if ((p[0] == 'y' || p[0] == 'Y') && strncasecmp (p, "yes", 3) == 0) { 354 ret = true; 355 val = true; 356 } 357 else if ((p[0] == 'o' || p[0] == 'O') && strncasecmp (p, "off", 3) == 0) { 358 ret = true; 359 val = false; 360 } 361 } 362 else if (len == 2) { 363 if ((p[0] == 'n' || p[0] == 'N') && strncasecmp (p, "no", 2) == 0) { 364 ret = true; 365 val = false; 366 } 367 else if ((p[0] == 'o' || p[0] == 'O') && strncasecmp (p, "on", 2) == 0) { 368 ret = true; 369 val = true; 370 } 371 } 372 373 if (ret && obj != NULL) { 374 obj->type = UCL_BOOLEAN; 375 obj->value.iv = val; 376 } 377 378 return ret; 379 } 380 381 /** 382 * Check numeric string 383 * @param obj object to set if a string is numeric 384 * @param start start of string 385 * @param end end of string 386 * @param pos position where parsing has stopped 387 * @param allow_double allow parsing of floating point values 388 * @return 0 if string is numeric and error code (EINVAL or ERANGE) in case of conversion error 389 */ 390 int ucl_maybe_parse_number (ucl_object_t *obj, 391 const char *start, const char *end, const char **pos, 392 bool allow_double, bool number_bytes, bool allow_time); 393 394 395 static inline const ucl_object_t * 396 ucl_hash_search_obj (ucl_hash_t* hashlin, ucl_object_t *obj) 397 { 398 return (const ucl_object_t *)ucl_hash_search (hashlin, obj->key, obj->keylen); 399 } 400 401 static inline ucl_hash_t * ucl_hash_insert_object (ucl_hash_t *hashlin, 402 const ucl_object_t *obj, 403 bool ignore_case) UCL_WARN_UNUSED_RESULT; 404 405 static inline ucl_hash_t * 406 ucl_hash_insert_object (ucl_hash_t *hashlin, 407 const ucl_object_t *obj, 408 bool ignore_case) 409 { 410 if (hashlin == NULL) { 411 hashlin = ucl_hash_create (ignore_case); 412 } 413 ucl_hash_insert (hashlin, obj, obj->key, obj->keylen); 414 415 return hashlin; 416 } 417 418 /** 419 * Get standard emitter context for a specified emit_type 420 * @param emit_type type of emitter 421 * @return context or NULL if input is invalid 422 */ 423 const struct ucl_emitter_context * 424 ucl_emit_get_standard_context (enum ucl_emitter emit_type); 425 426 /** 427 * Serialize string as JSON string 428 * @param str string to emit 429 * @param buf target buffer 430 */ 431 void ucl_elt_string_write_json (const char *str, size_t size, 432 struct ucl_emitter_context *ctx); 433 434 /** 435 * Write multiline string using `EOD` as string terminator 436 * @param str 437 * @param size 438 * @param ctx 439 */ 440 void ucl_elt_string_write_multiline (const char *str, size_t size, 441 struct ucl_emitter_context *ctx); 442 443 /** 444 * Emit a single object to string 445 * @param obj 446 * @return 447 */ 448 unsigned char * ucl_object_emit_single_json (const ucl_object_t *obj); 449 450 /** 451 * Check whether a specified string is long and should be likely printed in 452 * multiline mode 453 * @param obj 454 * @return 455 */ 456 bool ucl_maybe_long_string (const ucl_object_t *obj); 457 458 /** 459 * Print integer to the msgpack output 460 * @param ctx 461 * @param val 462 */ 463 void ucl_emitter_print_int_msgpack (struct ucl_emitter_context *ctx, 464 int64_t val); 465 /** 466 * Print integer to the msgpack output 467 * @param ctx 468 * @param val 469 */ 470 void ucl_emitter_print_double_msgpack (struct ucl_emitter_context *ctx, 471 double val); 472 /** 473 * Print double to the msgpack output 474 * @param ctx 475 * @param val 476 */ 477 void ucl_emitter_print_bool_msgpack (struct ucl_emitter_context *ctx, 478 bool val); 479 /** 480 * Print string to the msgpack output 481 * @param ctx 482 * @param s 483 * @param len 484 */ 485 void ucl_emitter_print_string_msgpack (struct ucl_emitter_context *ctx, 486 const char *s, size_t len); 487 488 /** 489 * Print binary string to the msgpack output 490 * @param ctx 491 * @param s 492 * @param len 493 */ 494 void ucl_emitter_print_binary_string_msgpack (struct ucl_emitter_context *ctx, 495 const char *s, size_t len); 496 497 /** 498 * Print array preamble for msgpack 499 * @param ctx 500 * @param len 501 */ 502 void ucl_emitter_print_array_msgpack (struct ucl_emitter_context *ctx, 503 size_t len); 504 505 /** 506 * Print object preamble for msgpack 507 * @param ctx 508 * @param len 509 */ 510 void ucl_emitter_print_object_msgpack (struct ucl_emitter_context *ctx, 511 size_t len); 512 /** 513 * Print NULL to the msgpack output 514 * @param ctx 515 */ 516 void ucl_emitter_print_null_msgpack (struct ucl_emitter_context *ctx); 517 /** 518 * Print object's key if needed to the msgpack output 519 * @param print_key 520 * @param ctx 521 * @param obj 522 */ 523 void ucl_emitter_print_key_msgpack (bool print_key, 524 struct ucl_emitter_context *ctx, 525 const ucl_object_t *obj); 526 527 /** 528 * Fetch URL into a buffer 529 * @param url url to fetch 530 * @param buf pointer to buffer (must be freed by callee) 531 * @param buflen pointer to buffer length 532 * @param err pointer to error argument 533 * @param must_exist fail if cannot find a url 534 */ 535 bool ucl_fetch_url (const unsigned char *url, 536 unsigned char **buf, 537 size_t *buflen, 538 UT_string **err, 539 bool must_exist); 540 541 /** 542 * Fetch a file and save results to the memory buffer 543 * @param filename filename to fetch 544 * @param len length of filename 545 * @param buf target buffer 546 * @param buflen target length 547 * @return 548 */ 549 bool ucl_fetch_file (const unsigned char *filename, 550 unsigned char **buf, 551 size_t *buflen, 552 UT_string **err, 553 bool must_exist); 554 555 /** 556 * Add new element to an object using the current merge strategy and priority 557 * @param parser 558 * @param nobj 559 * @return 560 */ 561 bool ucl_parser_process_object_element (struct ucl_parser *parser, 562 ucl_object_t *nobj); 563 564 /** 565 * Parse msgpack chunk 566 * @param parser 567 * @return 568 */ 569 bool ucl_parse_msgpack (struct ucl_parser *parser); 570 571 #endif /* UCL_INTERNAL_H_ */ 572