1 /* Copyright (c) 2013, Vsevolod Stakhov 2 * Copyright (c) 2015 Allan Jude <allanjude@freebsd.org> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions are met: 7 * * Redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer. 9 * * Redistributions in binary form must reproduce the above copyright 10 * notice, this list of conditions and the following disclaimer in the 11 * documentation and/or other materials provided with the distribution. 12 * 13 * THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY 14 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 15 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 16 * DISCLAIMED. IN NO EVENT SHALL AUTHOR BE LIABLE FOR ANY 17 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 18 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 19 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 20 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 21 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 22 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 23 */ 24 25 #include "ucl.h" 26 #include "ucl_internal.h" 27 #include "ucl_chartable.h" 28 #include "kvec.h" 29 #include <limits.h> 30 #include <stdarg.h> 31 #include <stdio.h> /* for snprintf */ 32 33 #ifndef _WIN32 34 #include <glob.h> 35 #include <sys/param.h> 36 #else 37 #ifndef NBBY 38 #define NBBY 8 39 #endif 40 #endif 41 42 #ifdef HAVE_LIBGEN_H 43 #ifndef _WIN32 44 #include <libgen.h> /* For dirname */ 45 #endif 46 #endif 47 48 typedef kvec_t(ucl_object_t *) ucl_array_t; 49 50 #define UCL_ARRAY_GET(ar, obj) ucl_array_t *ar = \ 51 (ucl_array_t *) ((obj) != NULL ? (obj)->value.av : NULL) 52 53 #ifdef HAVE_OPENSSL 54 #include <openssl/err.h> 55 #include <openssl/sha.h> 56 #include <openssl/rsa.h> 57 #include <openssl/ssl.h> 58 #include <openssl/evp.h> 59 #endif 60 61 #ifdef CURL_FOUND 62 /* Seems to be broken */ 63 #define CURL_DISABLE_TYPECHECK 1 64 #include <curl/curl.h> 65 #endif 66 #ifdef HAVE_FETCH_H 67 #include <fetch.h> 68 #endif 69 70 #if defined(_WIN32) 71 #include <windows.h> 72 #include <io.h> 73 #include <direct.h> 74 75 #ifndef PROT_READ 76 #define PROT_READ 1 77 #endif 78 #ifndef PROT_WRITE 79 #define PROT_WRITE 2 80 #endif 81 #ifndef PROT_READWRITE 82 #define PROT_READWRITE 3 83 #endif 84 #ifndef MAP_SHARED 85 #define MAP_SHARED 1 86 #endif 87 #ifndef MAP_PRIVATE 88 #define MAP_PRIVATE 2 89 #endif 90 #ifndef MAP_FAILED 91 #define MAP_FAILED ((void *) -1) 92 #endif 93 94 #define getcwd _getcwd 95 #define open _open 96 #define close _close 97 98 static void *ucl_mmap(char *addr, size_t length, int prot, int access, int fd, off_t offset) 99 { 100 void *map = NULL; 101 HANDLE handle = INVALID_HANDLE_VALUE; 102 103 switch (prot) { 104 default: 105 case PROT_READ: { 106 handle = CreateFileMapping((HANDLE) _get_osfhandle(fd), 0, PAGE_READONLY, 0, length, 0); 107 if (!handle) break; 108 map = (void *) MapViewOfFile(handle, FILE_MAP_READ, 0, 0, length); 109 CloseHandle(handle); 110 break; 111 } 112 case PROT_WRITE: { 113 handle = CreateFileMapping((HANDLE) _get_osfhandle(fd), 0, PAGE_READWRITE, 0, length, 0); 114 if (!handle) break; 115 map = (void *) MapViewOfFile(handle, FILE_MAP_WRITE, 0, 0, length); 116 CloseHandle(handle); 117 break; 118 } 119 case PROT_READWRITE: { 120 handle = CreateFileMapping((HANDLE) _get_osfhandle(fd), 0, PAGE_READWRITE, 0, length, 0); 121 if (!handle) break; 122 map = (void *) MapViewOfFile(handle, FILE_MAP_ALL_ACCESS, 0, 0, length); 123 CloseHandle(handle); 124 break; 125 } 126 } 127 if (map == (void *) NULL) { 128 return (void *) MAP_FAILED; 129 } 130 return (void *) ((char *) map + offset); 131 } 132 133 static int ucl_munmap(void *map, size_t length) 134 { 135 if (!UnmapViewOfFile(map)) { 136 return (-1); 137 } 138 return (0); 139 } 140 141 static char *ucl_realpath(const char *path, char *resolved_path) 142 { 143 char *p; 144 char tmp[MAX_PATH + 1]; 145 strncpy(tmp, path, sizeof(tmp) - 1); 146 p = tmp; 147 while (*p) { 148 if (*p == '/') *p = '\\'; 149 p++; 150 } 151 return _fullpath(resolved_path, tmp, MAX_PATH); 152 } 153 154 155 char *dirname(char *path) 156 { 157 static char path_buffer[_MAX_PATH]; 158 char drive[_MAX_DRIVE]; 159 char dir[_MAX_DIR]; 160 char fname[_MAX_FNAME]; 161 char ext[_MAX_EXT]; 162 163 _splitpath(path, drive, dir, fname, ext); 164 _makepath(path_buffer, drive, dir, NULL, NULL); 165 166 return path_buffer; 167 } 168 169 char *basename(char *path) 170 { 171 static char path_buffer[_MAX_PATH]; 172 char drive[_MAX_DRIVE]; 173 char dir[_MAX_DIR]; 174 char fname[_MAX_FNAME]; 175 char ext[_MAX_EXT]; 176 177 _splitpath(path, drive, dir, fname, ext); 178 _makepath(path_buffer, NULL, NULL, fname, ext); 179 180 return path_buffer; 181 } 182 #else 183 #define ucl_mmap mmap 184 #define ucl_munmap munmap 185 #define ucl_realpath realpath 186 #endif 187 188 typedef void (*ucl_object_dtor)(ucl_object_t *obj); 189 static void ucl_object_free_internal(ucl_object_t *obj, bool allow_rec, 190 ucl_object_dtor dtor); 191 static void ucl_object_dtor_unref(ucl_object_t *obj); 192 193 static void 194 ucl_object_dtor_free(ucl_object_t *obj) 195 { 196 if (obj->trash_stack[UCL_TRASH_KEY] != NULL) { 197 UCL_FREE(obj->hh.keylen, obj->trash_stack[UCL_TRASH_KEY]); 198 } 199 if (obj->trash_stack[UCL_TRASH_VALUE] != NULL) { 200 UCL_FREE(obj->len, obj->trash_stack[UCL_TRASH_VALUE]); 201 } 202 /* Do not free ephemeral objects */ 203 if ((obj->flags & UCL_OBJECT_EPHEMERAL) == 0) { 204 if (obj->type != UCL_USERDATA) { 205 UCL_FREE(sizeof(ucl_object_t), obj); 206 } 207 else { 208 struct ucl_object_userdata *ud = (struct ucl_object_userdata *) obj; 209 if (ud->dtor) { 210 ud->dtor(obj->value.ud); 211 } 212 UCL_FREE(sizeof(*ud), obj); 213 } 214 } 215 } 216 217 /* 218 * This is a helper function that performs exactly the same as 219 * `ucl_object_unref` but it doesn't iterate over elements allowing 220 * to use it for individual elements of arrays and multiple values 221 */ 222 static void 223 ucl_object_dtor_unref_single(ucl_object_t *obj) 224 { 225 if (obj != NULL) { 226 #ifdef HAVE_ATOMIC_BUILTINS 227 unsigned int rc = __sync_sub_and_fetch(&obj->ref, 1); 228 if (rc == 0) { 229 #else 230 if (--obj->ref == 0) { 231 #endif 232 ucl_object_free_internal(obj, false, ucl_object_dtor_unref); 233 } 234 } 235 } 236 237 static void 238 ucl_object_dtor_unref(ucl_object_t *obj) 239 { 240 if (obj->ref == 0) { 241 ucl_object_dtor_free(obj); 242 } 243 else { 244 /* This may cause dtor unref being called one more time */ 245 ucl_object_dtor_unref_single(obj); 246 } 247 } 248 249 static void 250 ucl_object_free_internal(ucl_object_t *obj, bool allow_rec, ucl_object_dtor dtor) 251 { 252 ucl_object_t *tmp, *sub; 253 254 while (obj != NULL) { 255 if (obj->type == UCL_ARRAY) { 256 UCL_ARRAY_GET(vec, obj); 257 unsigned int i; 258 259 if (vec != NULL) { 260 for (i = 0; i < vec->n; i++) { 261 sub = kv_A(*vec, i); 262 if (sub != NULL) { 263 tmp = sub; 264 while (sub) { 265 tmp = sub->next; 266 dtor(sub); 267 sub = tmp; 268 } 269 } 270 } 271 kv_destroy(*vec); 272 UCL_FREE(sizeof(*vec), vec); 273 } 274 obj->value.av = NULL; 275 } 276 else if (obj->type == UCL_OBJECT) { 277 if (obj->value.ov != NULL) { 278 ucl_hash_destroy(obj->value.ov, (ucl_hash_free_func) dtor); 279 } 280 obj->value.ov = NULL; 281 } 282 tmp = obj->next; 283 dtor(obj); 284 obj = tmp; 285 286 if (!allow_rec) { 287 break; 288 } 289 } 290 } 291 292 void ucl_object_free(ucl_object_t *obj) 293 { 294 ucl_object_free_internal(obj, true, ucl_object_dtor_free); 295 } 296 297 size_t 298 ucl_unescape_json_string(char *str, size_t len) 299 { 300 char *t = str, *h = str; 301 int i, uval; 302 303 if (len <= 1) { 304 return len; 305 } 306 /* t is target (tortoise), h is source (hare) */ 307 308 while (len) { 309 if (*h == '\\') { 310 h++; 311 312 if (len == 1) { 313 /* 314 * If \ is last, then do not try to go further 315 * Issue: #74 316 */ 317 len--; 318 *t++ = '\\'; 319 continue; 320 } 321 322 switch (*h) { 323 case 'n': 324 *t++ = '\n'; 325 break; 326 case 'r': 327 *t++ = '\r'; 328 break; 329 case 'b': 330 *t++ = '\b'; 331 break; 332 case 't': 333 *t++ = '\t'; 334 break; 335 case 'f': 336 *t++ = '\f'; 337 break; 338 case '\\': 339 *t++ = '\\'; 340 break; 341 case '"': 342 *t++ = '"'; 343 break; 344 case 'u': 345 /* Unicode escape */ 346 uval = 0; 347 h++; /* u character */ 348 len--; 349 350 if (len > 3) { 351 for (i = 0; i < 4; i++) { 352 uval <<= 4; 353 if (isdigit(h[i])) { 354 uval += h[i] - '0'; 355 } 356 else if (h[i] >= 'a' && h[i] <= 'f') { 357 uval += h[i] - 'a' + 10; 358 } 359 else if (h[i] >= 'A' && h[i] <= 'F') { 360 uval += h[i] - 'A' + 10; 361 } 362 else { 363 break; 364 } 365 } 366 367 /* Encode */ 368 if (uval < 0x80) { 369 t[0] = (char) uval; 370 t++; 371 } 372 else if (uval < 0x800) { 373 t[0] = 0xC0 + ((uval & 0x7C0) >> 6); 374 t[1] = 0x80 + ((uval & 0x03F)); 375 t += 2; 376 } 377 else if (uval < 0x10000) { 378 t[0] = 0xE0 + ((uval & 0xF000) >> 12); 379 t[1] = 0x80 + ((uval & 0x0FC0) >> 6); 380 t[2] = 0x80 + ((uval & 0x003F)); 381 t += 3; 382 } 383 #if 0 384 /* It's not actually supported now */ 385 else if(uval <= 0x10FFFF) { 386 t[0] = 0xF0 + ((uval & 0x1C0000) >> 18); 387 t[1] = 0x80 + ((uval & 0x03F000) >> 12); 388 t[2] = 0x80 + ((uval & 0x000FC0) >> 6); 389 t[3] = 0x80 + ((uval & 0x00003F)); 390 t += 4; 391 } 392 #endif 393 else { 394 *t++ = '?'; 395 } 396 397 /* Consume 4 characters of source */ 398 h += 4; 399 len -= 4; 400 401 if (len > 0) { 402 len--; /* for '\' character */ 403 } 404 continue; 405 } 406 else { 407 *t++ = 'u'; 408 } 409 break; 410 default: 411 *t++ = *h; 412 break; 413 } 414 h++; 415 len--; 416 } 417 else { 418 *t++ = *h++; 419 } 420 421 if (len > 0) { 422 len--; 423 } 424 } 425 *t = '\0'; 426 427 return (t - str); 428 } 429 430 size_t 431 ucl_unescape_squoted_string(char *str, size_t len) 432 { 433 char *t = str, *h = str; 434 435 if (len <= 1) { 436 return len; 437 } 438 439 /* t is target (tortoise), h is source (hare) */ 440 441 while (len) { 442 if (*h == '\\') { 443 h++; 444 445 if (len == 1) { 446 /* 447 * If \ is last, then do not try to go further 448 * Issue: #74 449 */ 450 len--; 451 *t++ = '\\'; 452 continue; 453 } 454 455 switch (*h) { 456 case '\'': 457 *t++ = '\''; 458 break; 459 case '\n': 460 /* Ignore \<newline> style stuff */ 461 break; 462 case '\r': 463 /* Ignore \r and the following \n if needed */ 464 if (len > 1 && h[1] == '\n') { 465 h++; 466 len--; 467 } 468 break; 469 default: 470 /* Ignore \ */ 471 *t++ = '\\'; 472 *t++ = *h; 473 break; 474 } 475 476 h++; 477 len--; 478 } 479 else { 480 *t++ = *h++; 481 } 482 483 if (len > 0) { 484 len--; 485 } 486 } 487 488 *t = '\0'; 489 490 return (t - str); 491 } 492 493 char * 494 ucl_copy_key_trash(const ucl_object_t *obj) 495 { 496 ucl_object_t *deconst; 497 498 if (obj == NULL) { 499 return NULL; 500 } 501 if (obj->trash_stack[UCL_TRASH_KEY] == NULL && obj->key != NULL) { 502 deconst = __DECONST(ucl_object_t *, obj); 503 deconst->trash_stack[UCL_TRASH_KEY] = malloc(obj->keylen + 1); 504 if (deconst->trash_stack[UCL_TRASH_KEY] != NULL) { 505 memcpy(deconst->trash_stack[UCL_TRASH_KEY], obj->key, obj->keylen); 506 deconst->trash_stack[UCL_TRASH_KEY][obj->keylen] = '\0'; 507 } 508 deconst->key = obj->trash_stack[UCL_TRASH_KEY]; 509 deconst->flags |= UCL_OBJECT_ALLOCATED_KEY; 510 } 511 512 return obj->trash_stack[UCL_TRASH_KEY]; 513 } 514 515 void ucl_chunk_free(struct ucl_chunk *chunk) 516 { 517 if (chunk) { 518 struct ucl_parser_special_handler_chain *chain, *tmp; 519 520 LL_FOREACH_SAFE(chunk->special_handlers, chain, tmp) 521 { 522 if (chain->special_handler->free_function) { 523 chain->special_handler->free_function( 524 chain->begin, 525 chain->len, 526 chain->special_handler->user_data); 527 } 528 else { 529 UCL_FREE(chain->len, chain->begin); 530 } 531 532 UCL_FREE(sizeof(*chain), chain); 533 } 534 535 chunk->special_handlers = NULL; 536 537 if (chunk->fname) { 538 free(chunk->fname); 539 } 540 541 UCL_FREE(sizeof(*chunk), chunk); 542 } 543 } 544 545 char * 546 ucl_copy_value_trash(const ucl_object_t *obj) 547 { 548 ucl_object_t *deconst; 549 550 if (obj == NULL) { 551 return NULL; 552 } 553 if (obj->trash_stack[UCL_TRASH_VALUE] == NULL) { 554 deconst = __DECONST(ucl_object_t *, obj); 555 if (obj->type == UCL_STRING) { 556 557 /* Special case for strings */ 558 if (obj->flags & UCL_OBJECT_BINARY) { 559 deconst->trash_stack[UCL_TRASH_VALUE] = malloc(obj->len); 560 if (deconst->trash_stack[UCL_TRASH_VALUE] != NULL) { 561 memcpy(deconst->trash_stack[UCL_TRASH_VALUE], 562 obj->value.sv, 563 obj->len); 564 deconst->value.sv = obj->trash_stack[UCL_TRASH_VALUE]; 565 } 566 } 567 else { 568 deconst->trash_stack[UCL_TRASH_VALUE] = malloc(obj->len + 1); 569 if (deconst->trash_stack[UCL_TRASH_VALUE] != NULL) { 570 memcpy(deconst->trash_stack[UCL_TRASH_VALUE], 571 obj->value.sv, 572 obj->len); 573 deconst->trash_stack[UCL_TRASH_VALUE][obj->len] = '\0'; 574 deconst->value.sv = obj->trash_stack[UCL_TRASH_VALUE]; 575 } 576 } 577 } 578 else { 579 /* Just emit value in json notation */ 580 deconst->trash_stack[UCL_TRASH_VALUE] = ucl_object_emit_single_json(obj); 581 deconst->len = strlen(obj->trash_stack[UCL_TRASH_VALUE]); 582 } 583 deconst->flags |= UCL_OBJECT_ALLOCATED_VALUE; 584 } 585 586 return obj->trash_stack[UCL_TRASH_VALUE]; 587 } 588 589 ucl_object_t * 590 ucl_parser_get_object(struct ucl_parser *parser) 591 { 592 if (parser->state != UCL_STATE_ERROR && parser->top_obj != NULL) { 593 return ucl_object_ref(parser->top_obj); 594 } 595 596 return NULL; 597 } 598 599 void ucl_parser_free(struct ucl_parser *parser) 600 { 601 struct ucl_stack *stack, *stmp; 602 struct ucl_macro *macro, *mtmp; 603 struct ucl_chunk *chunk, *ctmp; 604 struct ucl_pubkey *key, *ktmp; 605 struct ucl_variable *var, *vtmp; 606 ucl_object_t *tr, *trtmp; 607 608 if (parser == NULL) { 609 return; 610 } 611 612 if (parser->top_obj != NULL) { 613 ucl_object_unref(parser->top_obj); 614 } 615 616 if (parser->includepaths != NULL) { 617 ucl_object_unref(parser->includepaths); 618 } 619 620 LL_FOREACH_SAFE(parser->stack, stack, stmp) 621 { 622 free(stack); 623 } 624 HASH_ITER(hh, parser->macroes, macro, mtmp) 625 { 626 free(macro->name); 627 HASH_DEL(parser->macroes, macro); 628 UCL_FREE(sizeof(struct ucl_macro), macro); 629 } 630 LL_FOREACH_SAFE(parser->chunks, chunk, ctmp) 631 { 632 ucl_chunk_free(chunk); 633 } 634 LL_FOREACH_SAFE(parser->keys, key, ktmp) 635 { 636 UCL_FREE(sizeof(struct ucl_pubkey), key); 637 } 638 LL_FOREACH_SAFE(parser->variables, var, vtmp) 639 { 640 free(var->value); 641 free(var->var); 642 UCL_FREE(sizeof(struct ucl_variable), var); 643 } 644 LL_FOREACH_SAFE(parser->trash_objs, tr, trtmp) 645 { 646 ucl_object_free_internal(tr, false, ucl_object_dtor_free); 647 } 648 649 if (parser->err != NULL) { 650 utstring_free(parser->err); 651 } 652 653 if (parser->cur_file) { 654 UCL_FREE(strlen(parser->cur_file) + 1, parser->cur_file); 655 } 656 657 if (parser->comments) { 658 ucl_object_unref(parser->comments); 659 } 660 661 UCL_FREE(sizeof(struct ucl_parser), parser); 662 } 663 664 const char * 665 ucl_parser_get_error(struct ucl_parser *parser) 666 { 667 if (parser == NULL) { 668 return NULL; 669 } 670 671 if (parser->err == NULL) { 672 return NULL; 673 } 674 675 return utstring_body(parser->err); 676 } 677 678 int ucl_parser_get_error_code(struct ucl_parser *parser) 679 { 680 if (parser == NULL) { 681 return 0; 682 } 683 684 return parser->err_code; 685 } 686 687 unsigned 688 ucl_parser_get_column(struct ucl_parser *parser) 689 { 690 if (parser == NULL || parser->chunks == NULL) { 691 return 0; 692 } 693 694 return parser->chunks->column; 695 } 696 697 unsigned 698 ucl_parser_get_linenum(struct ucl_parser *parser) 699 { 700 if (parser == NULL || parser->chunks == NULL) { 701 return 0; 702 } 703 704 return parser->chunks->line; 705 } 706 707 void ucl_parser_clear_error(struct ucl_parser *parser) 708 { 709 if (parser != NULL && parser->err != NULL) { 710 utstring_free(parser->err); 711 parser->err = NULL; 712 parser->err_code = 0; 713 } 714 } 715 716 bool ucl_pubkey_add(struct ucl_parser *parser, const unsigned char *key, size_t len) 717 { 718 #ifndef HAVE_OPENSSL 719 ucl_create_err(&parser->err, "cannot check signatures without openssl"); 720 return false; 721 #else 722 #if (OPENSSL_VERSION_NUMBER < 0x10000000L) 723 ucl_create_err(&parser->err, "cannot check signatures, openssl version is unsupported"); 724 return EXIT_FAILURE; 725 #else 726 struct ucl_pubkey *nkey; 727 BIO *mem; 728 729 mem = BIO_new_mem_buf((void *) key, len); 730 nkey = UCL_ALLOC(sizeof(struct ucl_pubkey)); 731 if (nkey == NULL) { 732 ucl_create_err(&parser->err, "cannot allocate memory for key"); 733 return false; 734 } 735 nkey->key = PEM_read_bio_PUBKEY(mem, &nkey->key, NULL, NULL); 736 BIO_free(mem); 737 if (nkey->key == NULL) { 738 UCL_FREE(sizeof(struct ucl_pubkey), nkey); 739 ucl_create_err(&parser->err, "%s", 740 ERR_error_string(ERR_get_error(), NULL)); 741 return false; 742 } 743 LL_PREPEND(parser->keys, nkey); 744 #endif 745 #endif 746 return true; 747 } 748 749 void ucl_parser_add_special_handler(struct ucl_parser *parser, 750 struct ucl_parser_special_handler *handler) 751 { 752 LL_APPEND(parser->special_handlers, handler); 753 } 754 755 #ifdef CURL_FOUND 756 struct ucl_curl_cbdata { 757 unsigned char *buf; 758 size_t buflen; 759 }; 760 761 static size_t 762 ucl_curl_write_callback(void *contents, size_t size, size_t nmemb, void *ud) 763 { 764 struct ucl_curl_cbdata *cbdata = ud; 765 size_t realsize = size * nmemb; 766 767 cbdata->buf = realloc(cbdata->buf, cbdata->buflen + realsize + 1); 768 if (cbdata->buf == NULL) { 769 return 0; 770 } 771 772 memcpy(&(cbdata->buf[cbdata->buflen]), contents, realsize); 773 cbdata->buflen += realsize; 774 cbdata->buf[cbdata->buflen] = 0; 775 776 return realsize; 777 } 778 #endif 779 780 /** 781 * Fetch a url and save results to the memory buffer 782 * @param url url to fetch 783 * @param len length of url 784 * @param buf target buffer 785 * @param buflen target length 786 * @return 787 */ 788 bool ucl_fetch_url(const unsigned char *url, unsigned char **buf, size_t *buflen, 789 UT_string **err, bool must_exist) 790 { 791 792 #ifdef HAVE_FETCH_H 793 struct url *fetch_url; 794 struct url_stat us; 795 FILE *in; 796 797 fetch_url = fetchParseURL(url); 798 if (fetch_url == NULL) { 799 ucl_create_err(err, "invalid URL %s: %s", 800 url, strerror(errno)); 801 return false; 802 } 803 if ((in = fetchXGet(fetch_url, &us, "")) == NULL) { 804 if (!must_exist) { 805 ucl_create_err(err, "cannot fetch URL %s: %s", 806 url, strerror(errno)); 807 } 808 fetchFreeURL(fetch_url); 809 return false; 810 } 811 812 *buflen = us.size; 813 *buf = malloc(*buflen); 814 if (*buf == NULL) { 815 ucl_create_err(err, "cannot allocate buffer for URL %s: %s", 816 url, strerror(errno)); 817 fclose(in); 818 fetchFreeURL(fetch_url); 819 return false; 820 } 821 822 if (fread(*buf, *buflen, 1, in) != 1) { 823 ucl_create_err(err, "cannot read URL %s: %s", 824 url, strerror(errno)); 825 fclose(in); 826 fetchFreeURL(fetch_url); 827 return false; 828 } 829 830 fetchFreeURL(fetch_url); 831 return true; 832 #elif defined(CURL_FOUND) 833 CURL *curl; 834 int r; 835 struct ucl_curl_cbdata cbdata; 836 837 curl = curl_easy_init(); 838 if (curl == NULL) { 839 ucl_create_err(err, "CURL interface is broken"); 840 return false; 841 } 842 if ((r = curl_easy_setopt(curl, CURLOPT_URL, url)) != CURLE_OK) { 843 ucl_create_err(err, "invalid URL %s: %s", 844 url, curl_easy_strerror(r)); 845 curl_easy_cleanup(curl); 846 return false; 847 } 848 curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, ucl_curl_write_callback); 849 cbdata.buf = NULL; 850 cbdata.buflen = 0; 851 curl_easy_setopt(curl, CURLOPT_WRITEDATA, &cbdata); 852 853 if ((r = curl_easy_perform(curl)) != CURLE_OK) { 854 if (!must_exist) { 855 ucl_create_err(err, "error fetching URL %s: %s", 856 url, curl_easy_strerror(r)); 857 } 858 curl_easy_cleanup(curl); 859 if (cbdata.buf) { 860 free(cbdata.buf); 861 } 862 return false; 863 } 864 *buf = cbdata.buf; 865 *buflen = cbdata.buflen; 866 867 curl_easy_cleanup(curl); 868 869 return true; 870 #else 871 ucl_create_err(err, "URL support is disabled"); 872 return false; 873 #endif 874 } 875 876 /** 877 * Fetch a file and save results to the memory buffer 878 * @param filename filename to fetch 879 * @param len length of filename 880 * @param buf target buffer 881 * @param buflen target length 882 * @return 883 */ 884 bool ucl_fetch_file(const unsigned char *filename, unsigned char **buf, size_t *buflen, 885 UT_string **err, bool must_exist) 886 { 887 int fd; 888 struct stat st; 889 if ((fd = open(filename, O_RDONLY)) == -1) { 890 ucl_create_err(err, "cannot open file %s: %s", 891 filename, strerror(errno)); 892 return false; 893 } 894 895 if (fstat(fd, &st) == -1) { 896 if (must_exist || errno == EPERM) { 897 ucl_create_err(err, "cannot stat file %s: %s", 898 filename, strerror(errno)); 899 } 900 close(fd); 901 902 return false; 903 } 904 if (!S_ISREG(st.st_mode)) { 905 if (must_exist) { 906 ucl_create_err(err, "file %s is not a regular file", filename); 907 } 908 close(fd); 909 910 return false; 911 } 912 913 if (st.st_size == 0) { 914 /* Do not map empty files */ 915 *buf = NULL; 916 *buflen = 0; 917 } 918 else { 919 if ((*buf = ucl_mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) { 920 close(fd); 921 ucl_create_err(err, "cannot mmap file %s: %s", 922 filename, strerror(errno)); 923 *buf = NULL; 924 925 return false; 926 } 927 *buflen = st.st_size; 928 } 929 930 close(fd); 931 932 return true; 933 } 934 935 936 #if (defined(HAVE_OPENSSL) && OPENSSL_VERSION_NUMBER >= 0x10000000L) 937 static inline bool 938 ucl_sig_check(const unsigned char *data, size_t datalen, 939 const unsigned char *sig, size_t siglen, struct ucl_parser *parser) 940 { 941 struct ucl_pubkey *key; 942 char dig[EVP_MAX_MD_SIZE]; 943 unsigned int diglen; 944 EVP_PKEY_CTX *key_ctx; 945 EVP_MD_CTX *sign_ctx = NULL; 946 947 sign_ctx = EVP_MD_CTX_create(); 948 949 LL_FOREACH(parser->keys, key) 950 { 951 key_ctx = EVP_PKEY_CTX_new(key->key, NULL); 952 if (key_ctx != NULL) { 953 if (EVP_PKEY_verify_init(key_ctx) <= 0) { 954 EVP_PKEY_CTX_free(key_ctx); 955 continue; 956 } 957 if (EVP_PKEY_CTX_set_rsa_padding(key_ctx, RSA_PKCS1_PADDING) <= 0) { 958 EVP_PKEY_CTX_free(key_ctx); 959 continue; 960 } 961 if (EVP_PKEY_CTX_set_signature_md(key_ctx, EVP_sha256()) <= 0) { 962 EVP_PKEY_CTX_free(key_ctx); 963 continue; 964 } 965 EVP_DigestInit(sign_ctx, EVP_sha256()); 966 EVP_DigestUpdate(sign_ctx, data, datalen); 967 EVP_DigestFinal(sign_ctx, dig, &diglen); 968 969 if (EVP_PKEY_verify(key_ctx, sig, siglen, dig, diglen) == 1) { 970 EVP_MD_CTX_destroy(sign_ctx); 971 EVP_PKEY_CTX_free(key_ctx); 972 return true; 973 } 974 975 EVP_PKEY_CTX_free(key_ctx); 976 } 977 } 978 979 EVP_MD_CTX_destroy(sign_ctx); 980 981 return false; 982 } 983 #endif 984 985 struct ucl_include_params { 986 bool check_signature; 987 bool must_exist; 988 bool use_glob; 989 bool use_prefix; 990 bool soft_fail; 991 bool allow_glob; 992 unsigned priority; 993 enum ucl_duplicate_strategy strat; 994 enum ucl_parse_type parse_type; 995 const char *prefix; 996 const char *target; 997 }; 998 999 /** 1000 * Include an url to configuration 1001 * @param data 1002 * @param len 1003 * @param parser 1004 * @param err 1005 * @return 1006 */ 1007 static bool 1008 ucl_include_url(const unsigned char *data, size_t len, 1009 struct ucl_parser *parser, 1010 struct ucl_include_params *params) 1011 { 1012 1013 bool res; 1014 unsigned char *buf = NULL; 1015 size_t buflen = 0; 1016 struct ucl_chunk *chunk; 1017 char urlbuf[PATH_MAX]; 1018 int prev_state; 1019 1020 snprintf(urlbuf, sizeof(urlbuf), "%.*s", (int) len, data); 1021 1022 if (!ucl_fetch_url(urlbuf, &buf, &buflen, &parser->err, params->must_exist)) { 1023 if (!params->must_exist) { 1024 ucl_parser_clear_error(parser); 1025 } 1026 return !params->must_exist; 1027 } 1028 1029 if (params->check_signature) { 1030 #if (defined(HAVE_OPENSSL) && OPENSSL_VERSION_NUMBER >= 0x10000000L) 1031 unsigned char *sigbuf = NULL; 1032 size_t siglen = 0; 1033 /* We need to check signature first */ 1034 snprintf(urlbuf, sizeof(urlbuf), "%.*s.sig", (int) len, data); 1035 if (!ucl_fetch_url(urlbuf, &sigbuf, &siglen, &parser->err, true)) { 1036 return false; 1037 } 1038 if (!ucl_sig_check(buf, buflen, sigbuf, siglen, parser)) { 1039 ucl_create_err(&parser->err, "cannot verify url %s: %s", 1040 urlbuf, 1041 ERR_error_string(ERR_get_error(), NULL)); 1042 if (siglen > 0) { 1043 free(sigbuf); 1044 } 1045 return false; 1046 } 1047 if (siglen > 0) { 1048 free(sigbuf); 1049 } 1050 #endif 1051 } 1052 1053 prev_state = parser->state; 1054 parser->state = UCL_STATE_INIT; 1055 1056 res = ucl_parser_add_chunk_full(parser, buf, buflen, params->priority, 1057 params->strat, params->parse_type); 1058 if (res == true) { 1059 /* Remove chunk from the stack */ 1060 chunk = parser->chunks; 1061 if (chunk != NULL) { 1062 parser->chunks = chunk->next; 1063 ucl_chunk_free(chunk); 1064 } 1065 } 1066 1067 parser->state = prev_state; 1068 free(buf); 1069 1070 return res; 1071 } 1072 1073 /** 1074 * Include a single file to the parser 1075 * @param data 1076 * @param len 1077 * @param parser 1078 * @param check_signature 1079 * @param must_exist 1080 * @param allow_glob 1081 * @param priority 1082 * @return 1083 */ 1084 static bool 1085 ucl_include_file_single(const unsigned char *data, size_t len, 1086 struct ucl_parser *parser, struct ucl_include_params *params) 1087 { 1088 bool res; 1089 struct ucl_chunk *chunk; 1090 unsigned char *buf = NULL; 1091 char *old_curfile, *ext, *tmp; 1092 size_t buflen = 0; 1093 char filebuf[PATH_MAX], realbuf[PATH_MAX]; 1094 int prev_state; 1095 struct ucl_variable *cur_var, *tmp_var, *old_curdir = NULL, 1096 *old_filename = NULL; 1097 ucl_object_t *nest_obj = NULL, *old_obj = NULL, *new_obj = NULL; 1098 ucl_hash_t *container = NULL; 1099 struct ucl_stack *st = NULL; 1100 1101 if (parser->state == UCL_STATE_ERROR) { 1102 /* Return immediately if we are in the error state... */ 1103 return false; 1104 } 1105 1106 snprintf(filebuf, sizeof(filebuf), "%.*s", (int) len, data); 1107 if (ucl_realpath(filebuf, realbuf) == NULL) { 1108 if (params->soft_fail) { 1109 return false; 1110 } 1111 if (!params->must_exist && errno != EPERM) { 1112 return true; 1113 } 1114 1115 ucl_create_err(&parser->err, "cannot open file %s: %s", 1116 filebuf, 1117 strerror(errno)); 1118 return false; 1119 } 1120 1121 if (parser->cur_file && strcmp(realbuf, parser->cur_file) == 0) { 1122 /* We are likely including the file itself */ 1123 if (params->soft_fail) { 1124 return false; 1125 } 1126 1127 ucl_create_err(&parser->err, "trying to include the file %s from itself", 1128 realbuf); 1129 return false; 1130 } 1131 1132 if (!ucl_fetch_file(realbuf, &buf, &buflen, &parser->err, params->must_exist)) { 1133 if (params->soft_fail) { 1134 return false; 1135 } 1136 1137 if (params->must_exist || parser->err != NULL) { 1138 /* The case of fatal errors */ 1139 return false; 1140 } 1141 1142 ucl_parser_clear_error(parser); 1143 1144 return true; 1145 } 1146 1147 if (params->check_signature) { 1148 #if (defined(HAVE_OPENSSL) && OPENSSL_VERSION_NUMBER >= 0x10000000L) 1149 unsigned char *sigbuf = NULL; 1150 size_t siglen = 0; 1151 /* We need to check signature first */ 1152 snprintf(filebuf, sizeof(filebuf), "%s.sig", realbuf); 1153 if (!ucl_fetch_file(filebuf, &sigbuf, &siglen, &parser->err, true)) { 1154 if (buf) { 1155 ucl_munmap(buf, buflen); 1156 } 1157 1158 return false; 1159 } 1160 if (!ucl_sig_check(buf, buflen, sigbuf, siglen, parser)) { 1161 ucl_create_err(&parser->err, "cannot verify file %s: %s", 1162 filebuf, 1163 ERR_error_string(ERR_get_error(), NULL)); 1164 if (sigbuf) { 1165 ucl_munmap(sigbuf, siglen); 1166 } 1167 if (buf) { 1168 ucl_munmap(buf, buflen); 1169 } 1170 1171 return false; 1172 } 1173 1174 if (sigbuf) { 1175 ucl_munmap(sigbuf, siglen); 1176 } 1177 #endif 1178 } 1179 1180 old_curfile = parser->cur_file; 1181 parser->cur_file = NULL; 1182 1183 /* Store old file vars */ 1184 DL_FOREACH_SAFE(parser->variables, cur_var, tmp_var) 1185 { 1186 if (strcmp(cur_var->var, "CURDIR") == 0) { 1187 old_curdir = cur_var; 1188 DL_DELETE(parser->variables, cur_var); 1189 } 1190 else if (strcmp(cur_var->var, "FILENAME") == 0) { 1191 old_filename = cur_var; 1192 DL_DELETE(parser->variables, cur_var); 1193 } 1194 } 1195 1196 ucl_parser_set_filevars(parser, realbuf, false); 1197 1198 prev_state = parser->state; 1199 parser->state = UCL_STATE_INIT; 1200 1201 if (params->use_prefix && params->prefix == NULL) { 1202 /* Auto generate a key name based on the included filename */ 1203 tmp = basename(realbuf); 1204 ext = strrchr(tmp, '.'); 1205 if (ext != NULL && (strcmp(ext, ".conf") == 0 || strcmp(ext, ".ucl") == 0)) { 1206 /* Strip off .conf or .ucl */ 1207 *ext = '\0'; 1208 } 1209 params->prefix = tmp; 1210 } 1211 if (params->prefix != NULL) { 1212 /* This is a prefixed include */ 1213 container = parser->stack->obj->value.ov; 1214 1215 old_obj = __DECONST(ucl_object_t *, ucl_hash_search(container, 1216 params->prefix, strlen(params->prefix))); 1217 1218 if (strcasecmp(params->target, "array") == 0) { 1219 if (old_obj == NULL) { 1220 /* Create an array with key: prefix */ 1221 old_obj = ucl_object_new_full(UCL_ARRAY, params->priority); 1222 old_obj->key = params->prefix; 1223 old_obj->keylen = strlen(params->prefix); 1224 ucl_copy_key_trash(old_obj); 1225 old_obj->prev = old_obj; 1226 old_obj->next = NULL; 1227 1228 container = ucl_hash_insert_object(container, old_obj, 1229 parser->flags & UCL_PARSER_KEY_LOWERCASE); 1230 parser->stack->obj->len++; 1231 1232 nest_obj = ucl_object_new_full(UCL_OBJECT, params->priority); 1233 nest_obj->prev = nest_obj; 1234 nest_obj->next = NULL; 1235 1236 ucl_array_append(old_obj, nest_obj); 1237 } 1238 else { 1239 if (ucl_object_type(old_obj) == UCL_ARRAY) { 1240 /* Append to the existing array */ 1241 nest_obj = ucl_object_new_full(UCL_OBJECT, 1242 params->priority); 1243 if (nest_obj == NULL) { 1244 ucl_create_err(&parser->err, 1245 "cannot allocate memory for an object"); 1246 if (buf) { 1247 ucl_munmap(buf, buflen); 1248 } 1249 1250 return false; 1251 } 1252 nest_obj->prev = nest_obj; 1253 nest_obj->next = NULL; 1254 1255 ucl_array_append(old_obj, nest_obj); 1256 } 1257 else { 1258 /* Convert the object to an array */ 1259 new_obj = ucl_object_typed_new(UCL_ARRAY); 1260 if (new_obj == NULL) { 1261 ucl_create_err(&parser->err, 1262 "cannot allocate memory for an object"); 1263 if (buf) { 1264 ucl_munmap(buf, buflen); 1265 } 1266 1267 return false; 1268 } 1269 new_obj->key = old_obj->key; 1270 new_obj->keylen = old_obj->keylen; 1271 new_obj->flags |= UCL_OBJECT_MULTIVALUE; 1272 new_obj->prev = new_obj; 1273 new_obj->next = NULL; 1274 1275 nest_obj = ucl_object_new_full(UCL_OBJECT, 1276 params->priority); 1277 if (nest_obj == NULL) { 1278 ucl_create_err(&parser->err, 1279 "cannot allocate memory for an object"); 1280 if (buf) { 1281 ucl_munmap(buf, buflen); 1282 } 1283 1284 ucl_object_unref(new_obj); 1285 1286 return false; 1287 } 1288 nest_obj->prev = nest_obj; 1289 nest_obj->next = NULL; 1290 1291 ucl_array_append(new_obj, old_obj); 1292 ucl_array_append(new_obj, nest_obj); 1293 ucl_hash_replace(container, old_obj, new_obj); 1294 } 1295 } 1296 } 1297 else { 1298 /* Case of object */ 1299 if (old_obj == NULL) { 1300 /* Create an object with key: prefix */ 1301 nest_obj = ucl_object_new_full(UCL_OBJECT, params->priority); 1302 1303 if (nest_obj == NULL) { 1304 ucl_create_err(&parser->err, "cannot allocate memory for an object"); 1305 if (buf) { 1306 ucl_munmap(buf, buflen); 1307 } 1308 1309 return false; 1310 } 1311 1312 nest_obj->key = params->prefix; 1313 nest_obj->keylen = strlen(params->prefix); 1314 ucl_copy_key_trash(nest_obj); 1315 nest_obj->prev = nest_obj; 1316 nest_obj->next = NULL; 1317 1318 container = ucl_hash_insert_object(container, nest_obj, 1319 parser->flags & UCL_PARSER_KEY_LOWERCASE); 1320 parser->stack->obj->len++; 1321 } 1322 else { 1323 if (ucl_object_type(old_obj) == UCL_OBJECT) { 1324 /* Append to existing Object*/ 1325 nest_obj = old_obj; 1326 } 1327 else { 1328 /* The key is not an object */ 1329 ucl_create_err(&parser->err, 1330 "Conflicting type for key: %s, asked %s, has %s", 1331 params->prefix, params->target, 1332 ucl_object_type_to_string(ucl_object_type(old_obj))); 1333 if (buf) { 1334 ucl_munmap(buf, buflen); 1335 } 1336 1337 return false; 1338 } 1339 } 1340 } 1341 1342 1343 /* Put all of the content of the include inside that object */ 1344 parser->stack->obj->value.ov = container; 1345 1346 st = UCL_ALLOC(sizeof(struct ucl_stack)); 1347 if (st == NULL) { 1348 ucl_create_err(&parser->err, "cannot allocate memory for an object"); 1349 ucl_object_unref(nest_obj); 1350 1351 if (buf) { 1352 ucl_munmap(buf, buflen); 1353 } 1354 1355 return false; 1356 } 1357 st->obj = nest_obj; 1358 st->e.params.level = parser->stack->e.params.level; 1359 st->e.params.flags = parser->stack->e.params.flags; 1360 st->e.params.line = parser->stack->e.params.line; 1361 st->chunk = parser->chunks; 1362 LL_PREPEND(parser->stack, st); 1363 parser->cur_obj = nest_obj; 1364 } 1365 1366 res = ucl_parser_add_chunk_full(parser, buf, buflen, params->priority, 1367 params->strat, params->parse_type); 1368 1369 if (res) { 1370 /* Stop nesting the include, take 1 level off the stack */ 1371 if (params->prefix != NULL && nest_obj != NULL) { 1372 parser->stack = st->next; 1373 UCL_FREE(sizeof(struct ucl_stack), st); 1374 } 1375 1376 /* Remove chunk from the stack */ 1377 chunk = parser->chunks; 1378 if (chunk != NULL) { 1379 parser->chunks = chunk->next; 1380 ucl_chunk_free(chunk); 1381 parser->recursion--; 1382 } 1383 1384 /* Restore old file vars */ 1385 if (parser->cur_file) { 1386 UCL_FREE(strlen(parser->cur_file) + 1, parser->cur_file); 1387 } 1388 1389 parser->cur_file = old_curfile; 1390 DL_FOREACH_SAFE(parser->variables, cur_var, tmp_var) 1391 { 1392 if (strcmp(cur_var->var, "CURDIR") == 0 && old_curdir) { 1393 DL_DELETE(parser->variables, cur_var); 1394 free(cur_var->var); 1395 free(cur_var->value); 1396 UCL_FREE(sizeof(struct ucl_variable), cur_var); 1397 } 1398 else if (strcmp(cur_var->var, "FILENAME") == 0 && old_filename) { 1399 DL_DELETE(parser->variables, cur_var); 1400 free(cur_var->var); 1401 free(cur_var->value); 1402 UCL_FREE(sizeof(struct ucl_variable), cur_var); 1403 } 1404 } 1405 if (old_filename) { 1406 DL_APPEND(parser->variables, old_filename); 1407 } 1408 if (old_curdir) { 1409 DL_APPEND(parser->variables, old_curdir); 1410 } 1411 1412 parser->state = prev_state; 1413 } 1414 1415 if (buflen > 0) { 1416 ucl_munmap(buf, buflen); 1417 } 1418 1419 return res; 1420 } 1421 1422 /** 1423 * Include a file to configuration 1424 * @param data 1425 * @param len 1426 * @param parser 1427 * @param err 1428 * @return 1429 */ 1430 static bool 1431 ucl_include_file(const unsigned char *data, size_t len, 1432 struct ucl_parser *parser, 1433 struct ucl_include_params *params, 1434 const ucl_object_t *args) 1435 { 1436 const unsigned char *p = data, *end = data + len; 1437 bool need_glob = false; 1438 int cnt = 0; 1439 char glob_pattern[PATH_MAX]; 1440 size_t i; 1441 1442 #ifndef _WIN32 1443 if (!params->allow_glob) { 1444 return ucl_include_file_single(data, len, parser, params); 1445 } 1446 else { 1447 /* Check for special symbols in a filename */ 1448 while (p != end) { 1449 if (*p == '*' || *p == '?') { 1450 need_glob = true; 1451 break; 1452 } 1453 p++; 1454 } 1455 if (need_glob) { 1456 glob_t globbuf; 1457 memset(&globbuf, 0, sizeof(globbuf)); 1458 ucl_strlcpy(glob_pattern, (const char *) data, 1459 (len + 1 < sizeof(glob_pattern) ? len + 1 : sizeof(glob_pattern))); 1460 if (glob(glob_pattern, 0, NULL, &globbuf) != 0) { 1461 return (!params->must_exist || false); 1462 } 1463 for (i = 0; i < globbuf.gl_pathc; i++) { 1464 1465 if (parser->include_trace_func) { 1466 const ucl_object_t *parent = NULL; 1467 1468 if (parser->stack) { 1469 parent = parser->stack->obj; 1470 } 1471 1472 parser->include_trace_func(parser, parent, NULL, 1473 globbuf.gl_pathv[i], 1474 strlen(globbuf.gl_pathv[i]), 1475 parser->include_trace_ud); 1476 } 1477 1478 if (!ucl_include_file_single((unsigned char *) globbuf.gl_pathv[i], 1479 strlen(globbuf.gl_pathv[i]), parser, params)) { 1480 if (params->soft_fail) { 1481 continue; 1482 } 1483 globfree(&globbuf); 1484 return false; 1485 } 1486 cnt++; 1487 } 1488 globfree(&globbuf); 1489 1490 if (cnt == 0 && params->must_exist) { 1491 ucl_create_err(&parser->err, "cannot match any files for pattern %s", 1492 glob_pattern); 1493 return false; 1494 } 1495 } 1496 else { 1497 return ucl_include_file_single(data, len, parser, params); 1498 } 1499 } 1500 #else 1501 /* Win32 compilers do not support globbing. Therefore, for Win32, 1502 treat allow_glob/need_glob as a NOOP and just return */ 1503 return ucl_include_file_single(data, len, parser, params); 1504 #endif 1505 1506 return true; 1507 } 1508 1509 /** 1510 * Common function to handle .*include* macros 1511 * @param data 1512 * @param len 1513 * @param args 1514 * @param parser 1515 * @param default_try 1516 * @param default_sign 1517 * @return 1518 */ 1519 static bool 1520 ucl_include_common(const unsigned char *data, size_t len, 1521 const ucl_object_t *args, struct ucl_parser *parser, 1522 bool default_try, 1523 bool default_sign) 1524 { 1525 bool allow_url = false, search = false; 1526 const char *duplicate; 1527 const ucl_object_t *param; 1528 ucl_object_iter_t it = NULL, ip = NULL; 1529 char ipath[PATH_MAX]; 1530 struct ucl_include_params params; 1531 1532 /* Default values */ 1533 params.soft_fail = default_try; 1534 params.allow_glob = false; 1535 params.check_signature = default_sign; 1536 params.use_prefix = false; 1537 params.target = "object"; 1538 params.prefix = NULL; 1539 params.priority = 0; 1540 params.parse_type = UCL_PARSE_UCL; 1541 params.strat = UCL_DUPLICATE_APPEND; 1542 params.must_exist = !default_try; 1543 1544 if (parser->include_trace_func) { 1545 const ucl_object_t *parent = NULL; 1546 1547 if (parser->stack) { 1548 parent = parser->stack->obj; 1549 } 1550 1551 parser->include_trace_func(parser, parent, args, 1552 data, len, parser->include_trace_ud); 1553 } 1554 1555 /* Process arguments */ 1556 if (args != NULL && args->type == UCL_OBJECT) { 1557 while ((param = ucl_object_iterate(args, &it, true)) != NULL) { 1558 if (param->type == UCL_BOOLEAN) { 1559 if (strncmp(param->key, "try", param->keylen) == 0) { 1560 params.must_exist = !ucl_object_toboolean(param); 1561 } 1562 else if (strncmp(param->key, "sign", param->keylen) == 0) { 1563 params.check_signature = ucl_object_toboolean(param); 1564 } 1565 else if (strncmp(param->key, "glob", param->keylen) == 0) { 1566 params.allow_glob = ucl_object_toboolean(param); 1567 } 1568 else if (strncmp(param->key, "url", param->keylen) == 0) { 1569 allow_url = ucl_object_toboolean(param); 1570 } 1571 else if (strncmp(param->key, "prefix", param->keylen) == 0) { 1572 params.use_prefix = ucl_object_toboolean(param); 1573 } 1574 } 1575 else if (param->type == UCL_STRING) { 1576 if (strncmp(param->key, "key", param->keylen) == 0) { 1577 params.prefix = ucl_object_tostring(param); 1578 } 1579 else if (strncmp(param->key, "target", param->keylen) == 0) { 1580 params.target = ucl_object_tostring(param); 1581 } 1582 else if (strncmp(param->key, "duplicate", param->keylen) == 0) { 1583 duplicate = ucl_object_tostring(param); 1584 1585 if (strcmp(duplicate, "append") == 0) { 1586 params.strat = UCL_DUPLICATE_APPEND; 1587 } 1588 else if (strcmp(duplicate, "merge") == 0) { 1589 params.strat = UCL_DUPLICATE_MERGE; 1590 } 1591 else if (strcmp(duplicate, "rewrite") == 0) { 1592 params.strat = UCL_DUPLICATE_REWRITE; 1593 } 1594 else if (strcmp(duplicate, "error") == 0) { 1595 params.strat = UCL_DUPLICATE_ERROR; 1596 } 1597 } 1598 } 1599 else if (param->type == UCL_ARRAY) { 1600 if (strncmp(param->key, "path", param->keylen) == 0) { 1601 ucl_set_include_path(parser, __DECONST(ucl_object_t *, param)); 1602 } 1603 } 1604 else if (param->type == UCL_INT) { 1605 if (strncmp(param->key, "priority", param->keylen) == 0) { 1606 params.priority = ucl_object_toint(param); 1607 } 1608 } 1609 } 1610 } 1611 1612 if (parser->includepaths == NULL) { 1613 if (allow_url && ucl_strnstr(data, "://", len) != NULL) { 1614 /* Globbing is not used for URL's */ 1615 return ucl_include_url(data, len, parser, ¶ms); 1616 } 1617 else if (data != NULL) { 1618 /* Try to load a file */ 1619 return ucl_include_file(data, len, parser, ¶ms, args); 1620 } 1621 } 1622 else { 1623 if (allow_url && ucl_strnstr(data, "://", len) != NULL) { 1624 /* Globbing is not used for URL's */ 1625 return ucl_include_url(data, len, parser, ¶ms); 1626 } 1627 1628 ip = ucl_object_iterate_new(parser->includepaths); 1629 while ((param = ucl_object_iterate_safe(ip, true)) != NULL) { 1630 if (ucl_object_type(param) == UCL_STRING) { 1631 snprintf(ipath, sizeof(ipath), "%s/%.*s", ucl_object_tostring(param), 1632 (int) len, data); 1633 if ((search = ucl_include_file(ipath, strlen(ipath), 1634 parser, ¶ms, args))) { 1635 if (!params.allow_glob) { 1636 break; 1637 } 1638 } 1639 } 1640 } 1641 ucl_object_iterate_free(ip); 1642 if (search == true) { 1643 return true; 1644 } 1645 else { 1646 ucl_create_err(&parser->err, 1647 "cannot find file: %.*s in search path", 1648 (int) len, data); 1649 return false; 1650 } 1651 } 1652 1653 return false; 1654 } 1655 1656 /** 1657 * Handle include macro 1658 * @param data include data 1659 * @param len length of data 1660 * @param args UCL object representing arguments to the macro 1661 * @param ud user data 1662 * @return 1663 */ 1664 bool ucl_include_handler(const unsigned char *data, size_t len, 1665 const ucl_object_t *args, void *ud) 1666 { 1667 struct ucl_parser *parser = ud; 1668 1669 return ucl_include_common(data, len, args, parser, false, false); 1670 } 1671 1672 /** 1673 * Handle includes macro 1674 * @param data include data 1675 * @param len length of data 1676 * @param args UCL object representing arguments to the macro 1677 * @param ud user data 1678 * @return 1679 */ 1680 bool ucl_includes_handler(const unsigned char *data, size_t len, 1681 const ucl_object_t *args, void *ud) 1682 { 1683 struct ucl_parser *parser = ud; 1684 1685 return ucl_include_common(data, len, args, parser, false, true); 1686 } 1687 1688 /** 1689 * Handle tryinclude macro 1690 * @param data include data 1691 * @param len length of data 1692 * @param args UCL object representing arguments to the macro 1693 * @param ud user data 1694 * @return 1695 */ 1696 bool ucl_try_include_handler(const unsigned char *data, size_t len, 1697 const ucl_object_t *args, void *ud) 1698 { 1699 struct ucl_parser *parser = ud; 1700 1701 return ucl_include_common(data, len, args, parser, true, false); 1702 } 1703 1704 /** 1705 * Handle priority macro 1706 * @param data include data 1707 * @param len length of data 1708 * @param args UCL object representing arguments to the macro 1709 * @param ud user data 1710 * @return 1711 */ 1712 bool ucl_priority_handler(const unsigned char *data, size_t len, 1713 const ucl_object_t *args, void *ud) 1714 { 1715 struct ucl_parser *parser = ud; 1716 unsigned priority = 255; 1717 const ucl_object_t *param; 1718 bool found = false; 1719 char *value = NULL, *leftover = NULL; 1720 ucl_object_iter_t it = NULL; 1721 1722 if (parser == NULL) { 1723 return false; 1724 } 1725 1726 /* Process arguments */ 1727 if (args != NULL && args->type == UCL_OBJECT) { 1728 while ((param = ucl_object_iterate(args, &it, true)) != NULL) { 1729 if (param->type == UCL_INT) { 1730 if (strncmp(param->key, "priority", param->keylen) == 0) { 1731 priority = ucl_object_toint(param); 1732 found = true; 1733 } 1734 } 1735 } 1736 } 1737 1738 if (len > 0) { 1739 value = malloc(len + 1); 1740 ucl_strlcpy(value, (const char *) data, len + 1); 1741 priority = strtol(value, &leftover, 10); 1742 if (*leftover != '\0') { 1743 ucl_create_err(&parser->err, "Invalid priority value in macro: %s", 1744 value); 1745 free(value); 1746 return false; 1747 } 1748 free(value); 1749 found = true; 1750 } 1751 1752 if (found == true) { 1753 parser->chunks->priority = priority; 1754 return true; 1755 } 1756 1757 ucl_create_err(&parser->err, "Unable to parse priority macro"); 1758 return false; 1759 } 1760 1761 /** 1762 * Handle load macro 1763 * @param data include data 1764 * @param len length of data 1765 * @param args UCL object representing arguments to the macro 1766 * @param ud user data 1767 * @return 1768 */ 1769 bool ucl_load_handler(const unsigned char *data, size_t len, 1770 const ucl_object_t *args, void *ud) 1771 { 1772 struct ucl_parser *parser = ud; 1773 const ucl_object_t *param; 1774 ucl_object_t *obj, *old_obj; 1775 ucl_object_iter_t it = NULL; 1776 bool try_load, multiline, test; 1777 const char *target, *prefix; 1778 char *load_file, *tmp; 1779 unsigned char *buf; 1780 size_t buflen; 1781 unsigned priority; 1782 int64_t iv; 1783 ucl_object_t *container = NULL; 1784 enum ucl_string_flags flags; 1785 1786 /* Default values */ 1787 try_load = false; 1788 multiline = false; 1789 test = false; 1790 target = "string"; 1791 prefix = NULL; 1792 load_file = NULL; 1793 buf = NULL; 1794 buflen = 0; 1795 priority = 0; 1796 obj = NULL; 1797 old_obj = NULL; 1798 flags = 0; 1799 1800 if (parser == NULL) { 1801 return false; 1802 } 1803 1804 /* Process arguments */ 1805 if (args != NULL && args->type == UCL_OBJECT) { 1806 while ((param = ucl_object_iterate(args, &it, true)) != NULL) { 1807 if (param->type == UCL_BOOLEAN) { 1808 if (strncmp(param->key, "try", param->keylen) == 0) { 1809 try_load = ucl_object_toboolean(param); 1810 } 1811 else if (strncmp(param->key, "multiline", param->keylen) == 0) { 1812 multiline = ucl_object_toboolean(param); 1813 } 1814 else if (strncmp(param->key, "escape", param->keylen) == 0) { 1815 test = ucl_object_toboolean(param); 1816 if (test) { 1817 flags |= UCL_STRING_ESCAPE; 1818 } 1819 } 1820 else if (strncmp(param->key, "trim", param->keylen) == 0) { 1821 test = ucl_object_toboolean(param); 1822 if (test) { 1823 flags |= UCL_STRING_TRIM; 1824 } 1825 } 1826 } 1827 else if (param->type == UCL_STRING) { 1828 if (strncmp(param->key, "key", param->keylen) == 0) { 1829 prefix = ucl_object_tostring(param); 1830 } 1831 else if (strncmp(param->key, "target", param->keylen) == 0) { 1832 target = ucl_object_tostring(param); 1833 } 1834 } 1835 else if (param->type == UCL_INT) { 1836 if (strncmp(param->key, "priority", param->keylen) == 0) { 1837 priority = ucl_object_toint(param); 1838 } 1839 } 1840 } 1841 } 1842 1843 if (prefix == NULL || strlen(prefix) == 0) { 1844 ucl_create_err(&parser->err, "No Key specified in load macro"); 1845 return false; 1846 } 1847 1848 if (len > 0) { 1849 load_file = malloc(len + 1); 1850 if (!load_file) { 1851 ucl_create_err(&parser->err, "cannot allocate memory for suffix"); 1852 1853 return false; 1854 } 1855 1856 snprintf(load_file, len + 1, "%.*s", (int) len, data); 1857 1858 if (!ucl_fetch_file(load_file, &buf, &buflen, &parser->err, 1859 !try_load)) { 1860 free(load_file); 1861 1862 if (try_load) { 1863 ucl_parser_clear_error(parser); 1864 } 1865 1866 return (try_load || false); 1867 } 1868 1869 free(load_file); 1870 container = parser->stack->obj; 1871 old_obj = __DECONST(ucl_object_t *, ucl_object_lookup(container, 1872 prefix)); 1873 1874 if (old_obj != NULL) { 1875 ucl_create_err(&parser->err, "Key %s already exists", prefix); 1876 if (buf) { 1877 ucl_munmap(buf, buflen); 1878 } 1879 1880 return false; 1881 } 1882 1883 if (strcasecmp(target, "string") == 0) { 1884 obj = ucl_object_fromstring_common(buf, buflen, flags); 1885 ucl_copy_value_trash(obj); 1886 if (multiline) { 1887 obj->flags |= UCL_OBJECT_MULTILINE; 1888 } 1889 } 1890 else if (strcasecmp(target, "int") == 0) { 1891 tmp = malloc(buflen + 1); 1892 1893 if (tmp == NULL) { 1894 ucl_create_err(&parser->err, "Memory allocation failed"); 1895 if (buf) { 1896 ucl_munmap(buf, buflen); 1897 } 1898 1899 return false; 1900 } 1901 1902 snprintf(tmp, buflen + 1, "%.*s", (int) buflen, buf); 1903 iv = strtoll(tmp, NULL, 10); 1904 obj = ucl_object_fromint(iv); 1905 free(tmp); 1906 } 1907 1908 if (buf) { 1909 ucl_munmap(buf, buflen); 1910 } 1911 1912 if (obj != NULL) { 1913 obj->key = prefix; 1914 obj->keylen = strlen(prefix); 1915 ucl_copy_key_trash(obj); 1916 obj->prev = obj; 1917 obj->next = NULL; 1918 ucl_object_set_priority(obj, priority); 1919 ucl_object_insert_key(container, obj, obj->key, obj->keylen, false); 1920 } 1921 1922 return true; 1923 } 1924 1925 ucl_create_err(&parser->err, "Unable to parse load macro"); 1926 return false; 1927 } 1928 1929 bool ucl_inherit_handler(const unsigned char *data, size_t len, 1930 const ucl_object_t *args, const ucl_object_t *ctx, void *ud) 1931 { 1932 const ucl_object_t *parent, *cur; 1933 ucl_object_t *target, *copy; 1934 ucl_object_iter_t it = NULL; 1935 bool replace = false; 1936 struct ucl_parser *parser = ud; 1937 1938 parent = ucl_object_lookup_len(ctx, data, len); 1939 1940 /* Some sanity checks */ 1941 if (parent == NULL || ucl_object_type(parent) != UCL_OBJECT) { 1942 ucl_create_err(&parser->err, "Unable to find inherited object %.*s", 1943 (int) len, data); 1944 return false; 1945 } 1946 1947 if (parser->stack == NULL || parser->stack->obj == NULL || 1948 ucl_object_type(parser->stack->obj) != UCL_OBJECT) { 1949 ucl_create_err(&parser->err, "Invalid inherit context"); 1950 return false; 1951 } 1952 1953 target = parser->stack->obj; 1954 1955 if (args && (cur = ucl_object_lookup(args, "replace")) != NULL) { 1956 replace = ucl_object_toboolean(cur); 1957 } 1958 1959 while ((cur = ucl_object_iterate(parent, &it, true))) { 1960 /* We do not replace existing keys */ 1961 if (!replace && ucl_object_lookup_len(target, cur->key, cur->keylen)) { 1962 continue; 1963 } 1964 1965 copy = ucl_object_copy(cur); 1966 1967 if (!replace) { 1968 copy->flags |= UCL_OBJECT_INHERITED; 1969 } 1970 1971 ucl_object_insert_key(target, copy, copy->key, 1972 copy->keylen, false); 1973 } 1974 1975 return true; 1976 } 1977 1978 bool ucl_parser_set_filevars(struct ucl_parser *parser, const char *filename, bool need_expand) 1979 { 1980 char realbuf[PATH_MAX], *curdir; 1981 1982 if (filename != NULL) { 1983 if (need_expand) { 1984 if (ucl_realpath(filename, realbuf) == NULL) { 1985 return false; 1986 } 1987 } 1988 else { 1989 ucl_strlcpy(realbuf, filename, sizeof(realbuf)); 1990 } 1991 1992 if (parser->cur_file) { 1993 UCL_FREE(strlen(parser->cur_file) + 1, parser->cur_file); 1994 } 1995 1996 parser->cur_file = UCL_STRDUP(realbuf); 1997 1998 /* Define variables */ 1999 ucl_parser_register_variable(parser, "FILENAME", realbuf); 2000 curdir = dirname(realbuf); 2001 ucl_parser_register_variable(parser, "CURDIR", curdir); 2002 } 2003 else { 2004 /* Set everything from the current dir */ 2005 curdir = getcwd(realbuf, sizeof(realbuf)); 2006 ucl_parser_register_variable(parser, "FILENAME", "undef"); 2007 ucl_parser_register_variable(parser, "CURDIR", curdir); 2008 } 2009 2010 return true; 2011 } 2012 2013 bool ucl_parser_add_file_full(struct ucl_parser *parser, const char *filename, 2014 unsigned priority, enum ucl_duplicate_strategy strat, 2015 enum ucl_parse_type parse_type) 2016 { 2017 unsigned char *buf; 2018 size_t len; 2019 bool ret; 2020 char realbuf[PATH_MAX]; 2021 2022 if (ucl_realpath(filename, realbuf) == NULL) { 2023 ucl_create_err(&parser->err, "cannot open file %s: %s", 2024 filename, 2025 strerror(errno)); 2026 return false; 2027 } 2028 2029 if (!ucl_fetch_file(realbuf, &buf, &len, &parser->err, true)) { 2030 return false; 2031 } 2032 2033 ucl_parser_set_filevars(parser, realbuf, false); 2034 ret = ucl_parser_add_chunk_full(parser, buf, len, priority, strat, 2035 parse_type); 2036 2037 if (len > 0) { 2038 ucl_munmap(buf, len); 2039 } 2040 2041 return ret; 2042 } 2043 2044 bool ucl_parser_add_file_priority(struct ucl_parser *parser, const char *filename, 2045 unsigned priority) 2046 { 2047 if (parser == NULL) { 2048 return false; 2049 } 2050 2051 return ucl_parser_add_file_full(parser, filename, priority, 2052 UCL_DUPLICATE_APPEND, UCL_PARSE_UCL); 2053 } 2054 2055 bool ucl_parser_add_file(struct ucl_parser *parser, const char *filename) 2056 { 2057 if (parser == NULL) { 2058 return false; 2059 } 2060 2061 return ucl_parser_add_file_full(parser, filename, 2062 parser->default_priority, UCL_DUPLICATE_APPEND, 2063 UCL_PARSE_UCL); 2064 } 2065 2066 2067 bool ucl_parser_add_fd_full(struct ucl_parser *parser, int fd, 2068 unsigned priority, enum ucl_duplicate_strategy strat, 2069 enum ucl_parse_type parse_type) 2070 { 2071 unsigned char *buf; 2072 size_t len; 2073 bool ret; 2074 struct stat st; 2075 2076 if (fstat(fd, &st) == -1) { 2077 ucl_create_err(&parser->err, "cannot stat fd %d: %s", 2078 fd, strerror(errno)); 2079 return false; 2080 } 2081 if (st.st_size == 0) { 2082 return true; 2083 } 2084 if ((buf = ucl_mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) { 2085 ucl_create_err(&parser->err, "cannot mmap fd %d: %s", 2086 fd, strerror(errno)); 2087 return false; 2088 } 2089 2090 if (parser->cur_file) { 2091 UCL_FREE(strlen(parser->cur_file) + 1, parser->cur_file); 2092 } 2093 parser->cur_file = NULL; 2094 len = st.st_size; 2095 ret = ucl_parser_add_chunk_full(parser, buf, len, priority, strat, 2096 parse_type); 2097 2098 if (len > 0) { 2099 ucl_munmap(buf, len); 2100 } 2101 2102 return ret; 2103 } 2104 2105 bool ucl_parser_add_fd_priority(struct ucl_parser *parser, int fd, 2106 unsigned priority) 2107 { 2108 if (parser == NULL) { 2109 return false; 2110 } 2111 2112 return ucl_parser_add_fd_full(parser, fd, parser->default_priority, 2113 UCL_DUPLICATE_APPEND, UCL_PARSE_UCL); 2114 } 2115 2116 bool ucl_parser_add_fd(struct ucl_parser *parser, int fd) 2117 { 2118 if (parser == NULL) { 2119 return false; 2120 } 2121 2122 return ucl_parser_add_fd_priority(parser, fd, parser->default_priority); 2123 } 2124 2125 size_t 2126 ucl_strlcpy(char *dst, const char *src, size_t siz) 2127 { 2128 char *d = dst; 2129 const char *s = src; 2130 size_t n = siz; 2131 2132 /* Copy as many bytes as will fit */ 2133 if (n != 0) { 2134 while (--n != 0) { 2135 if ((*d++ = *s++) == '\0') { 2136 break; 2137 } 2138 } 2139 } 2140 2141 if (n == 0 && siz != 0) { 2142 *d = '\0'; 2143 } 2144 2145 return (s - src - 1); /* count does not include NUL */ 2146 } 2147 2148 size_t 2149 ucl_strlcpy_unsafe(char *dst, const char *src, size_t siz) 2150 { 2151 memcpy(dst, src, siz - 1); 2152 dst[siz - 1] = '\0'; 2153 2154 return siz - 1; 2155 } 2156 2157 size_t 2158 ucl_strlcpy_tolower(char *dst, const char *src, size_t siz) 2159 { 2160 char *d = dst; 2161 const char *s = src; 2162 size_t n = siz; 2163 2164 /* Copy as many bytes as will fit */ 2165 if (n != 0) { 2166 while (--n != 0) { 2167 if ((*d++ = tolower(*s++)) == '\0') { 2168 break; 2169 } 2170 } 2171 } 2172 2173 if (n == 0 && siz != 0) { 2174 *d = '\0'; 2175 } 2176 2177 return (s - src); /* count does not include NUL */ 2178 } 2179 2180 /* 2181 * Find the first occurrence of find in s 2182 */ 2183 char * 2184 ucl_strnstr(const char *s, const char *find, int len) 2185 { 2186 char c, sc; 2187 int mlen; 2188 2189 if ((c = *find++) != 0) { 2190 mlen = strlen(find); 2191 do { 2192 do { 2193 if ((sc = *s++) == 0 || len-- < mlen) 2194 return (NULL); 2195 } while (sc != c); 2196 } while (strncmp(s, find, mlen) != 0); 2197 s--; 2198 } 2199 return ((char *) s); 2200 } 2201 2202 /* 2203 * Find the first occurrence of find in s, ignore case. 2204 */ 2205 char * 2206 ucl_strncasestr(const char *s, const char *find, int len) 2207 { 2208 char c, sc; 2209 int mlen; 2210 2211 if ((c = *find++) != 0) { 2212 c = tolower(c); 2213 mlen = strlen(find); 2214 do { 2215 do { 2216 if ((sc = *s++) == 0 || len-- == 0) 2217 return (NULL); 2218 } while (tolower(sc) != c); 2219 } while (strncasecmp(s, find, mlen) != 0); 2220 s--; 2221 } 2222 return ((char *) s); 2223 } 2224 2225 ucl_object_t * 2226 ucl_object_fromstring_common(const char *str, size_t len, enum ucl_string_flags flags) 2227 { 2228 ucl_object_t *obj; 2229 const char *start, *end, *p, *pos; 2230 char *dst, *d; 2231 size_t escaped_len; 2232 2233 if (str == NULL) { 2234 return NULL; 2235 } 2236 2237 obj = ucl_object_new(); 2238 if (obj) { 2239 if (len == 0) { 2240 len = strlen(str); 2241 } 2242 if (flags & UCL_STRING_TRIM) { 2243 /* Skip leading spaces */ 2244 for (start = str; (size_t) (start - str) < len; start++) { 2245 if (!ucl_test_character(*start, UCL_CHARACTER_WHITESPACE_UNSAFE)) { 2246 break; 2247 } 2248 } 2249 /* Skip trailing spaces */ 2250 for (end = str + len - 1; end > start; end--) { 2251 if (!ucl_test_character(*end, UCL_CHARACTER_WHITESPACE_UNSAFE)) { 2252 break; 2253 } 2254 } 2255 end++; 2256 } 2257 else { 2258 start = str; 2259 end = str + len; 2260 } 2261 2262 obj->type = UCL_STRING; 2263 if (flags & UCL_STRING_ESCAPE) { 2264 for (p = start, escaped_len = 0; p < end; p++, escaped_len++) { 2265 if (ucl_test_character(*p, UCL_CHARACTER_JSON_UNSAFE | UCL_CHARACTER_WHITESPACE_UNSAFE)) { 2266 switch (*p) { 2267 case '\v': 2268 case '\0': 2269 escaped_len += 5; 2270 break; 2271 case ' ': 2272 break; 2273 default: 2274 escaped_len++; 2275 break; 2276 } 2277 } 2278 } 2279 dst = malloc(escaped_len + 1); 2280 if (dst != NULL) { 2281 for (p = start, d = dst; p < end; p++, d++) { 2282 if (ucl_test_character(*p, UCL_CHARACTER_JSON_UNSAFE | UCL_CHARACTER_WHITESPACE_UNSAFE)) { 2283 switch (*p) { 2284 case '\n': 2285 *d++ = '\\'; 2286 *d = 'n'; 2287 break; 2288 case '\r': 2289 *d++ = '\\'; 2290 *d = 'r'; 2291 break; 2292 case '\b': 2293 *d++ = '\\'; 2294 *d = 'b'; 2295 break; 2296 case '\t': 2297 *d++ = '\\'; 2298 *d = 't'; 2299 break; 2300 case '\f': 2301 *d++ = '\\'; 2302 *d = 'f'; 2303 break; 2304 case '\0': 2305 *d++ = '\\'; 2306 *d++ = 'u'; 2307 *d++ = '0'; 2308 *d++ = '0'; 2309 *d++ = '0'; 2310 *d = '0'; 2311 break; 2312 case '\v': 2313 *d++ = '\\'; 2314 *d++ = 'u'; 2315 *d++ = '0'; 2316 *d++ = '0'; 2317 *d++ = '0'; 2318 *d = 'B'; 2319 break; 2320 case '\\': 2321 *d++ = '\\'; 2322 *d = '\\'; 2323 break; 2324 case ' ': 2325 *d = ' '; 2326 break; 2327 case '"': 2328 *d++ = '\\'; 2329 *d = '"'; 2330 break; 2331 } 2332 } 2333 else { 2334 *d = *p; 2335 } 2336 } 2337 *d = '\0'; 2338 obj->value.sv = dst; 2339 obj->trash_stack[UCL_TRASH_VALUE] = dst; 2340 obj->len = escaped_len; 2341 } 2342 } 2343 else { 2344 dst = malloc(end - start + 1); 2345 if (dst != NULL) { 2346 ucl_strlcpy_unsafe(dst, start, end - start + 1); 2347 obj->value.sv = dst; 2348 obj->trash_stack[UCL_TRASH_VALUE] = dst; 2349 obj->len = end - start; 2350 } 2351 } 2352 if ((flags & UCL_STRING_PARSE) && dst != NULL) { 2353 /* Parse what we have */ 2354 if (flags & UCL_STRING_PARSE_BOOLEAN) { 2355 if (!ucl_maybe_parse_boolean(obj, dst, obj->len) && (flags & UCL_STRING_PARSE_NUMBER)) { 2356 ucl_maybe_parse_number(obj, dst, dst + obj->len, &pos, 2357 flags & UCL_STRING_PARSE_DOUBLE, 2358 flags & UCL_STRING_PARSE_BYTES, 2359 flags & UCL_STRING_PARSE_TIME); 2360 } 2361 } 2362 else { 2363 ucl_maybe_parse_number(obj, dst, dst + obj->len, &pos, 2364 flags & UCL_STRING_PARSE_DOUBLE, 2365 flags & UCL_STRING_PARSE_BYTES, 2366 flags & UCL_STRING_PARSE_TIME); 2367 } 2368 } 2369 } 2370 2371 return obj; 2372 } 2373 2374 static bool 2375 ucl_object_insert_key_common(ucl_object_t *top, ucl_object_t *elt, 2376 const char *key, size_t keylen, bool copy_key, bool merge, bool replace) 2377 { 2378 ucl_object_t *found, *tmp; 2379 const ucl_object_t *cur; 2380 ucl_object_iter_t it = NULL; 2381 const char *p; 2382 int ret = true; 2383 2384 if (elt == NULL || key == NULL) { 2385 return false; 2386 } 2387 2388 if (top == NULL) { 2389 return false; 2390 } 2391 2392 if (top->type != UCL_OBJECT) { 2393 /* It is possible to convert NULL type to an object */ 2394 if (top->type == UCL_NULL) { 2395 top->type = UCL_OBJECT; 2396 } 2397 else { 2398 /* Refuse converting of other object types */ 2399 return false; 2400 } 2401 } 2402 2403 if (top->value.ov == NULL) { 2404 top->value.ov = ucl_hash_create(false); 2405 } 2406 2407 if (keylen == 0) { 2408 keylen = strlen(key); 2409 } 2410 2411 for (p = key; p < key + keylen; p++) { 2412 if (ucl_test_character(*p, UCL_CHARACTER_UCL_UNSAFE)) { 2413 elt->flags |= UCL_OBJECT_NEED_KEY_ESCAPE; 2414 break; 2415 } 2416 } 2417 2418 /* workaround for some use cases */ 2419 if (elt->trash_stack[UCL_TRASH_KEY] != NULL && 2420 key != (const char *) elt->trash_stack[UCL_TRASH_KEY]) { 2421 /* Remove copied key */ 2422 free(elt->trash_stack[UCL_TRASH_KEY]); 2423 elt->trash_stack[UCL_TRASH_KEY] = NULL; 2424 elt->flags &= ~UCL_OBJECT_ALLOCATED_KEY; 2425 } 2426 2427 elt->key = key; 2428 elt->keylen = keylen; 2429 2430 if (copy_key) { 2431 ucl_copy_key_trash(elt); 2432 } 2433 2434 found = __DECONST(ucl_object_t *, ucl_hash_search_obj(top->value.ov, elt)); 2435 2436 if (found == NULL) { 2437 top->value.ov = ucl_hash_insert_object(top->value.ov, elt, false); 2438 top->len++; 2439 /* Key was inserted - return true regardless of replace flag */ 2440 } 2441 else { 2442 if (replace) { 2443 ucl_hash_replace(top->value.ov, found, elt); 2444 ucl_object_unref(found); 2445 } 2446 else if (merge) { 2447 if (found->type != UCL_OBJECT && elt->type == UCL_OBJECT) { 2448 /* Insert old elt to new one */ 2449 ucl_object_insert_key_common(elt, found, found->key, 2450 found->keylen, copy_key, false, false); 2451 ucl_hash_delete(top->value.ov, found); 2452 top->value.ov = ucl_hash_insert_object(top->value.ov, elt, false); 2453 } 2454 else if (found->type == UCL_OBJECT && elt->type != UCL_OBJECT) { 2455 /* Insert new to old */ 2456 ucl_object_insert_key_common(found, elt, elt->key, 2457 elt->keylen, copy_key, false, false); 2458 } 2459 else if (found->type == UCL_OBJECT && elt->type == UCL_OBJECT) { 2460 /* Mix two hashes */ 2461 while ((cur = ucl_object_iterate(elt, &it, true)) != NULL) { 2462 tmp = ucl_object_ref(cur); 2463 ucl_object_insert_key_common(found, tmp, cur->key, 2464 cur->keylen, copy_key, true, false); 2465 } 2466 ucl_object_unref(elt); 2467 } 2468 else { 2469 /* Just make a list of scalars */ 2470 DL_CONCAT(found, elt); 2471 } 2472 } 2473 else { 2474 DL_CONCAT(found, elt); 2475 } 2476 } 2477 2478 return ret; 2479 } 2480 2481 bool ucl_object_delete_keyl(ucl_object_t *top, const char *key, size_t keylen) 2482 { 2483 ucl_object_t *found; 2484 2485 if (top == NULL || key == NULL) { 2486 return false; 2487 } 2488 2489 found = __DECONST(ucl_object_t *, ucl_object_lookup_len(top, key, keylen)); 2490 2491 if (found == NULL) { 2492 return false; 2493 } 2494 2495 ucl_hash_delete(top->value.ov, found); 2496 ucl_object_unref(found); 2497 top->len--; 2498 2499 return true; 2500 } 2501 2502 bool ucl_object_delete_key(ucl_object_t *top, const char *key) 2503 { 2504 return ucl_object_delete_keyl(top, key, strlen(key)); 2505 } 2506 2507 ucl_object_t * 2508 ucl_object_pop_keyl(ucl_object_t *top, const char *key, size_t keylen) 2509 { 2510 const ucl_object_t *found; 2511 2512 if (top == NULL || key == NULL) { 2513 return false; 2514 } 2515 found = ucl_object_lookup_len(top, key, keylen); 2516 2517 if (found == NULL) { 2518 return NULL; 2519 } 2520 ucl_hash_delete(top->value.ov, found); 2521 top->len--; 2522 2523 return __DECONST(ucl_object_t *, found); 2524 } 2525 2526 ucl_object_t * 2527 ucl_object_pop_key(ucl_object_t *top, const char *key) 2528 { 2529 return ucl_object_pop_keyl(top, key, strlen(key)); 2530 } 2531 2532 bool ucl_object_insert_key(ucl_object_t *top, ucl_object_t *elt, 2533 const char *key, size_t keylen, bool copy_key) 2534 { 2535 return ucl_object_insert_key_common(top, elt, key, keylen, copy_key, false, false); 2536 } 2537 2538 bool ucl_object_insert_key_merged(ucl_object_t *top, ucl_object_t *elt, 2539 const char *key, size_t keylen, bool copy_key) 2540 { 2541 return ucl_object_insert_key_common(top, elt, key, keylen, copy_key, true, false); 2542 } 2543 2544 bool ucl_object_replace_key(ucl_object_t *top, ucl_object_t *elt, 2545 const char *key, size_t keylen, bool copy_key) 2546 { 2547 return ucl_object_insert_key_common(top, elt, key, keylen, copy_key, false, true); 2548 } 2549 2550 bool ucl_object_merge(ucl_object_t *top, ucl_object_t *elt, bool copy) 2551 { 2552 ucl_object_t *cur = NULL, *cp = NULL, *found = NULL; 2553 ucl_object_iter_t iter = NULL; 2554 2555 if (top == NULL || elt == NULL) { 2556 return false; 2557 } 2558 2559 if (top->type == UCL_ARRAY) { 2560 if (elt->type == UCL_ARRAY) { 2561 /* Merge two arrays */ 2562 return ucl_array_merge(top, elt, copy); 2563 } 2564 else { 2565 if (copy) { 2566 ucl_array_append(top, ucl_object_copy(elt)); 2567 2568 return true; 2569 } 2570 else { 2571 ucl_array_append(top, ucl_object_ref(elt)); 2572 2573 return true; 2574 } 2575 } 2576 } 2577 else if (top->type == UCL_OBJECT) { 2578 if (elt->type == UCL_OBJECT) { 2579 /* Mix two hashes */ 2580 while ((cur = (ucl_object_t *) ucl_hash_iterate(elt->value.ov, 2581 &iter))) { 2582 2583 if (copy) { 2584 cp = ucl_object_copy(cur); 2585 } 2586 else { 2587 cp = ucl_object_ref(cur); 2588 } 2589 2590 found = __DECONST(ucl_object_t *, 2591 ucl_hash_search(top->value.ov, cp->key, cp->keylen)); 2592 2593 if (found == NULL) { 2594 /* The key does not exist */ 2595 top->value.ov = ucl_hash_insert_object(top->value.ov, cp, 2596 false); 2597 top->len++; 2598 } 2599 else { 2600 /* The key already exists, merge it recursively */ 2601 if (found->type == UCL_OBJECT || found->type == UCL_ARRAY) { 2602 if (!ucl_object_merge(found, cp, copy)) { 2603 return false; 2604 } 2605 ucl_object_unref(cp); 2606 } 2607 else { 2608 ucl_hash_replace(top->value.ov, found, cp); 2609 ucl_object_unref(found); 2610 } 2611 } 2612 } 2613 } 2614 else { 2615 if (copy) { 2616 cp = ucl_object_copy(elt); 2617 } 2618 else { 2619 cp = ucl_object_ref(elt); 2620 } 2621 2622 found = __DECONST(ucl_object_t *, 2623 ucl_hash_search(top->value.ov, cp->key, cp->keylen)); 2624 2625 if (found == NULL) { 2626 /* The key does not exist */ 2627 top->value.ov = ucl_hash_insert_object(top->value.ov, cp, 2628 false); 2629 top->len++; 2630 } 2631 else { 2632 /* The key already exists, merge it recursively */ 2633 if (found->type == UCL_OBJECT || found->type == UCL_ARRAY) { 2634 if (!ucl_object_merge(found, cp, copy)) { 2635 return false; 2636 } 2637 ucl_object_unref(cp); 2638 } 2639 else { 2640 ucl_hash_replace(top->value.ov, found, cp); 2641 ucl_object_unref(found); 2642 } 2643 } 2644 } 2645 } 2646 else { 2647 /* Cannot merge trivial objects */ 2648 return false; 2649 } 2650 2651 return true; 2652 } 2653 2654 const ucl_object_t * 2655 ucl_object_lookup_len(const ucl_object_t *obj, const char *key, size_t klen) 2656 { 2657 const ucl_object_t *ret; 2658 ucl_object_t srch; 2659 2660 if (obj == NULL || obj->type != UCL_OBJECT || key == NULL) { 2661 return NULL; 2662 } 2663 2664 srch.key = key; 2665 srch.keylen = klen; 2666 ret = ucl_hash_search_obj(obj->value.ov, &srch); 2667 2668 return ret; 2669 } 2670 2671 const ucl_object_t * 2672 ucl_object_lookup(const ucl_object_t *obj, const char *key) 2673 { 2674 if (key == NULL) { 2675 return NULL; 2676 } 2677 2678 return ucl_object_lookup_len(obj, key, strlen(key)); 2679 } 2680 2681 const ucl_object_t * 2682 ucl_object_lookup_any(const ucl_object_t *obj, 2683 const char *key, ...) 2684 { 2685 va_list ap; 2686 const ucl_object_t *ret = NULL; 2687 const char *nk = NULL; 2688 2689 if (obj == NULL || key == NULL) { 2690 return NULL; 2691 } 2692 2693 ret = ucl_object_lookup_len(obj, key, strlen(key)); 2694 2695 if (ret == NULL) { 2696 va_start(ap, key); 2697 2698 while (ret == NULL) { 2699 nk = va_arg(ap, const char *); 2700 2701 if (nk == NULL) { 2702 break; 2703 } 2704 else { 2705 ret = ucl_object_lookup_len(obj, nk, strlen(nk)); 2706 } 2707 } 2708 2709 va_end(ap); 2710 } 2711 2712 return ret; 2713 } 2714 2715 const ucl_object_t * 2716 ucl_object_iterate_with_error(const ucl_object_t *obj, ucl_object_iter_t *iter, bool expand_values, 2717 int *ep) 2718 { 2719 const ucl_object_t *elt = NULL; 2720 2721 if (obj == NULL || iter == NULL) { 2722 return NULL; 2723 } 2724 2725 if (expand_values) { 2726 switch (obj->type) { 2727 case UCL_OBJECT: 2728 return (const ucl_object_t *) ucl_hash_iterate2(obj->value.ov, iter, ep); 2729 break; 2730 case UCL_ARRAY: { 2731 unsigned int idx; 2732 UCL_ARRAY_GET(vec, obj); 2733 idx = (unsigned int) (uintptr_t) (*iter); 2734 2735 if (vec != NULL) { 2736 while (idx < kv_size(*vec)) { 2737 if ((elt = kv_A(*vec, idx)) != NULL) { 2738 idx++; 2739 break; 2740 } 2741 idx++; 2742 } 2743 *iter = (void *) (uintptr_t) idx; 2744 } 2745 2746 return elt; 2747 break; 2748 } 2749 default: 2750 /* Go to linear iteration */ 2751 break; 2752 } 2753 } 2754 /* Treat everything as a linear list */ 2755 elt = *iter; 2756 if (elt == NULL) { 2757 elt = obj; 2758 } 2759 else if (elt == obj) { 2760 return NULL; 2761 } 2762 *iter = __DECONST(void *, elt->next ? elt->next : obj); 2763 return elt; 2764 2765 /* Not reached */ 2766 return NULL; 2767 } 2768 2769 void 2770 ucl_object_iterate_end(const ucl_object_t *obj, ucl_object_iter_t *iter) 2771 { 2772 if (iter == NULL || *iter == NULL) { 2773 return; 2774 } 2775 2776 if (obj != NULL && obj->type == UCL_OBJECT) { 2777 ucl_hash_iterate_free(*iter); 2778 } 2779 2780 *iter = NULL; 2781 } 2782 2783 enum ucl_safe_iter_flags { 2784 UCL_ITERATE_FLAG_UNDEFINED = 0, 2785 UCL_ITERATE_FLAG_INSIDE_ARRAY, 2786 UCL_ITERATE_FLAG_INSIDE_OBJECT, 2787 UCL_ITERATE_FLAG_IMPLICIT, 2788 UCL_ITERATE_FLAG_EXCEPTION 2789 }; 2790 2791 static const char safe_iter_magic[4] = {'u', 'i', 't', 'e'}; 2792 struct ucl_object_safe_iter { 2793 char magic[4]; /* safety check */ 2794 uint32_t flags; 2795 const ucl_object_t *impl_it; /* implicit object iteration */ 2796 ucl_object_iter_t expl_it; /* explicit iteration */ 2797 }; 2798 2799 #define UCL_SAFE_ITER(ptr) (struct ucl_object_safe_iter *) (ptr) 2800 #define UCL_SAFE_ITER_CHECK(it) \ 2801 do { \ 2802 assert(it != NULL); \ 2803 assert(memcmp(it->magic, safe_iter_magic, sizeof(it->magic)) == 0); \ 2804 } while (0) 2805 2806 ucl_object_iter_t 2807 ucl_object_iterate_new(const ucl_object_t *obj) 2808 { 2809 struct ucl_object_safe_iter *it; 2810 2811 it = UCL_ALLOC(sizeof(*it)); 2812 if (it != NULL) { 2813 memcpy(it->magic, safe_iter_magic, sizeof(it->magic)); 2814 it->flags = UCL_ITERATE_FLAG_UNDEFINED; 2815 it->expl_it = NULL; 2816 it->impl_it = obj; 2817 } 2818 2819 return (ucl_object_iter_t) it; 2820 } 2821 2822 bool ucl_object_iter_chk_excpn(ucl_object_iter_t *it) 2823 { 2824 struct ucl_object_safe_iter *rit = UCL_SAFE_ITER(it); 2825 2826 UCL_SAFE_ITER_CHECK(rit); 2827 2828 return (rit->flags == UCL_ITERATE_FLAG_EXCEPTION); 2829 } 2830 2831 ucl_object_iter_t 2832 ucl_object_iterate_reset(ucl_object_iter_t it, const ucl_object_t *obj) 2833 { 2834 struct ucl_object_safe_iter *rit = UCL_SAFE_ITER(it); 2835 2836 UCL_SAFE_ITER_CHECK(rit); 2837 2838 if (rit->expl_it != NULL) { 2839 if (rit->flags == UCL_ITERATE_FLAG_INSIDE_OBJECT) { 2840 UCL_FREE(sizeof(*rit->expl_it), rit->expl_it); 2841 } 2842 } 2843 2844 rit->impl_it = obj; 2845 rit->expl_it = NULL; 2846 rit->flags = UCL_ITERATE_FLAG_UNDEFINED; 2847 2848 return it; 2849 } 2850 2851 const ucl_object_t * 2852 ucl_object_iterate_safe(ucl_object_iter_t it, bool expand_values) 2853 { 2854 return ucl_object_iterate_full(it, expand_values ? UCL_ITERATE_BOTH : UCL_ITERATE_IMPLICIT); 2855 } 2856 2857 const ucl_object_t * 2858 ucl_object_iterate_full(ucl_object_iter_t it, enum ucl_iterate_type type) 2859 { 2860 struct ucl_object_safe_iter *rit = UCL_SAFE_ITER(it); 2861 const ucl_object_t *ret = NULL; 2862 int ern; 2863 2864 UCL_SAFE_ITER_CHECK(rit); 2865 2866 if (rit->impl_it == NULL) { 2867 return NULL; 2868 } 2869 2870 if (rit->impl_it->type == UCL_OBJECT) { 2871 rit->flags = UCL_ITERATE_FLAG_INSIDE_OBJECT; 2872 ret = ucl_object_iterate_with_error(rit->impl_it, &rit->expl_it, true, &ern); 2873 2874 if (ret == NULL && ern != 0) { 2875 rit->flags = UCL_ITERATE_FLAG_EXCEPTION; 2876 return NULL; 2877 } 2878 2879 if (ret == NULL && (type & UCL_ITERATE_IMPLICIT)) { 2880 /* Need to switch to another implicit object in chain */ 2881 rit->impl_it = rit->impl_it->next; 2882 rit->expl_it = NULL; 2883 2884 return ucl_object_iterate_safe(it, type); 2885 } 2886 } 2887 else if (rit->impl_it->type == UCL_ARRAY) { 2888 rit->flags = UCL_ITERATE_FLAG_INSIDE_ARRAY; 2889 ret = ucl_object_iterate(rit->impl_it, &rit->expl_it, true); 2890 2891 if (ret == NULL && (type & UCL_ITERATE_IMPLICIT)) { 2892 /* Need to switch to another implicit object in chain */ 2893 rit->impl_it = rit->impl_it->next; 2894 rit->expl_it = NULL; 2895 2896 return ucl_object_iterate_safe(it, type); 2897 } 2898 } 2899 else { 2900 /* Just iterate over the implicit array */ 2901 rit->flags = UCL_ITERATE_FLAG_IMPLICIT; 2902 ret = rit->impl_it; 2903 rit->impl_it = rit->impl_it->next; 2904 2905 if (type & UCL_ITERATE_EXPLICIT) { 2906 /* We flatten objects if need to expand values */ 2907 if (ret->type == UCL_OBJECT || ret->type == UCL_ARRAY) { 2908 return ucl_object_iterate_safe(it, type); 2909 } 2910 } 2911 } 2912 2913 return ret; 2914 } 2915 2916 void ucl_object_iterate_free(ucl_object_iter_t it) 2917 { 2918 struct ucl_object_safe_iter *rit = UCL_SAFE_ITER(it); 2919 2920 UCL_SAFE_ITER_CHECK(rit); 2921 2922 if (rit->expl_it != NULL) { 2923 if (rit->flags == UCL_ITERATE_FLAG_INSIDE_OBJECT) { 2924 UCL_FREE(sizeof(*rit->expl_it), rit->expl_it); 2925 } 2926 } 2927 2928 UCL_FREE(sizeof(*rit), it); 2929 } 2930 2931 const ucl_object_t * 2932 ucl_object_lookup_path(const ucl_object_t *top, const char *path_in) 2933 { 2934 return ucl_object_lookup_path_char(top, path_in, '.'); 2935 } 2936 2937 2938 const ucl_object_t * 2939 ucl_object_lookup_path_char(const ucl_object_t *top, const char *path_in, const char sep) 2940 { 2941 const ucl_object_t *o = NULL, *found; 2942 const char *p, *c; 2943 char *err_str; 2944 unsigned index; 2945 2946 if (path_in == NULL || top == NULL) { 2947 return NULL; 2948 } 2949 2950 found = NULL; 2951 p = path_in; 2952 2953 /* Skip leading dots */ 2954 while (*p == sep) { 2955 p++; 2956 } 2957 2958 c = p; 2959 while (*p != '\0') { 2960 p++; 2961 if (*p == sep || *p == '\0') { 2962 if (p > c) { 2963 switch (top->type) { 2964 case UCL_ARRAY: 2965 /* Key should be an int */ 2966 index = strtoul(c, &err_str, 10); 2967 if (err_str != NULL && (*err_str != sep && *err_str != '\0')) { 2968 return NULL; 2969 } 2970 o = ucl_array_find_index(top, index); 2971 break; 2972 default: 2973 o = ucl_object_lookup_len(top, c, p - c); 2974 break; 2975 } 2976 if (o == NULL) { 2977 return NULL; 2978 } 2979 top = o; 2980 } 2981 if (*p != '\0') { 2982 c = p + 1; 2983 } 2984 } 2985 } 2986 found = o; 2987 2988 return found; 2989 } 2990 2991 2992 ucl_object_t * 2993 ucl_object_new(void) 2994 { 2995 return ucl_object_typed_new(UCL_NULL); 2996 } 2997 2998 ucl_object_t * 2999 ucl_object_typed_new(ucl_type_t type) 3000 { 3001 return ucl_object_new_full(type, 0); 3002 } 3003 3004 ucl_object_t * 3005 ucl_object_new_full(ucl_type_t type, unsigned priority) 3006 { 3007 ucl_object_t *new; 3008 3009 if (type != UCL_USERDATA) { 3010 new = UCL_ALLOC(sizeof(ucl_object_t)); 3011 if (new != NULL) { 3012 memset(new, 0, sizeof(ucl_object_t)); 3013 new->ref = 1; 3014 new->type = (type <= UCL_NULL ? type : UCL_NULL); 3015 new->next = NULL; 3016 new->prev = new; 3017 ucl_object_set_priority(new, priority); 3018 3019 if (type == UCL_ARRAY) { 3020 new->value.av = UCL_ALLOC(sizeof(ucl_array_t)); 3021 if (new->value.av) { 3022 memset(new->value.av, 0, sizeof(ucl_array_t)); 3023 UCL_ARRAY_GET(vec, new); 3024 3025 /* Preallocate some space for arrays */ 3026 kv_resize_safe(ucl_object_t *, *vec, 8, enomem); 3027 } 3028 } 3029 } 3030 } 3031 else { 3032 new = ucl_object_new_userdata(NULL, NULL, NULL); 3033 ucl_object_set_priority(new, priority); 3034 } 3035 enomem: 3036 return new; 3037 } 3038 3039 bool ucl_object_reserve(ucl_object_t *obj, size_t reserved) 3040 { 3041 if (obj->type == UCL_ARRAY) { 3042 UCL_ARRAY_GET(vec, obj); 3043 3044 if (vec == NULL) { 3045 /* Allocate array storage if not present (e.g., copied empty array) */ 3046 vec = UCL_ALLOC(sizeof(*vec)); 3047 if (vec == NULL) { 3048 return false; 3049 } 3050 kv_init(*vec); 3051 obj->value.av = (void *)vec; 3052 } 3053 3054 if (vec->m < reserved) { 3055 /* Preallocate some space for arrays */ 3056 kv_resize_safe(ucl_object_t *, *vec, reserved, e0); 3057 } 3058 } 3059 else if (obj->type == UCL_OBJECT) { 3060 ucl_hash_reserve(obj->value.ov, reserved); 3061 } 3062 return true; 3063 e0: 3064 return false; 3065 } 3066 3067 ucl_object_t * 3068 ucl_object_new_userdata(ucl_userdata_dtor dtor, 3069 ucl_userdata_emitter emitter, 3070 void *ptr) 3071 { 3072 struct ucl_object_userdata *new; 3073 size_t nsize = sizeof(*new); 3074 3075 new = UCL_ALLOC(nsize); 3076 if (new != NULL) { 3077 memset(new, 0, nsize); 3078 new->obj.ref = 1; 3079 new->obj.type = UCL_USERDATA; 3080 new->obj.next = NULL; 3081 new->obj.prev = (ucl_object_t *) new; 3082 new->dtor = dtor; 3083 new->emitter = emitter; 3084 new->obj.value.ud = ptr; 3085 } 3086 3087 return (ucl_object_t *) new; 3088 } 3089 3090 ucl_type_t 3091 ucl_object_type(const ucl_object_t *obj) 3092 { 3093 if (obj == NULL) { 3094 return UCL_NULL; 3095 } 3096 3097 return obj->type; 3098 } 3099 3100 ucl_object_t * 3101 ucl_object_fromstring(const char *str) 3102 { 3103 return ucl_object_fromstring_common(str, 0, UCL_STRING_RAW); 3104 } 3105 3106 ucl_object_t * 3107 ucl_object_fromlstring(const char *str, size_t len) 3108 { 3109 return ucl_object_fromstring_common(str, len, UCL_STRING_RAW); 3110 } 3111 3112 ucl_object_t * 3113 ucl_object_fromint(int64_t iv) 3114 { 3115 ucl_object_t *obj; 3116 3117 obj = ucl_object_new(); 3118 if (obj != NULL) { 3119 obj->type = UCL_INT; 3120 obj->value.iv = iv; 3121 } 3122 3123 return obj; 3124 } 3125 3126 ucl_object_t * 3127 ucl_object_fromdouble(double dv) 3128 { 3129 ucl_object_t *obj; 3130 3131 obj = ucl_object_new(); 3132 if (obj != NULL) { 3133 obj->type = UCL_FLOAT; 3134 obj->value.dv = dv; 3135 } 3136 3137 return obj; 3138 } 3139 3140 ucl_object_t * 3141 ucl_object_frombool(bool bv) 3142 { 3143 ucl_object_t *obj; 3144 3145 obj = ucl_object_new(); 3146 if (obj != NULL) { 3147 obj->type = UCL_BOOLEAN; 3148 obj->value.iv = bv; 3149 } 3150 3151 return obj; 3152 } 3153 3154 bool ucl_array_append(ucl_object_t *top, ucl_object_t *elt) 3155 { 3156 if (top->type != UCL_ARRAY) { 3157 return false; 3158 } 3159 3160 UCL_ARRAY_GET(vec, top); 3161 3162 if (elt == NULL || top == NULL) { 3163 return false; 3164 } 3165 3166 if (vec == NULL) { 3167 vec = UCL_ALLOC(sizeof(*vec)); 3168 3169 if (vec == NULL) { 3170 return false; 3171 } 3172 3173 kv_init(*vec); 3174 top->value.av = (void *) vec; 3175 } 3176 3177 kv_push_safe(ucl_object_t *, *vec, elt, e0); 3178 3179 top->len++; 3180 3181 return true; 3182 e0: 3183 return false; 3184 } 3185 3186 bool ucl_array_prepend(ucl_object_t *top, ucl_object_t *elt) 3187 { 3188 if (top->type != UCL_ARRAY) { 3189 return false; 3190 } 3191 3192 UCL_ARRAY_GET(vec, top); 3193 3194 if (elt == NULL || top == NULL) { 3195 return false; 3196 } 3197 3198 if (vec == NULL) { 3199 vec = UCL_ALLOC(sizeof(*vec)); 3200 kv_init(*vec); 3201 top->value.av = (void *) vec; 3202 kv_push_safe(ucl_object_t *, *vec, elt, e0); 3203 } 3204 else { 3205 /* Slow O(n) algorithm */ 3206 kv_prepend_safe(ucl_object_t *, *vec, elt, e0); 3207 } 3208 3209 top->len++; 3210 3211 return true; 3212 e0: 3213 return false; 3214 } 3215 3216 bool ucl_array_merge(ucl_object_t *top, ucl_object_t *elt, bool copy) 3217 { 3218 unsigned i; 3219 ucl_object_t *cp = NULL; 3220 ucl_object_t **obj; 3221 3222 if (elt == NULL || top == NULL || top->type != UCL_ARRAY || elt->type != UCL_ARRAY) { 3223 return false; 3224 } 3225 3226 if (copy) { 3227 cp = ucl_object_copy(elt); 3228 } 3229 else { 3230 cp = ucl_object_ref(elt); 3231 } 3232 3233 UCL_ARRAY_GET(v1, top); 3234 UCL_ARRAY_GET(v2, cp); 3235 3236 if (v1 && v2) { 3237 kv_concat_safe(ucl_object_t *, *v1, *v2, e0); 3238 3239 for (i = v2->n; i < v1->n; i++) { 3240 obj = &kv_A(*v1, i); 3241 if (*obj == NULL) { 3242 continue; 3243 } 3244 top->len++; 3245 } 3246 } 3247 3248 return true; 3249 e0: 3250 return false; 3251 } 3252 3253 ucl_object_t * 3254 ucl_array_delete(ucl_object_t *top, ucl_object_t *elt) 3255 { 3256 if (top->type != UCL_ARRAY) { 3257 return NULL; 3258 } 3259 3260 UCL_ARRAY_GET(vec, top); 3261 ucl_object_t *ret = NULL; 3262 unsigned i; 3263 3264 if (vec == NULL) { 3265 return NULL; 3266 } 3267 3268 for (i = 0; i < vec->n; i++) { 3269 if (kv_A(*vec, i) == elt) { 3270 kv_del(ucl_object_t *, *vec, i); 3271 ret = elt; 3272 top->len--; 3273 break; 3274 } 3275 } 3276 3277 return ret; 3278 } 3279 3280 const ucl_object_t * 3281 ucl_array_head(const ucl_object_t *top) 3282 { 3283 UCL_ARRAY_GET(vec, top); 3284 3285 if (vec == NULL || top == NULL || top->type != UCL_ARRAY || 3286 top->value.av == NULL) { 3287 return NULL; 3288 } 3289 3290 return (vec->n > 0 ? vec->a[0] : NULL); 3291 } 3292 3293 const ucl_object_t * 3294 ucl_array_tail(const ucl_object_t *top) 3295 { 3296 UCL_ARRAY_GET(vec, top); 3297 3298 if (top == NULL || top->type != UCL_ARRAY || top->value.av == NULL) { 3299 return NULL; 3300 } 3301 3302 return (vec->n > 0 ? vec->a[vec->n - 1] : NULL); 3303 } 3304 3305 ucl_object_t * 3306 ucl_array_pop_last(ucl_object_t *top) 3307 { 3308 if (top->type != UCL_ARRAY) { 3309 return NULL; 3310 } 3311 3312 UCL_ARRAY_GET(vec, top); 3313 ucl_object_t **obj, *ret = NULL; 3314 3315 if (vec != NULL && vec->n > 0) { 3316 obj = &kv_A(*vec, vec->n - 1); 3317 ret = *obj; 3318 kv_del(ucl_object_t *, *vec, vec->n - 1); 3319 top->len--; 3320 } 3321 3322 return ret; 3323 } 3324 3325 ucl_object_t * 3326 ucl_array_pop_first(ucl_object_t *top) 3327 { 3328 if (top->type != UCL_ARRAY) { 3329 return NULL; 3330 } 3331 3332 UCL_ARRAY_GET(vec, top); 3333 ucl_object_t **obj, *ret = NULL; 3334 3335 if (vec != NULL && vec->n > 0) { 3336 obj = &kv_A(*vec, 0); 3337 ret = *obj; 3338 kv_del(ucl_object_t *, *vec, 0); 3339 top->len--; 3340 } 3341 3342 return ret; 3343 } 3344 3345 unsigned int 3346 ucl_array_size(const ucl_object_t *top) 3347 { 3348 if (top == NULL || top->type != UCL_ARRAY) { 3349 return 0; 3350 } 3351 3352 UCL_ARRAY_GET(vec, top); 3353 3354 if (vec != NULL) { 3355 return kv_size(*vec); 3356 } 3357 3358 return 0; 3359 } 3360 3361 const ucl_object_t * 3362 ucl_array_find_index(const ucl_object_t *top, unsigned int index) 3363 { 3364 if (top->type != UCL_ARRAY) { 3365 return NULL; 3366 } 3367 3368 UCL_ARRAY_GET(vec, top); 3369 3370 if (vec != NULL && vec->n > 0 && index < vec->n) { 3371 return kv_A(*vec, index); 3372 } 3373 3374 return NULL; 3375 } 3376 3377 unsigned int 3378 ucl_array_index_of(ucl_object_t *top, ucl_object_t *elt) 3379 { 3380 if (top->type != UCL_ARRAY) { 3381 return (unsigned int) (-1); 3382 } 3383 3384 UCL_ARRAY_GET(vec, top); 3385 unsigned i; 3386 3387 if (vec == NULL) { 3388 return (unsigned int) (-1); 3389 } 3390 3391 for (i = 0; i < vec->n; i++) { 3392 if (kv_A(*vec, i) == elt) { 3393 return i; 3394 } 3395 } 3396 3397 return (unsigned int) (-1); 3398 } 3399 3400 ucl_object_t * 3401 ucl_array_replace_index(ucl_object_t *top, ucl_object_t *elt, 3402 unsigned int index) 3403 { 3404 if (top->type != UCL_ARRAY) { 3405 return NULL; 3406 } 3407 3408 UCL_ARRAY_GET(vec, top); 3409 ucl_object_t *ret = NULL; 3410 3411 if (vec != NULL && vec->n > 0 && index < vec->n) { 3412 ret = kv_A(*vec, index); 3413 kv_A(*vec, index) = elt; 3414 } 3415 3416 return ret; 3417 } 3418 3419 ucl_object_t * 3420 ucl_elt_append(ucl_object_t *head, ucl_object_t *elt) 3421 { 3422 3423 if (head == NULL) { 3424 elt->next = NULL; 3425 elt->prev = elt; 3426 head = elt; 3427 } 3428 else { 3429 if (head->type == UCL_USERDATA) { 3430 /* Userdata objects are VERY special! */ 3431 struct ucl_object_userdata *ud = (struct ucl_object_userdata *) head; 3432 elt->prev = ud->obj.prev; 3433 ud->obj.prev->next = elt; 3434 ud->obj.prev = elt; 3435 elt->next = NULL; 3436 } 3437 else { 3438 elt->prev = head->prev; 3439 head->prev->next = elt; 3440 head->prev = elt; 3441 elt->next = NULL; 3442 } 3443 } 3444 3445 return head; 3446 } 3447 3448 bool ucl_object_todouble_safe(const ucl_object_t *obj, double *target) 3449 { 3450 if (obj == NULL || target == NULL) { 3451 return false; 3452 } 3453 switch (obj->type) { 3454 case UCL_INT: 3455 *target = obj->value.iv; /* Probably could cause overflow */ 3456 break; 3457 case UCL_FLOAT: 3458 case UCL_TIME: 3459 *target = obj->value.dv; 3460 break; 3461 default: 3462 return false; 3463 } 3464 3465 return true; 3466 } 3467 3468 double 3469 ucl_object_todouble(const ucl_object_t *obj) 3470 { 3471 double result = 0.; 3472 3473 ucl_object_todouble_safe(obj, &result); 3474 return result; 3475 } 3476 3477 bool ucl_object_toint_safe(const ucl_object_t *obj, int64_t *target) 3478 { 3479 if (obj == NULL || target == NULL) { 3480 return false; 3481 } 3482 switch (obj->type) { 3483 case UCL_INT: 3484 *target = obj->value.iv; 3485 break; 3486 case UCL_FLOAT: 3487 case UCL_TIME: 3488 *target = obj->value.dv; /* Losing of decimal points */ 3489 break; 3490 default: 3491 return false; 3492 } 3493 3494 return true; 3495 } 3496 3497 int64_t 3498 ucl_object_toint(const ucl_object_t *obj) 3499 { 3500 int64_t result = 0; 3501 3502 ucl_object_toint_safe(obj, &result); 3503 return result; 3504 } 3505 3506 bool ucl_object_toboolean_safe(const ucl_object_t *obj, bool *target) 3507 { 3508 if (obj == NULL || target == NULL) { 3509 return false; 3510 } 3511 switch (obj->type) { 3512 case UCL_BOOLEAN: 3513 *target = (obj->value.iv == true); 3514 break; 3515 default: 3516 return false; 3517 } 3518 3519 return true; 3520 } 3521 3522 bool ucl_object_toboolean(const ucl_object_t *obj) 3523 { 3524 bool result = false; 3525 3526 ucl_object_toboolean_safe(obj, &result); 3527 return result; 3528 } 3529 3530 bool ucl_object_tostring_safe(const ucl_object_t *obj, const char **target) 3531 { 3532 if (obj == NULL || target == NULL) { 3533 return false; 3534 } 3535 3536 switch (obj->type) { 3537 case UCL_STRING: 3538 if (!(obj->flags & UCL_OBJECT_BINARY)) { 3539 *target = ucl_copy_value_trash(obj); 3540 } 3541 break; 3542 default: 3543 return false; 3544 } 3545 3546 return true; 3547 } 3548 3549 const char * 3550 ucl_object_tostring(const ucl_object_t *obj) 3551 { 3552 const char *result = NULL; 3553 3554 ucl_object_tostring_safe(obj, &result); 3555 return result; 3556 } 3557 3558 const char * 3559 ucl_object_tostring_forced(const ucl_object_t *obj) 3560 { 3561 /* TODO: For binary strings we might encode string here */ 3562 if (!(obj->flags & UCL_OBJECT_BINARY)) { 3563 return ucl_copy_value_trash(obj); 3564 } 3565 3566 return NULL; 3567 } 3568 3569 bool ucl_object_tolstring_safe(const ucl_object_t *obj, const char **target, size_t *tlen) 3570 { 3571 if (obj == NULL || target == NULL) { 3572 return false; 3573 } 3574 switch (obj->type) { 3575 case UCL_STRING: 3576 *target = obj->value.sv; 3577 if (tlen != NULL) { 3578 *tlen = obj->len; 3579 } 3580 break; 3581 default: 3582 return false; 3583 } 3584 3585 return true; 3586 } 3587 3588 const char * 3589 ucl_object_tolstring(const ucl_object_t *obj, size_t *tlen) 3590 { 3591 const char *result = NULL; 3592 3593 ucl_object_tolstring_safe(obj, &result, tlen); 3594 return result; 3595 } 3596 3597 const char * 3598 ucl_object_key(const ucl_object_t *obj) 3599 { 3600 return ucl_copy_key_trash(obj); 3601 } 3602 3603 const char * 3604 ucl_object_keyl(const ucl_object_t *obj, size_t *len) 3605 { 3606 if (len == NULL || obj == NULL) { 3607 return NULL; 3608 } 3609 *len = obj->keylen; 3610 return obj->key; 3611 } 3612 3613 ucl_object_t * 3614 ucl_object_ref(const ucl_object_t *obj) 3615 { 3616 ucl_object_t *res = NULL; 3617 3618 if (obj != NULL) { 3619 if (obj->flags & UCL_OBJECT_EPHEMERAL) { 3620 /* 3621 * Use deep copy for ephemeral objects, note that its refcount 3622 * is NOT increased, since ephemeral objects does not need refcount 3623 * at all 3624 */ 3625 res = ucl_object_copy(obj); 3626 } 3627 else { 3628 res = __DECONST(ucl_object_t *, obj); 3629 #ifdef HAVE_ATOMIC_BUILTINS 3630 (void) __sync_add_and_fetch(&res->ref, 1); 3631 #else 3632 res->ref++; 3633 #endif 3634 } 3635 } 3636 return res; 3637 } 3638 3639 static ucl_object_t * 3640 ucl_object_copy_internal(const ucl_object_t *other, bool allow_array) 3641 { 3642 3643 ucl_object_t *new; 3644 ucl_object_iter_t it = NULL; 3645 const ucl_object_t *cur; 3646 size_t sz = sizeof(*new); 3647 3648 if (other->type == UCL_USERDATA) { 3649 sz = sizeof(struct ucl_object_userdata); 3650 } 3651 new = UCL_ALLOC(sz); 3652 3653 if (new != NULL) { 3654 memcpy(new, other, sz); 3655 if (other->flags & UCL_OBJECT_EPHEMERAL) { 3656 /* Copied object is always non ephemeral */ 3657 new->flags &= ~UCL_OBJECT_EPHEMERAL; 3658 } 3659 new->ref = 1; 3660 /* Unlink from others */ 3661 new->next = NULL; 3662 new->prev = new; 3663 3664 /* deep copy of values stored */ 3665 if (other->trash_stack[UCL_TRASH_KEY] != NULL) { 3666 new->trash_stack[UCL_TRASH_KEY] = NULL; 3667 if (other->key == (const char *) other->trash_stack[UCL_TRASH_KEY]) { 3668 new->trash_stack[UCL_TRASH_KEY] = UCL_ALLOC(other->keylen + 1); 3669 memcpy(new->trash_stack[UCL_TRASH_KEY], other->trash_stack[UCL_TRASH_KEY], other->keylen); 3670 new->trash_stack[UCL_TRASH_KEY][other->keylen] = '\0'; 3671 new->key = new->trash_stack[UCL_TRASH_KEY]; 3672 } 3673 } 3674 if (other->trash_stack[UCL_TRASH_VALUE] != NULL) { 3675 new->trash_stack[UCL_TRASH_VALUE] = 3676 UCL_STRDUP(other->trash_stack[UCL_TRASH_VALUE]); 3677 if (new->type == UCL_STRING) { 3678 new->value.sv = new->trash_stack[UCL_TRASH_VALUE]; 3679 } 3680 } 3681 3682 if (other->type == UCL_ARRAY || other->type == UCL_OBJECT) { 3683 /* reset old value and length since we will re-add elements below */ 3684 memset(&new->value, 0, sizeof(new->value)); 3685 new->len = 0; 3686 3687 while ((cur = ucl_object_iterate(other, &it, true)) != NULL) { 3688 if (other->type == UCL_ARRAY) { 3689 ucl_array_append(new, ucl_object_copy_internal(cur, false)); 3690 } 3691 else { 3692 ucl_object_t *cp = ucl_object_copy_internal(cur, true); 3693 if (cp != NULL) { 3694 ucl_object_insert_key(new, cp, cp->key, cp->keylen, 3695 false); 3696 } 3697 } 3698 } 3699 } 3700 else if (allow_array && other->next != NULL) { 3701 LL_FOREACH(other->next, cur) 3702 { 3703 ucl_object_t *cp = ucl_object_copy_internal(cur, false); 3704 if (cp != NULL) { 3705 DL_APPEND(new, cp); 3706 } 3707 } 3708 } 3709 } 3710 3711 return new; 3712 } 3713 3714 ucl_object_t * 3715 ucl_object_copy(const ucl_object_t *other) 3716 { 3717 return ucl_object_copy_internal(other, true); 3718 } 3719 3720 void ucl_object_unref(ucl_object_t *obj) 3721 { 3722 if (obj != NULL) { 3723 #ifdef HAVE_ATOMIC_BUILTINS 3724 unsigned int rc = __sync_sub_and_fetch(&obj->ref, 1); 3725 if (rc == 0) { 3726 #else 3727 if (--obj->ref == 0) { 3728 #endif 3729 ucl_object_free_internal(obj, true, ucl_object_dtor_unref); 3730 } 3731 } 3732 } 3733 3734 int ucl_object_compare(const ucl_object_t *o1, const ucl_object_t *o2) 3735 { 3736 const ucl_object_t *it1, *it2; 3737 ucl_object_iter_t iter = NULL; 3738 int ret = 0; 3739 3740 if (o1->type != o2->type) { 3741 return (o1->type) - (o2->type); 3742 } 3743 3744 switch (o1->type) { 3745 case UCL_STRING: 3746 if (o1->len == o2->len && o1->len > 0) { 3747 ret = strcmp(ucl_object_tostring(o1), ucl_object_tostring(o2)); 3748 } 3749 else { 3750 ret = o1->len - o2->len; 3751 } 3752 break; 3753 case UCL_FLOAT: 3754 case UCL_INT: 3755 case UCL_TIME: 3756 ret = ucl_object_todouble(o1) - ucl_object_todouble(o2); 3757 break; 3758 case UCL_BOOLEAN: 3759 ret = ucl_object_toboolean(o1) - ucl_object_toboolean(o2); 3760 break; 3761 case UCL_ARRAY: 3762 if (o1->len == o2->len && o1->len > 0) { 3763 UCL_ARRAY_GET(vec1, o1); 3764 UCL_ARRAY_GET(vec2, o2); 3765 unsigned i; 3766 3767 /* Compare all elements in both arrays */ 3768 for (i = 0; i < vec1->n; i++) { 3769 it1 = kv_A(*vec1, i); 3770 it2 = kv_A(*vec2, i); 3771 3772 if (it1 == NULL && it2 != NULL) { 3773 return -1; 3774 } 3775 else if (it2 == NULL && it1 != NULL) { 3776 return 1; 3777 } 3778 else if (it1 != NULL && it2 != NULL) { 3779 ret = ucl_object_compare(it1, it2); 3780 if (ret != 0) { 3781 break; 3782 } 3783 } 3784 } 3785 } 3786 else { 3787 ret = o1->len - o2->len; 3788 } 3789 break; 3790 case UCL_OBJECT: 3791 if (o1->len == o2->len && o1->len > 0) { 3792 while ((it1 = ucl_object_iterate(o1, &iter, true)) != NULL) { 3793 it2 = ucl_object_lookup(o2, ucl_object_key(it1)); 3794 if (it2 == NULL) { 3795 ret = 1; 3796 break; 3797 } 3798 ret = ucl_object_compare(it1, it2); 3799 if (ret != 0) { 3800 break; 3801 } 3802 } 3803 } 3804 else { 3805 ret = o1->len - o2->len; 3806 } 3807 break; 3808 default: 3809 ret = 0; 3810 break; 3811 } 3812 3813 return ret; 3814 } 3815 3816 int ucl_object_compare_qsort(const ucl_object_t **o1, 3817 const ucl_object_t **o2) 3818 { 3819 return ucl_object_compare(*o1, *o2); 3820 } 3821 3822 void ucl_object_array_sort(ucl_object_t *ar, 3823 int (*cmp)(const ucl_object_t **o1, const ucl_object_t **o2)) 3824 { 3825 UCL_ARRAY_GET(vec, ar); 3826 3827 if (cmp == NULL || ar == NULL || ar->type != UCL_ARRAY) { 3828 return; 3829 } 3830 3831 qsort(vec->a, vec->n, sizeof(ucl_object_t *), 3832 (int (*)(const void *, const void *)) cmp); 3833 } 3834 3835 void ucl_object_sort_keys(ucl_object_t *obj, 3836 enum ucl_object_keys_sort_flags how) 3837 { 3838 if (obj != NULL && obj->type == UCL_OBJECT) { 3839 ucl_hash_sort(obj->value.ov, how); 3840 } 3841 } 3842 3843 #define PRIOBITS 4 3844 3845 unsigned int 3846 ucl_object_get_priority(const ucl_object_t *obj) 3847 { 3848 if (obj == NULL) { 3849 return 0; 3850 } 3851 3852 return (obj->flags >> ((sizeof(obj->flags) * NBBY) - PRIOBITS)); 3853 } 3854 3855 void ucl_object_set_priority(ucl_object_t *obj, 3856 unsigned int priority) 3857 { 3858 if (obj != NULL) { 3859 priority &= (0x1 << PRIOBITS) - 1; 3860 priority <<= ((sizeof(obj->flags) * NBBY) - PRIOBITS); 3861 priority |= obj->flags & ((1 << ((sizeof(obj->flags) * NBBY) - 3862 PRIOBITS)) - 3863 1); 3864 obj->flags = priority; 3865 } 3866 } 3867 3868 bool ucl_object_string_to_type(const char *input, ucl_type_t *res) 3869 { 3870 if (strcasecmp(input, "object") == 0) { 3871 *res = UCL_OBJECT; 3872 } 3873 else if (strcasecmp(input, "array") == 0) { 3874 *res = UCL_ARRAY; 3875 } 3876 else if (strcasecmp(input, "integer") == 0) { 3877 *res = UCL_INT; 3878 } 3879 else if (strcasecmp(input, "number") == 0) { 3880 *res = UCL_FLOAT; 3881 } 3882 else if (strcasecmp(input, "string") == 0) { 3883 *res = UCL_STRING; 3884 } 3885 else if (strcasecmp(input, "boolean") == 0) { 3886 *res = UCL_BOOLEAN; 3887 } 3888 else if (strcasecmp(input, "null") == 0) { 3889 *res = UCL_NULL; 3890 } 3891 else if (strcasecmp(input, "userdata") == 0) { 3892 *res = UCL_USERDATA; 3893 } 3894 else { 3895 return false; 3896 } 3897 3898 return true; 3899 } 3900 3901 const char * 3902 ucl_object_type_to_string(ucl_type_t type) 3903 { 3904 const char *res = "unknown"; 3905 3906 switch (type) { 3907 case UCL_OBJECT: 3908 res = "object"; 3909 break; 3910 case UCL_ARRAY: 3911 res = "array"; 3912 break; 3913 case UCL_INT: 3914 res = "integer"; 3915 break; 3916 case UCL_FLOAT: 3917 case UCL_TIME: 3918 res = "number"; 3919 break; 3920 case UCL_STRING: 3921 res = "string"; 3922 break; 3923 case UCL_BOOLEAN: 3924 res = "boolean"; 3925 break; 3926 case UCL_USERDATA: 3927 res = "userdata"; 3928 break; 3929 case UCL_NULL: 3930 res = "null"; 3931 break; 3932 } 3933 3934 return res; 3935 } 3936 3937 const ucl_object_t * 3938 ucl_parser_get_comments(struct ucl_parser *parser) 3939 { 3940 if (parser && parser->comments) { 3941 return parser->comments; 3942 } 3943 3944 return NULL; 3945 } 3946 3947 const ucl_object_t * 3948 ucl_comments_find(const ucl_object_t *comments, 3949 const ucl_object_t *srch) 3950 { 3951 if (comments && srch) { 3952 return ucl_object_lookup_len(comments, (const char *) &srch, 3953 sizeof(void *)); 3954 } 3955 3956 return NULL; 3957 } 3958 3959 bool ucl_comments_move(ucl_object_t *comments, 3960 const ucl_object_t *from, const ucl_object_t *to) 3961 { 3962 const ucl_object_t *found; 3963 ucl_object_t *obj; 3964 3965 if (comments && from && to) { 3966 found = ucl_object_lookup_len(comments, 3967 (const char *) &from, sizeof(void *)); 3968 3969 if (found) { 3970 /* Replace key */ 3971 obj = ucl_object_ref(found); 3972 ucl_object_delete_keyl(comments, (const char *) &from, 3973 sizeof(void *)); 3974 ucl_object_insert_key(comments, obj, (const char *) &to, 3975 sizeof(void *), true); 3976 3977 return true; 3978 } 3979 } 3980 3981 return false; 3982 } 3983 3984 void ucl_comments_add(ucl_object_t *comments, const ucl_object_t *obj, 3985 const char *comment) 3986 { 3987 if (comments && obj && comment) { 3988 ucl_object_insert_key(comments, ucl_object_fromstring(comment), 3989 (const char *) &obj, sizeof(void *), true); 3990 } 3991 } 3992 3993 void ucl_parser_set_include_tracer(struct ucl_parser *parser, 3994 ucl_include_trace_func_t func, 3995 void *user_data) 3996 { 3997 parser->include_trace_func = func; 3998 parser->include_trace_ud = user_data; 3999 } 4000 4001 const char * 4002 ucl_parser_get_cur_file(struct ucl_parser *parser) 4003 { 4004 return parser->cur_file; 4005 } 4006