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
ucl_mmap(char * addr,size_t length,int prot,int access,int fd,off_t offset)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
ucl_munmap(void * map,size_t length)133 static int ucl_munmap(void *map, size_t length)
134 {
135 if (!UnmapViewOfFile(map)) {
136 return (-1);
137 }
138 return (0);
139 }
140
ucl_realpath(const char * path,char * resolved_path)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
dirname(char * path)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
basename(char * path)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
ucl_object_dtor_free(ucl_object_t * obj)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
ucl_object_dtor_unref_single(ucl_object_t * obj)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