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