1 /* Copyright (c) 2013, Vsevolod Stakhov
2 * Copyright (c) 2015 Allan Jude <allanjude@freebsd.org>
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.
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.
26 #include "ucl_internal.h"
27 #include "ucl_chartable.h"
31 #include <stdio.h> /* for snprintf */
35 #include <sys/param.h>
43 #include <libgen.h> /* For dirname */
46 typedef kvec_t(ucl_object_t *) ucl_array_t;
48 #define UCL_ARRAY_GET(ar, obj) ucl_array_t *ar = \
49 (ucl_array_t *)((obj) != NULL ? (obj)->value.av : NULL)
52 #include <openssl/err.h>
53 #include <openssl/sha.h>
54 #include <openssl/rsa.h>
55 #include <openssl/ssl.h>
56 #include <openssl/evp.h>
60 /* Seems to be broken */
61 #define CURL_DISABLE_TYPECHECK 1
62 #include <curl/curl.h>
77 #ifndef PROT_READWRITE
78 #define PROT_READWRITE 3
87 #define MAP_FAILED ((void *) -1)
90 static void *ucl_mmap(char *addr, size_t length, int prot, int access, int fd, off_t offset)
93 HANDLE handle = INVALID_HANDLE_VALUE;
99 handle = CreateFileMapping((HANDLE) _get_osfhandle(fd), 0, PAGE_READONLY, 0, length, 0);
101 map = (void *) MapViewOfFile(handle, FILE_MAP_READ, 0, 0, length);
107 handle = CreateFileMapping((HANDLE) _get_osfhandle(fd), 0, PAGE_READWRITE, 0, length, 0);
109 map = (void *) MapViewOfFile(handle, FILE_MAP_WRITE, 0, 0, length);
115 handle = CreateFileMapping((HANDLE) _get_osfhandle(fd), 0, PAGE_READWRITE, 0, length, 0);
117 map = (void *) MapViewOfFile(handle, FILE_MAP_ALL_ACCESS, 0, 0, length);
122 if (map == (void *) NULL) {
123 return (void *) MAP_FAILED;
125 return (void *) ((char *) map + offset);
128 static int ucl_munmap(void *map,size_t length)
130 if (!UnmapViewOfFile(map)) {
136 static char* ucl_realpath(const char *path, char *resolved_path) {
138 char tmp[MAX_PATH + 1];
139 strncpy(tmp, path, sizeof(tmp)-1);
142 if (*p == '/') *p = '\\';
145 return _fullpath(resolved_path, tmp, MAX_PATH);
148 #define ucl_mmap mmap
149 #define ucl_munmap munmap
150 #define ucl_realpath realpath
153 typedef void (*ucl_object_dtor) (ucl_object_t *obj);
154 static void ucl_object_free_internal (ucl_object_t *obj, bool allow_rec,
155 ucl_object_dtor dtor);
156 static void ucl_object_dtor_unref (ucl_object_t *obj);
159 ucl_object_dtor_free (ucl_object_t *obj)
161 if (obj->trash_stack[UCL_TRASH_KEY] != NULL) {
162 UCL_FREE (obj->hh.keylen, obj->trash_stack[UCL_TRASH_KEY]);
164 if (obj->trash_stack[UCL_TRASH_VALUE] != NULL) {
165 UCL_FREE (obj->len, obj->trash_stack[UCL_TRASH_VALUE]);
167 /* Do not free ephemeral objects */
168 if ((obj->flags & UCL_OBJECT_EPHEMERAL) == 0) {
169 if (obj->type != UCL_USERDATA) {
170 UCL_FREE (sizeof (ucl_object_t), obj);
173 struct ucl_object_userdata *ud = (struct ucl_object_userdata *)obj;
175 ud->dtor (obj->value.ud);
177 UCL_FREE (sizeof (*ud), obj);
183 * This is a helper function that performs exactly the same as
184 * `ucl_object_unref` but it doesn't iterate over elements allowing
185 * to use it for individual elements of arrays and multiple values
188 ucl_object_dtor_unref_single (ucl_object_t *obj)
191 #ifdef HAVE_ATOMIC_BUILTINS
192 unsigned int rc = __sync_sub_and_fetch (&obj->ref, 1);
195 if (--obj->ref == 0) {
197 ucl_object_free_internal (obj, false, ucl_object_dtor_unref);
203 ucl_object_dtor_unref (ucl_object_t *obj)
206 ucl_object_dtor_free (obj);
209 /* This may cause dtor unref being called one more time */
210 ucl_object_dtor_unref_single (obj);
215 ucl_object_free_internal (ucl_object_t *obj, bool allow_rec, ucl_object_dtor dtor)
217 ucl_object_t *tmp, *sub;
219 while (obj != NULL) {
220 if (obj->type == UCL_ARRAY) {
221 UCL_ARRAY_GET (vec, obj);
225 for (i = 0; i < vec->n; i ++) {
226 sub = kv_A (*vec, i);
237 UCL_FREE (sizeof (*vec), vec);
239 obj->value.av = NULL;
241 else if (obj->type == UCL_OBJECT) {
242 if (obj->value.ov != NULL) {
243 ucl_hash_destroy (obj->value.ov, (ucl_hash_free_func)dtor);
245 obj->value.ov = NULL;
258 ucl_object_free (ucl_object_t *obj)
260 ucl_object_free_internal (obj, true, ucl_object_dtor_free);
264 ucl_unescape_json_string (char *str, size_t len)
266 char *t = str, *h = str;
272 /* t is target (tortoise), h is source (hare) */
280 * If \ is last, then do not try to go further
313 h ++; /* u character */
317 for (i = 0; i < 4; i++) {
319 if (isdigit (h[i])) {
322 else if (h[i] >= 'a' && h[i] <= 'f') {
323 uval += h[i] - 'a' + 10;
325 else if (h[i] >= 'A' && h[i] <= 'F') {
326 uval += h[i] - 'A' + 10;
338 else if(uval < 0x800) {
339 t[0] = 0xC0 + ((uval & 0x7C0) >> 6);
340 t[1] = 0x80 + ((uval & 0x03F));
343 else if(uval < 0x10000) {
344 t[0] = 0xE0 + ((uval & 0xF000) >> 12);
345 t[1] = 0x80 + ((uval & 0x0FC0) >> 6);
346 t[2] = 0x80 + ((uval & 0x003F));
350 /* It's not actually supported now */
351 else if(uval <= 0x10FFFF) {
352 t[0] = 0xF0 + ((uval & 0x1C0000) >> 18);
353 t[1] = 0x80 + ((uval & 0x03F000) >> 12);
354 t[2] = 0x80 + ((uval & 0x000FC0) >> 6);
355 t[3] = 0x80 + ((uval & 0x00003F));
363 /* Consume 4 characters of source */
368 len --; /* for '\' character */
397 ucl_copy_key_trash (const ucl_object_t *obj)
399 ucl_object_t *deconst;
404 if (obj->trash_stack[UCL_TRASH_KEY] == NULL && obj->key != NULL) {
405 deconst = __DECONST (ucl_object_t *, obj);
406 deconst->trash_stack[UCL_TRASH_KEY] = malloc (obj->keylen + 1);
407 if (deconst->trash_stack[UCL_TRASH_KEY] != NULL) {
408 memcpy (deconst->trash_stack[UCL_TRASH_KEY], obj->key, obj->keylen);
409 deconst->trash_stack[UCL_TRASH_KEY][obj->keylen] = '\0';
411 deconst->key = obj->trash_stack[UCL_TRASH_KEY];
412 deconst->flags |= UCL_OBJECT_ALLOCATED_KEY;
415 return obj->trash_stack[UCL_TRASH_KEY];
419 ucl_copy_value_trash (const ucl_object_t *obj)
421 ucl_object_t *deconst;
426 if (obj->trash_stack[UCL_TRASH_VALUE] == NULL) {
427 deconst = __DECONST (ucl_object_t *, obj);
428 if (obj->type == UCL_STRING) {
430 /* Special case for strings */
431 if (obj->flags & UCL_OBJECT_BINARY) {
432 deconst->trash_stack[UCL_TRASH_VALUE] = malloc (obj->len);
433 if (deconst->trash_stack[UCL_TRASH_VALUE] != NULL) {
434 memcpy (deconst->trash_stack[UCL_TRASH_VALUE],
437 deconst->value.sv = obj->trash_stack[UCL_TRASH_VALUE];
441 deconst->trash_stack[UCL_TRASH_VALUE] = malloc (obj->len + 1);
442 if (deconst->trash_stack[UCL_TRASH_VALUE] != NULL) {
443 memcpy (deconst->trash_stack[UCL_TRASH_VALUE],
446 deconst->trash_stack[UCL_TRASH_VALUE][obj->len] = '\0';
447 deconst->value.sv = obj->trash_stack[UCL_TRASH_VALUE];
452 /* Just emit value in json notation */
453 deconst->trash_stack[UCL_TRASH_VALUE] = ucl_object_emit_single_json (obj);
454 deconst->len = strlen (obj->trash_stack[UCL_TRASH_VALUE]);
456 deconst->flags |= UCL_OBJECT_ALLOCATED_VALUE;
459 return obj->trash_stack[UCL_TRASH_VALUE];
463 ucl_parser_get_object (struct ucl_parser *parser)
465 if (parser->state != UCL_STATE_ERROR && parser->top_obj != NULL) {
466 return ucl_object_ref (parser->top_obj);
473 ucl_parser_free (struct ucl_parser *parser)
475 struct ucl_stack *stack, *stmp;
476 struct ucl_macro *macro, *mtmp;
477 struct ucl_chunk *chunk, *ctmp;
478 struct ucl_pubkey *key, *ktmp;
479 struct ucl_variable *var, *vtmp;
480 ucl_object_t *tr, *trtmp;
482 if (parser == NULL) {
486 if (parser->top_obj != NULL) {
487 ucl_object_unref (parser->top_obj);
490 if (parser->includepaths != NULL) {
491 ucl_object_unref (parser->includepaths);
494 LL_FOREACH_SAFE (parser->stack, stack, stmp) {
497 HASH_ITER (hh, parser->macroes, macro, mtmp) {
499 HASH_DEL (parser->macroes, macro);
500 UCL_FREE (sizeof (struct ucl_macro), macro);
502 LL_FOREACH_SAFE (parser->chunks, chunk, ctmp) {
503 UCL_FREE (sizeof (struct ucl_chunk), chunk);
505 LL_FOREACH_SAFE (parser->keys, key, ktmp) {
506 UCL_FREE (sizeof (struct ucl_pubkey), key);
508 LL_FOREACH_SAFE (parser->variables, var, vtmp) {
511 UCL_FREE (sizeof (struct ucl_variable), var);
513 LL_FOREACH_SAFE (parser->trash_objs, tr, trtmp) {
514 ucl_object_free_internal (tr, false, ucl_object_dtor_free);
517 if (parser->err != NULL) {
518 utstring_free (parser->err);
521 if (parser->cur_file) {
522 free (parser->cur_file);
525 if (parser->comments) {
526 ucl_object_unref (parser->comments);
529 UCL_FREE (sizeof (struct ucl_parser), parser);
533 ucl_parser_get_error(struct ucl_parser *parser)
535 if (parser == NULL) {
539 if (parser->err == NULL) {
543 return utstring_body (parser->err);
547 ucl_parser_get_error_code(struct ucl_parser *parser)
549 if (parser == NULL) {
553 return parser->err_code;
557 ucl_parser_get_column(struct ucl_parser *parser)
559 if (parser == NULL || parser->chunks == NULL) {
563 return parser->chunks->column;
567 ucl_parser_get_linenum(struct ucl_parser *parser)
569 if (parser == NULL || parser->chunks == NULL) {
573 return parser->chunks->line;
577 ucl_parser_clear_error(struct ucl_parser *parser)
579 if (parser != NULL && parser->err != NULL) {
580 utstring_free(parser->err);
582 parser->err_code = 0;
587 ucl_pubkey_add (struct ucl_parser *parser, const unsigned char *key, size_t len)
590 ucl_create_err (&parser->err, "cannot check signatures without openssl");
593 # if (OPENSSL_VERSION_NUMBER < 0x10000000L)
594 ucl_create_err (&parser->err, "cannot check signatures, openssl version is unsupported");
597 struct ucl_pubkey *nkey;
600 mem = BIO_new_mem_buf ((void *)key, len);
601 nkey = UCL_ALLOC (sizeof (struct ucl_pubkey));
603 ucl_create_err (&parser->err, "cannot allocate memory for key");
606 nkey->key = PEM_read_bio_PUBKEY (mem, &nkey->key, NULL, NULL);
608 if (nkey->key == NULL) {
609 UCL_FREE (sizeof (struct ucl_pubkey), nkey);
610 ucl_create_err (&parser->err, "%s",
611 ERR_error_string (ERR_get_error (), NULL));
614 LL_PREPEND (parser->keys, nkey);
621 struct ucl_curl_cbdata {
627 ucl_curl_write_callback (void* contents, size_t size, size_t nmemb, void* ud)
629 struct ucl_curl_cbdata *cbdata = ud;
630 size_t realsize = size * nmemb;
632 cbdata->buf = realloc (cbdata->buf, cbdata->buflen + realsize + 1);
633 if (cbdata->buf == NULL) {
637 memcpy (&(cbdata->buf[cbdata->buflen]), contents, realsize);
638 cbdata->buflen += realsize;
639 cbdata->buf[cbdata->buflen] = 0;
646 * Fetch a url and save results to the memory buffer
647 * @param url url to fetch
648 * @param len length of url
649 * @param buf target buffer
650 * @param buflen target length
654 ucl_fetch_url (const unsigned char *url, unsigned char **buf, size_t *buflen,
655 UT_string **err, bool must_exist)
659 struct url *fetch_url;
663 fetch_url = fetchParseURL (url);
664 if (fetch_url == NULL) {
665 ucl_create_err (err, "invalid URL %s: %s",
666 url, strerror (errno));
669 if ((in = fetchXGet (fetch_url, &us, "")) == NULL) {
671 ucl_create_err (err, "cannot fetch URL %s: %s",
672 url, strerror (errno));
674 fetchFreeURL (fetch_url);
679 *buf = malloc (*buflen);
681 ucl_create_err (err, "cannot allocate buffer for URL %s: %s",
682 url, strerror (errno));
684 fetchFreeURL (fetch_url);
688 if (fread (*buf, *buflen, 1, in) != 1) {
689 ucl_create_err (err, "cannot read URL %s: %s",
690 url, strerror (errno));
692 fetchFreeURL (fetch_url);
696 fetchFreeURL (fetch_url);
698 #elif defined(CURL_FOUND)
701 struct ucl_curl_cbdata cbdata;
703 curl = curl_easy_init ();
705 ucl_create_err (err, "CURL interface is broken");
708 if ((r = curl_easy_setopt (curl, CURLOPT_URL, url)) != CURLE_OK) {
709 ucl_create_err (err, "invalid URL %s: %s",
710 url, curl_easy_strerror (r));
711 curl_easy_cleanup (curl);
714 curl_easy_setopt (curl, CURLOPT_WRITEFUNCTION, ucl_curl_write_callback);
717 curl_easy_setopt (curl, CURLOPT_WRITEDATA, &cbdata);
719 if ((r = curl_easy_perform (curl)) != CURLE_OK) {
721 ucl_create_err (err, "error fetching URL %s: %s",
722 url, curl_easy_strerror (r));
724 curl_easy_cleanup (curl);
731 *buflen = cbdata.buflen;
735 ucl_create_err (err, "URL support is disabled");
741 * Fetch a file and save results to the memory buffer
742 * @param filename filename to fetch
743 * @param len length of filename
744 * @param buf target buffer
745 * @param buflen target length
749 ucl_fetch_file (const unsigned char *filename, unsigned char **buf, size_t *buflen,
750 UT_string **err, bool must_exist)
755 if (stat (filename, &st) == -1 || !S_ISREG (st.st_mode)) {
757 ucl_create_err (err, "cannot stat file %s: %s",
758 filename, strerror (errno));
762 if (st.st_size == 0) {
763 /* Do not map empty files */
768 if ((fd = open (filename, O_RDONLY)) == -1) {
769 ucl_create_err (err, "cannot open file %s: %s",
770 filename, strerror (errno));
773 if ((*buf = ucl_mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
775 ucl_create_err (err, "cannot mmap file %s: %s",
776 filename, strerror (errno));
781 *buflen = st.st_size;
789 #if (defined(HAVE_OPENSSL) && OPENSSL_VERSION_NUMBER >= 0x10000000L)
791 ucl_sig_check (const unsigned char *data, size_t datalen,
792 const unsigned char *sig, size_t siglen, struct ucl_parser *parser)
794 struct ucl_pubkey *key;
795 char dig[EVP_MAX_MD_SIZE];
797 EVP_PKEY_CTX *key_ctx;
798 EVP_MD_CTX *sign_ctx = NULL;
800 sign_ctx = EVP_MD_CTX_create ();
802 LL_FOREACH (parser->keys, key) {
803 key_ctx = EVP_PKEY_CTX_new (key->key, NULL);
804 if (key_ctx != NULL) {
805 if (EVP_PKEY_verify_init (key_ctx) <= 0) {
806 EVP_PKEY_CTX_free (key_ctx);
809 if (EVP_PKEY_CTX_set_rsa_padding (key_ctx, RSA_PKCS1_PADDING) <= 0) {
810 EVP_PKEY_CTX_free (key_ctx);
813 if (EVP_PKEY_CTX_set_signature_md (key_ctx, EVP_sha256 ()) <= 0) {
814 EVP_PKEY_CTX_free (key_ctx);
817 EVP_DigestInit (sign_ctx, EVP_sha256 ());
818 EVP_DigestUpdate (sign_ctx, data, datalen);
819 EVP_DigestFinal (sign_ctx, dig, &diglen);
821 if (EVP_PKEY_verify (key_ctx, sig, siglen, dig, diglen) == 1) {
822 EVP_MD_CTX_destroy (sign_ctx);
823 EVP_PKEY_CTX_free (key_ctx);
827 EVP_PKEY_CTX_free (key_ctx);
831 EVP_MD_CTX_destroy (sign_ctx);
837 struct ucl_include_params {
838 bool check_signature;
845 enum ucl_duplicate_strategy strat;
846 enum ucl_parse_type parse_type;
852 * Include an url to configuration
860 ucl_include_url (const unsigned char *data, size_t len,
861 struct ucl_parser *parser,
862 struct ucl_include_params *params)
866 unsigned char *buf = NULL;
868 struct ucl_chunk *chunk;
869 char urlbuf[PATH_MAX];
872 snprintf (urlbuf, sizeof (urlbuf), "%.*s", (int)len, data);
874 if (!ucl_fetch_url (urlbuf, &buf, &buflen, &parser->err, params->must_exist)) {
875 return !params->must_exist;
878 if (params->check_signature) {
879 #if (defined(HAVE_OPENSSL) && OPENSSL_VERSION_NUMBER >= 0x10000000L)
880 unsigned char *sigbuf = NULL;
882 /* We need to check signature first */
883 snprintf (urlbuf, sizeof (urlbuf), "%.*s.sig", (int)len, data);
884 if (!ucl_fetch_url (urlbuf, &sigbuf, &siglen, &parser->err, true)) {
887 if (!ucl_sig_check (buf, buflen, sigbuf, siglen, parser)) {
888 ucl_create_err (&parser->err, "cannot verify url %s: %s",
890 ERR_error_string (ERR_get_error (), NULL));
892 ucl_munmap (sigbuf, siglen);
897 ucl_munmap (sigbuf, siglen);
902 prev_state = parser->state;
903 parser->state = UCL_STATE_INIT;
905 res = ucl_parser_add_chunk_full (parser, buf, buflen, params->priority,
906 params->strat, params->parse_type);
908 /* Remove chunk from the stack */
909 chunk = parser->chunks;
911 parser->chunks = chunk->next;
912 UCL_FREE (sizeof (struct ucl_chunk), chunk);
916 parser->state = prev_state;
923 * Include a single file to the parser
927 * @param check_signature
934 ucl_include_file_single (const unsigned char *data, size_t len,
935 struct ucl_parser *parser, struct ucl_include_params *params)
938 struct ucl_chunk *chunk;
939 unsigned char *buf = NULL;
940 char *old_curfile, *ext;
942 char filebuf[PATH_MAX], realbuf[PATH_MAX];
944 struct ucl_variable *cur_var, *tmp_var, *old_curdir = NULL,
945 *old_filename = NULL;
946 ucl_object_t *nest_obj = NULL, *old_obj = NULL, *new_obj = NULL;
947 ucl_hash_t *container = NULL;
948 struct ucl_stack *st = NULL;
950 snprintf (filebuf, sizeof (filebuf), "%.*s", (int)len, data);
951 if (ucl_realpath (filebuf, realbuf) == NULL) {
952 if (params->soft_fail) {
955 if (!params->must_exist) {
958 ucl_create_err (&parser->err, "cannot open file %s: %s",
964 if (parser->cur_file && strcmp (realbuf, parser->cur_file) == 0) {
965 /* We are likely including the file itself */
966 if (params->soft_fail) {
970 ucl_create_err (&parser->err, "trying to include the file %s from itself",
975 if (!ucl_fetch_file (realbuf, &buf, &buflen, &parser->err, params->must_exist)) {
976 if (params->soft_fail) {
980 return (!params->must_exist || false);
983 if (params->check_signature) {
984 #if (defined(HAVE_OPENSSL) && OPENSSL_VERSION_NUMBER >= 0x10000000L)
985 unsigned char *sigbuf = NULL;
987 /* We need to check signature first */
988 snprintf (filebuf, sizeof (filebuf), "%s.sig", realbuf);
989 if (!ucl_fetch_file (filebuf, &sigbuf, &siglen, &parser->err, true)) {
992 if (!ucl_sig_check (buf, buflen, sigbuf, siglen, parser)) {
993 ucl_create_err (&parser->err, "cannot verify file %s: %s",
995 ERR_error_string (ERR_get_error (), NULL));
997 ucl_munmap (sigbuf, siglen);
1002 ucl_munmap (sigbuf, siglen);
1007 old_curfile = parser->cur_file;
1008 parser->cur_file = strdup (realbuf);
1010 /* Store old file vars */
1011 DL_FOREACH_SAFE (parser->variables, cur_var, tmp_var) {
1012 if (strcmp (cur_var->var, "CURDIR") == 0) {
1013 old_curdir = cur_var;
1014 DL_DELETE (parser->variables, cur_var);
1016 else if (strcmp (cur_var->var, "FILENAME") == 0) {
1017 old_filename = cur_var;
1018 DL_DELETE (parser->variables, cur_var);
1022 ucl_parser_set_filevars (parser, realbuf, false);
1024 prev_state = parser->state;
1025 parser->state = UCL_STATE_INIT;
1027 if (params->use_prefix && params->prefix == NULL) {
1028 /* Auto generate a key name based on the included filename */
1029 params->prefix = basename (realbuf);
1030 ext = strrchr (params->prefix, '.');
1031 if (ext != NULL && (strcmp (ext, ".conf") == 0 || strcmp (ext, ".ucl") == 0)) {
1032 /* Strip off .conf or .ucl */
1036 if (params->prefix != NULL) {
1037 /* This is a prefixed include */
1038 container = parser->stack->obj->value.ov;
1040 old_obj = __DECONST (ucl_object_t *, ucl_hash_search (container,
1041 params->prefix, strlen (params->prefix)));
1043 if (strcasecmp (params->target, "array") == 0 && old_obj == NULL) {
1044 /* Create an array with key: prefix */
1045 old_obj = ucl_object_new_full (UCL_ARRAY, params->priority);
1046 old_obj->key = params->prefix;
1047 old_obj->keylen = strlen (params->prefix);
1048 ucl_copy_key_trash(old_obj);
1049 old_obj->prev = old_obj;
1050 old_obj->next = NULL;
1052 container = ucl_hash_insert_object (container, old_obj,
1053 parser->flags & UCL_PARSER_KEY_LOWERCASE);
1054 parser->stack->obj->len ++;
1056 nest_obj = ucl_object_new_full (UCL_OBJECT, params->priority);
1057 nest_obj->prev = nest_obj;
1058 nest_obj->next = NULL;
1060 ucl_array_append (old_obj, nest_obj);
1062 else if (old_obj == NULL) {
1063 /* Create an object with key: prefix */
1064 nest_obj = ucl_object_new_full (UCL_OBJECT, params->priority);
1066 if (nest_obj == NULL) {
1067 ucl_create_err (&parser->err, "cannot allocate memory for an object");
1069 ucl_munmap (buf, buflen);
1075 nest_obj->key = params->prefix;
1076 nest_obj->keylen = strlen (params->prefix);
1077 ucl_copy_key_trash(nest_obj);
1078 nest_obj->prev = nest_obj;
1079 nest_obj->next = NULL;
1081 container = ucl_hash_insert_object (container, nest_obj,
1082 parser->flags & UCL_PARSER_KEY_LOWERCASE);
1083 parser->stack->obj->len ++;
1085 else if (strcasecmp (params->target, "array") == 0 ||
1086 ucl_object_type(old_obj) == UCL_ARRAY) {
1087 if (ucl_object_type(old_obj) == UCL_ARRAY) {
1088 /* Append to the existing array */
1089 nest_obj = ucl_object_new_full (UCL_OBJECT, params->priority);
1090 if (nest_obj == NULL) {
1091 ucl_create_err (&parser->err, "cannot allocate memory for an object");
1093 ucl_munmap (buf, buflen);
1098 nest_obj->prev = nest_obj;
1099 nest_obj->next = NULL;
1101 ucl_array_append (old_obj, nest_obj);
1104 /* Convert the object to an array */
1105 new_obj = ucl_object_typed_new (UCL_ARRAY);
1106 if (new_obj == NULL) {
1107 ucl_create_err (&parser->err, "cannot allocate memory for an object");
1109 ucl_munmap (buf, buflen);
1114 new_obj->key = old_obj->key;
1115 new_obj->keylen = old_obj->keylen;
1116 new_obj->flags |= UCL_OBJECT_MULTIVALUE;
1117 new_obj->prev = new_obj;
1118 new_obj->next = NULL;
1120 nest_obj = ucl_object_new_full (UCL_OBJECT, params->priority);
1121 if (nest_obj == NULL) {
1122 ucl_create_err (&parser->err, "cannot allocate memory for an object");
1124 ucl_munmap (buf, buflen);
1129 nest_obj->prev = nest_obj;
1130 nest_obj->next = NULL;
1132 ucl_array_append (new_obj, old_obj);
1133 ucl_array_append (new_obj, nest_obj);
1134 ucl_hash_replace (container, old_obj, new_obj);
1138 if (ucl_object_type (old_obj) == UCL_OBJECT) {
1139 /* Append to existing Object*/
1143 /* The key is not an object */
1144 ucl_create_err (&parser->err,
1145 "Conflicting type for key: %s",
1148 ucl_munmap (buf, buflen);
1155 /* Put all of the content of the include inside that object */
1156 parser->stack->obj->value.ov = container;
1158 st = UCL_ALLOC (sizeof (struct ucl_stack));
1160 ucl_create_err (&parser->err, "cannot allocate memory for an object");
1161 ucl_object_unref (nest_obj);
1164 ucl_munmap (buf, buflen);
1170 st->level = parser->stack->level;
1171 LL_PREPEND (parser->stack, st);
1172 parser->cur_obj = nest_obj;
1175 res = ucl_parser_add_chunk_full (parser, buf, buflen, params->priority,
1176 params->strat, params->parse_type);
1179 if (!params->must_exist) {
1181 utstring_free (parser->err);
1187 /* Stop nesting the include, take 1 level off the stack */
1188 if (params->prefix != NULL && nest_obj != NULL) {
1189 parser->stack = st->next;
1190 UCL_FREE (sizeof (struct ucl_stack), st);
1193 /* Remove chunk from the stack */
1194 chunk = parser->chunks;
1195 if (chunk != NULL) {
1196 parser->chunks = chunk->next;
1197 UCL_FREE (sizeof (struct ucl_chunk), chunk);
1198 parser->recursion --;
1201 /* Restore old file vars */
1202 if (parser->cur_file) {
1203 free (parser->cur_file);
1206 parser->cur_file = old_curfile;
1207 DL_FOREACH_SAFE (parser->variables, cur_var, tmp_var) {
1208 if (strcmp (cur_var->var, "CURDIR") == 0 && old_curdir) {
1209 DL_DELETE (parser->variables, cur_var);
1210 free (cur_var->var);
1211 free (cur_var->value);
1212 UCL_FREE (sizeof (struct ucl_variable), cur_var);
1214 else if (strcmp (cur_var->var, "FILENAME") == 0 && old_filename) {
1215 DL_DELETE (parser->variables, cur_var);
1216 free (cur_var->var);
1217 free (cur_var->value);
1218 UCL_FREE (sizeof (struct ucl_variable), cur_var);
1222 DL_APPEND (parser->variables, old_filename);
1225 DL_APPEND (parser->variables, old_curdir);
1228 parser->state = prev_state;
1231 ucl_munmap (buf, buflen);
1238 * Include a file to configuration
1246 ucl_include_file (const unsigned char *data, size_t len,
1247 struct ucl_parser *parser, struct ucl_include_params *params)
1249 const unsigned char *p = data, *end = data + len;
1250 bool need_glob = false;
1252 char glob_pattern[PATH_MAX];
1256 if (!params->allow_glob) {
1257 return ucl_include_file_single (data, len, parser, params);
1260 /* Check for special symbols in a filename */
1262 if (*p == '*' || *p == '?') {
1270 memset (&globbuf, 0, sizeof (globbuf));
1271 ucl_strlcpy (glob_pattern, (const char *)data,
1272 (len + 1 < sizeof (glob_pattern) ? len + 1 : sizeof (glob_pattern)));
1273 if (glob (glob_pattern, 0, NULL, &globbuf) != 0) {
1274 return (!params->must_exist || false);
1276 for (i = 0; i < globbuf.gl_pathc; i ++) {
1277 if (!ucl_include_file_single ((unsigned char *)globbuf.gl_pathv[i],
1278 strlen (globbuf.gl_pathv[i]), parser, params)) {
1279 if (params->soft_fail) {
1282 globfree (&globbuf);
1287 globfree (&globbuf);
1289 if (cnt == 0 && params->must_exist) {
1290 ucl_create_err (&parser->err, "cannot match any files for pattern %s",
1296 return ucl_include_file_single (data, len, parser, params);
1300 /* Win32 compilers do not support globbing. Therefore, for Win32,
1301 treat allow_glob/need_glob as a NOOP and just return */
1302 return ucl_include_file_single (data, len, parser, params);
1309 * Common function to handle .*include* macros
1314 * @param default_try
1315 * @param default_sign
1319 ucl_include_common (const unsigned char *data, size_t len,
1320 const ucl_object_t *args, struct ucl_parser *parser,
1324 bool allow_url = false, search = false;
1325 const char *duplicate;
1326 const ucl_object_t *param;
1327 ucl_object_iter_t it = NULL, ip = NULL;
1328 char ipath[PATH_MAX];
1329 struct ucl_include_params params;
1331 /* Default values */
1332 params.soft_fail = default_try;
1333 params.allow_glob = false;
1334 params.check_signature = default_sign;
1335 params.use_prefix = false;
1336 params.target = "object";
1337 params.prefix = NULL;
1338 params.priority = 0;
1339 params.parse_type = UCL_PARSE_UCL;
1340 params.strat = UCL_DUPLICATE_APPEND;
1341 params.must_exist = !default_try;
1343 /* Process arguments */
1344 if (args != NULL && args->type == UCL_OBJECT) {
1345 while ((param = ucl_object_iterate (args, &it, true)) != NULL) {
1346 if (param->type == UCL_BOOLEAN) {
1347 if (strncmp (param->key, "try", param->keylen) == 0) {
1348 params.must_exist = !ucl_object_toboolean (param);
1350 else if (strncmp (param->key, "sign", param->keylen) == 0) {
1351 params.check_signature = ucl_object_toboolean (param);
1353 else if (strncmp (param->key, "glob", param->keylen) == 0) {
1354 params.allow_glob = ucl_object_toboolean (param);
1356 else if (strncmp (param->key, "url", param->keylen) == 0) {
1357 allow_url = ucl_object_toboolean (param);
1359 else if (strncmp (param->key, "prefix", param->keylen) == 0) {
1360 params.use_prefix = ucl_object_toboolean (param);
1363 else if (param->type == UCL_STRING) {
1364 if (strncmp (param->key, "key", param->keylen) == 0) {
1365 params.prefix = ucl_object_tostring (param);
1367 else if (strncmp (param->key, "target", param->keylen) == 0) {
1368 params.target = ucl_object_tostring (param);
1370 else if (strncmp (param->key, "duplicate", param->keylen) == 0) {
1371 duplicate = ucl_object_tostring (param);
1373 if (strcmp (duplicate, "append") == 0) {
1374 params.strat = UCL_DUPLICATE_APPEND;
1376 else if (strcmp (duplicate, "merge") == 0) {
1377 params.strat = UCL_DUPLICATE_MERGE;
1379 else if (strcmp (duplicate, "rewrite") == 0) {
1380 params.strat = UCL_DUPLICATE_REWRITE;
1382 else if (strcmp (duplicate, "error") == 0) {
1383 params.strat = UCL_DUPLICATE_ERROR;
1387 else if (param->type == UCL_ARRAY) {
1388 if (strncmp (param->key, "path", param->keylen) == 0) {
1389 ucl_set_include_path (parser, __DECONST(ucl_object_t *, param));
1392 else if (param->type == UCL_INT) {
1393 if (strncmp (param->key, "priority", param->keylen) == 0) {
1394 params.priority = ucl_object_toint (param);
1400 if (parser->includepaths == NULL) {
1401 if (allow_url && ucl_strnstr (data, "://", len) != NULL) {
1402 /* Globbing is not used for URL's */
1403 return ucl_include_url (data, len, parser, ¶ms);
1405 else if (data != NULL) {
1406 /* Try to load a file */
1407 return ucl_include_file (data, len, parser, ¶ms);
1411 if (allow_url && ucl_strnstr (data, "://", len) != NULL) {
1412 /* Globbing is not used for URL's */
1413 return ucl_include_url (data, len, parser, ¶ms);
1416 ip = ucl_object_iterate_new (parser->includepaths);
1417 while ((param = ucl_object_iterate_safe (ip, true)) != NULL) {
1418 if (ucl_object_type(param) == UCL_STRING) {
1419 snprintf (ipath, sizeof (ipath), "%s/%.*s", ucl_object_tostring(param),
1421 if ((search = ucl_include_file (ipath, strlen (ipath),
1422 parser, ¶ms))) {
1423 if (!params.allow_glob) {
1429 ucl_object_iterate_free (ip);
1430 if (search == true) {
1434 ucl_create_err (&parser->err,
1435 "cannot find file: %.*s in search path",
1445 * Handle include macro
1446 * @param data include data
1447 * @param len length of data
1448 * @param args UCL object representing arguments to the macro
1449 * @param ud user data
1453 ucl_include_handler (const unsigned char *data, size_t len,
1454 const ucl_object_t *args, void* ud)
1456 struct ucl_parser *parser = ud;
1458 return ucl_include_common (data, len, args, parser, false, false);
1462 * Handle includes macro
1463 * @param data include data
1464 * @param len length of data
1465 * @param args UCL object representing arguments to the macro
1466 * @param ud user data
1470 ucl_includes_handler (const unsigned char *data, size_t len,
1471 const ucl_object_t *args, void* ud)
1473 struct ucl_parser *parser = ud;
1475 return ucl_include_common (data, len, args, parser, false, true);
1479 * Handle tryinclude macro
1480 * @param data include data
1481 * @param len length of data
1482 * @param args UCL object representing arguments to the macro
1483 * @param ud user data
1487 ucl_try_include_handler (const unsigned char *data, size_t len,
1488 const ucl_object_t *args, void* ud)
1490 struct ucl_parser *parser = ud;
1492 return ucl_include_common (data, len, args, parser, true, false);
1496 * Handle priority macro
1497 * @param data include data
1498 * @param len length of data
1499 * @param args UCL object representing arguments to the macro
1500 * @param ud user data
1504 ucl_priority_handler (const unsigned char *data, size_t len,
1505 const ucl_object_t *args, void* ud)
1507 struct ucl_parser *parser = ud;
1508 unsigned priority = 255;
1509 const ucl_object_t *param;
1511 char *value = NULL, *leftover = NULL;
1512 ucl_object_iter_t it = NULL;
1514 if (parser == NULL) {
1518 /* Process arguments */
1519 if (args != NULL && args->type == UCL_OBJECT) {
1520 while ((param = ucl_object_iterate (args, &it, true)) != NULL) {
1521 if (param->type == UCL_INT) {
1522 if (strncmp (param->key, "priority", param->keylen) == 0) {
1523 priority = ucl_object_toint (param);
1531 value = malloc(len + 1);
1532 ucl_strlcpy(value, (const char *)data, len + 1);
1533 priority = strtol(value, &leftover, 10);
1534 if (*leftover != '\0') {
1535 ucl_create_err (&parser->err, "Invalid priority value in macro: %s",
1544 if (found == true) {
1545 parser->chunks->priority = priority;
1549 ucl_create_err (&parser->err, "Unable to parse priority macro");
1555 * @param data include data
1556 * @param len length of data
1557 * @param args UCL object representing arguments to the macro
1558 * @param ud user data
1562 ucl_load_handler (const unsigned char *data, size_t len,
1563 const ucl_object_t *args, void* ud)
1565 struct ucl_parser *parser = ud;
1566 const ucl_object_t *param;
1567 ucl_object_t *obj, *old_obj;
1568 ucl_object_iter_t it = NULL;
1569 bool try_load, multiline, test;
1570 const char *target, *prefix;
1571 char *load_file, *tmp;
1576 ucl_object_t *container = NULL;
1577 enum ucl_string_flags flags;
1579 /* Default values */
1593 if (parser == NULL) {
1597 /* Process arguments */
1598 if (args != NULL && args->type == UCL_OBJECT) {
1599 while ((param = ucl_object_iterate (args, &it, true)) != NULL) {
1600 if (param->type == UCL_BOOLEAN) {
1601 if (strncmp (param->key, "try", param->keylen) == 0) {
1602 try_load = ucl_object_toboolean (param);
1604 else if (strncmp (param->key, "multiline", param->keylen) == 0) {
1605 multiline = ucl_object_toboolean (param);
1607 else if (strncmp (param->key, "escape", param->keylen) == 0) {
1608 test = ucl_object_toboolean (param);
1610 flags |= UCL_STRING_ESCAPE;
1613 else if (strncmp (param->key, "trim", param->keylen) == 0) {
1614 test = ucl_object_toboolean (param);
1616 flags |= UCL_STRING_TRIM;
1620 else if (param->type == UCL_STRING) {
1621 if (strncmp (param->key, "key", param->keylen) == 0) {
1622 prefix = ucl_object_tostring (param);
1624 else if (strncmp (param->key, "target", param->keylen) == 0) {
1625 target = ucl_object_tostring (param);
1628 else if (param->type == UCL_INT) {
1629 if (strncmp (param->key, "priority", param->keylen) == 0) {
1630 priority = ucl_object_toint (param);
1636 if (prefix == NULL || strlen (prefix) == 0) {
1637 ucl_create_err (&parser->err, "No Key specified in load macro");
1642 load_file = malloc (len + 1);
1644 ucl_create_err (&parser->err, "cannot allocate memory for suffix");
1649 snprintf (load_file, len + 1, "%.*s", (int)len, data);
1651 if (!ucl_fetch_file (load_file, &buf, &buflen, &parser->err,
1655 return (try_load || false);
1659 container = parser->stack->obj;
1660 old_obj = __DECONST (ucl_object_t *, ucl_object_lookup (container,
1663 if (old_obj != NULL) {
1664 ucl_create_err (&parser->err, "Key %s already exists", prefix);
1666 ucl_munmap (buf, buflen);
1672 if (strcasecmp (target, "string") == 0) {
1673 obj = ucl_object_fromstring_common (buf, buflen, flags);
1674 ucl_copy_value_trash (obj);
1676 obj->flags |= UCL_OBJECT_MULTILINE;
1679 else if (strcasecmp (target, "int") == 0) {
1680 tmp = malloc (buflen + 1);
1683 ucl_create_err (&parser->err, "Memory allocation failed");
1685 ucl_munmap (buf, buflen);
1691 snprintf (tmp, buflen + 1, "%.*s", (int)buflen, buf);
1692 iv = strtoll (tmp, NULL, 10);
1693 obj = ucl_object_fromint (iv);
1698 ucl_munmap (buf, buflen);
1703 obj->keylen = strlen (prefix);
1704 ucl_copy_key_trash (obj);
1707 ucl_object_set_priority (obj, priority);
1708 ucl_object_insert_key (container, obj, obj->key, obj->keylen, false);
1714 ucl_create_err (&parser->err, "Unable to parse load macro");
1719 ucl_inherit_handler (const unsigned char *data, size_t len,
1720 const ucl_object_t *args, const ucl_object_t *ctx, void* ud)
1722 const ucl_object_t *parent, *cur;
1723 ucl_object_t *target, *copy;
1724 ucl_object_iter_t it = NULL;
1725 bool replace = false;
1726 struct ucl_parser *parser = ud;
1728 parent = ucl_object_lookup_len (ctx, data, len);
1730 /* Some sanity checks */
1731 if (parent == NULL || ucl_object_type (parent) != UCL_OBJECT) {
1732 ucl_create_err (&parser->err, "Unable to find inherited object %*.s",
1737 if (parser->stack == NULL || parser->stack->obj == NULL ||
1738 ucl_object_type (parser->stack->obj) != UCL_OBJECT) {
1739 ucl_create_err (&parser->err, "Invalid inherit context");
1743 target = parser->stack->obj;
1745 if (args && (cur = ucl_object_lookup (args, "replace")) != NULL) {
1746 replace = ucl_object_toboolean (cur);
1749 while ((cur = ucl_object_iterate (parent, &it, true))) {
1750 /* We do not replace existing keys */
1751 if (!replace && ucl_object_lookup_len (target, cur->key, cur->keylen)) {
1755 copy = ucl_object_copy (cur);
1758 copy->flags |= UCL_OBJECT_INHERITED;
1761 ucl_object_insert_key (target, copy, copy->key,
1762 copy->keylen, false);
1769 ucl_parser_set_filevars (struct ucl_parser *parser, const char *filename, bool need_expand)
1771 char realbuf[PATH_MAX], *curdir;
1773 if (filename != NULL) {
1775 if (ucl_realpath (filename, realbuf) == NULL) {
1780 ucl_strlcpy (realbuf, filename, sizeof (realbuf));
1783 /* Define variables */
1784 ucl_parser_register_variable (parser, "FILENAME", realbuf);
1785 curdir = dirname (realbuf);
1786 ucl_parser_register_variable (parser, "CURDIR", curdir);
1789 /* Set everything from the current dir */
1790 curdir = getcwd (realbuf, sizeof (realbuf));
1791 ucl_parser_register_variable (parser, "FILENAME", "undef");
1792 ucl_parser_register_variable (parser, "CURDIR", curdir);
1799 ucl_parser_add_file_full (struct ucl_parser *parser, const char *filename,
1800 unsigned priority, enum ucl_duplicate_strategy strat,
1801 enum ucl_parse_type parse_type)
1806 char realbuf[PATH_MAX];
1808 if (ucl_realpath (filename, realbuf) == NULL) {
1809 ucl_create_err (&parser->err, "cannot open file %s: %s",
1815 if (!ucl_fetch_file (realbuf, &buf, &len, &parser->err, true)) {
1819 if (parser->cur_file) {
1820 free (parser->cur_file);
1822 parser->cur_file = strdup (realbuf);
1823 ucl_parser_set_filevars (parser, realbuf, false);
1824 ret = ucl_parser_add_chunk_full (parser, buf, len, priority, strat,
1828 ucl_munmap (buf, len);
1835 ucl_parser_add_file_priority (struct ucl_parser *parser, const char *filename,
1838 if (parser == NULL) {
1842 return ucl_parser_add_file_full(parser, filename, priority,
1843 UCL_DUPLICATE_APPEND, UCL_PARSE_UCL);
1847 ucl_parser_add_file (struct ucl_parser *parser, const char *filename)
1849 if (parser == NULL) {
1853 return ucl_parser_add_file_full(parser, filename,
1854 parser->default_priority, UCL_DUPLICATE_APPEND,
1860 ucl_parser_add_fd_full (struct ucl_parser *parser, int fd,
1861 unsigned priority, enum ucl_duplicate_strategy strat,
1862 enum ucl_parse_type parse_type)
1869 if (fstat (fd, &st) == -1) {
1870 ucl_create_err (&parser->err, "cannot stat fd %d: %s",
1871 fd, strerror (errno));
1874 if (st.st_size == 0) {
1877 if ((buf = ucl_mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
1878 ucl_create_err (&parser->err, "cannot mmap fd %d: %s",
1879 fd, strerror (errno));
1883 if (parser->cur_file) {
1884 free (parser->cur_file);
1886 parser->cur_file = NULL;
1888 ret = ucl_parser_add_chunk_full (parser, buf, len, priority, strat,
1892 ucl_munmap (buf, len);
1899 ucl_parser_add_fd_priority (struct ucl_parser *parser, int fd,
1902 if (parser == NULL) {
1906 return ucl_parser_add_fd_full(parser, fd, parser->default_priority,
1907 UCL_DUPLICATE_APPEND, UCL_PARSE_UCL);
1911 ucl_parser_add_fd (struct ucl_parser *parser, int fd)
1913 if (parser == NULL) {
1917 return ucl_parser_add_fd_priority(parser, fd, parser->default_priority);
1921 ucl_strlcpy (char *dst, const char *src, size_t siz)
1924 const char *s = src;
1927 /* Copy as many bytes as will fit */
1930 if ((*d++ = *s++) == '\0') {
1936 if (n == 0 && siz != 0) {
1940 return (s - src - 1); /* count does not include NUL */
1944 ucl_strlcpy_unsafe (char *dst, const char *src, size_t siz)
1946 memcpy (dst, src, siz - 1);
1947 dst[siz - 1] = '\0';
1953 ucl_strlcpy_tolower (char *dst, const char *src, size_t siz)
1956 const char *s = src;
1959 /* Copy as many bytes as will fit */
1962 if ((*d++ = tolower (*s++)) == '\0') {
1968 if (n == 0 && siz != 0) {
1972 return (s - src); /* count does not include NUL */
1976 * Find the first occurrence of find in s
1979 ucl_strnstr (const char *s, const char *find, int len)
1984 if ((c = *find++) != 0) {
1985 mlen = strlen (find);
1988 if ((sc = *s++) == 0 || len-- == 0)
1991 } while (strncmp (s, find, mlen) != 0);
1998 * Find the first occurrence of find in s, ignore case.
2001 ucl_strncasestr (const char *s, const char *find, int len)
2006 if ((c = *find++) != 0) {
2008 mlen = strlen (find);
2011 if ((sc = *s++) == 0 || len-- == 0)
2013 } while (tolower (sc) != c);
2014 } while (strncasecmp (s, find, mlen) != 0);
2021 ucl_object_fromstring_common (const char *str, size_t len, enum ucl_string_flags flags)
2024 const char *start, *end, *p, *pos;
2032 obj = ucl_object_new ();
2037 if (flags & UCL_STRING_TRIM) {
2038 /* Skip leading spaces */
2039 for (start = str; (size_t)(start - str) < len; start ++) {
2040 if (!ucl_test_character (*start, UCL_CHARACTER_WHITESPACE_UNSAFE)) {
2044 /* Skip trailing spaces */
2045 for (end = str + len - 1; end > start; end --) {
2046 if (!ucl_test_character (*end, UCL_CHARACTER_WHITESPACE_UNSAFE)) {
2057 obj->type = UCL_STRING;
2058 if (flags & UCL_STRING_ESCAPE) {
2059 for (p = start, escaped_len = 0; p < end; p ++, escaped_len ++) {
2060 if (ucl_test_character (*p, UCL_CHARACTER_JSON_UNSAFE)) {
2064 dst = malloc (escaped_len + 1);
2066 for (p = start, d = dst; p < end; p ++, d ++) {
2067 if (ucl_test_character (*p, UCL_CHARACTER_JSON_UNSAFE)) {
2104 obj->value.sv = dst;
2105 obj->trash_stack[UCL_TRASH_VALUE] = dst;
2106 obj->len = escaped_len;
2110 dst = malloc (end - start + 1);
2112 ucl_strlcpy_unsafe (dst, start, end - start + 1);
2113 obj->value.sv = dst;
2114 obj->trash_stack[UCL_TRASH_VALUE] = dst;
2115 obj->len = end - start;
2118 if ((flags & UCL_STRING_PARSE) && dst != NULL) {
2119 /* Parse what we have */
2120 if (flags & UCL_STRING_PARSE_BOOLEAN) {
2121 if (!ucl_maybe_parse_boolean (obj, dst, obj->len) && (flags & UCL_STRING_PARSE_NUMBER)) {
2122 ucl_maybe_parse_number (obj, dst, dst + obj->len, &pos,
2123 flags & UCL_STRING_PARSE_DOUBLE,
2124 flags & UCL_STRING_PARSE_BYTES,
2125 flags & UCL_STRING_PARSE_TIME);
2129 ucl_maybe_parse_number (obj, dst, dst + obj->len, &pos,
2130 flags & UCL_STRING_PARSE_DOUBLE,
2131 flags & UCL_STRING_PARSE_BYTES,
2132 flags & UCL_STRING_PARSE_TIME);
2141 ucl_object_insert_key_common (ucl_object_t *top, ucl_object_t *elt,
2142 const char *key, size_t keylen, bool copy_key, bool merge, bool replace)
2144 ucl_object_t *found, *tmp;
2145 const ucl_object_t *cur;
2146 ucl_object_iter_t it = NULL;
2150 if (elt == NULL || key == NULL) {
2158 if (top->type != UCL_OBJECT) {
2159 /* It is possible to convert NULL type to an object */
2160 if (top->type == UCL_NULL) {
2161 top->type = UCL_OBJECT;
2164 /* Refuse converting of other object types */
2169 if (top->value.ov == NULL) {
2170 top->value.ov = ucl_hash_create (false);
2174 keylen = strlen (key);
2177 for (p = key; p < key + keylen; p ++) {
2178 if (ucl_test_character (*p, UCL_CHARACTER_UCL_UNSAFE)) {
2179 elt->flags |= UCL_OBJECT_NEED_KEY_ESCAPE;
2184 /* workaround for some use cases */
2185 if (elt->trash_stack[UCL_TRASH_KEY] != NULL &&
2186 key != (const char *)elt->trash_stack[UCL_TRASH_KEY]) {
2187 /* Remove copied key */
2188 free (elt->trash_stack[UCL_TRASH_KEY]);
2189 elt->trash_stack[UCL_TRASH_KEY] = NULL;
2190 elt->flags &= ~UCL_OBJECT_ALLOCATED_KEY;
2194 elt->keylen = keylen;
2197 ucl_copy_key_trash (elt);
2200 found = __DECONST (ucl_object_t *, ucl_hash_search_obj (top->value.ov, elt));
2202 if (found == NULL) {
2203 top->value.ov = ucl_hash_insert_object (top->value.ov, elt, false);
2211 ucl_hash_replace (top->value.ov, found, elt);
2212 ucl_object_unref (found);
2215 if (found->type != UCL_OBJECT && elt->type == UCL_OBJECT) {
2216 /* Insert old elt to new one */
2217 ucl_object_insert_key_common (elt, found, found->key,
2218 found->keylen, copy_key, false, false);
2219 ucl_hash_delete (top->value.ov, found);
2220 top->value.ov = ucl_hash_insert_object (top->value.ov, elt, false);
2222 else if (found->type == UCL_OBJECT && elt->type != UCL_OBJECT) {
2223 /* Insert new to old */
2224 ucl_object_insert_key_common (found, elt, elt->key,
2225 elt->keylen, copy_key, false, false);
2227 else if (found->type == UCL_OBJECT && elt->type == UCL_OBJECT) {
2228 /* Mix two hashes */
2229 while ((cur = ucl_object_iterate (elt, &it, true)) != NULL) {
2230 tmp = ucl_object_ref (cur);
2231 ucl_object_insert_key_common (found, tmp, cur->key,
2232 cur->keylen, copy_key, false, false);
2234 ucl_object_unref (elt);
2237 /* Just make a list of scalars */
2238 DL_APPEND (found, elt);
2242 DL_APPEND (found, elt);
2250 ucl_object_delete_keyl (ucl_object_t *top, const char *key, size_t keylen)
2252 ucl_object_t *found;
2254 if (top == NULL || key == NULL) {
2258 found = __DECONST (ucl_object_t *, ucl_object_lookup_len (top, key, keylen));
2260 if (found == NULL) {
2264 ucl_hash_delete (top->value.ov, found);
2265 ucl_object_unref (found);
2272 ucl_object_delete_key (ucl_object_t *top, const char *key)
2274 return ucl_object_delete_keyl (top, key, strlen (key));
2278 ucl_object_pop_keyl (ucl_object_t *top, const char *key, size_t keylen)
2280 const ucl_object_t *found;
2282 if (top == NULL || key == NULL) {
2285 found = ucl_object_lookup_len (top, key, keylen);
2287 if (found == NULL) {
2290 ucl_hash_delete (top->value.ov, found);
2293 return __DECONST (ucl_object_t *, found);
2297 ucl_object_pop_key (ucl_object_t *top, const char *key)
2299 return ucl_object_pop_keyl (top, key, strlen (key));
2303 ucl_object_insert_key (ucl_object_t *top, ucl_object_t *elt,
2304 const char *key, size_t keylen, bool copy_key)
2306 return ucl_object_insert_key_common (top, elt, key, keylen, copy_key, false, false);
2310 ucl_object_insert_key_merged (ucl_object_t *top, ucl_object_t *elt,
2311 const char *key, size_t keylen, bool copy_key)
2313 return ucl_object_insert_key_common (top, elt, key, keylen, copy_key, true, false);
2317 ucl_object_replace_key (ucl_object_t *top, ucl_object_t *elt,
2318 const char *key, size_t keylen, bool copy_key)
2320 return ucl_object_insert_key_common (top, elt, key, keylen, copy_key, false, true);
2324 ucl_object_merge (ucl_object_t *top, ucl_object_t *elt, bool copy)
2326 ucl_object_t *cur = NULL, *cp = NULL, *found = NULL;
2327 ucl_object_iter_t iter = NULL;
2329 if (top == NULL || top->type != UCL_OBJECT || elt == NULL || elt->type != UCL_OBJECT) {
2333 /* Mix two hashes */
2334 while ((cur = (ucl_object_t*)ucl_hash_iterate (elt->value.ov, &iter))) {
2336 cp = ucl_object_copy (cur);
2339 cp = ucl_object_ref (cur);
2341 found = __DECONST(ucl_object_t *, ucl_hash_search (top->value.ov, cp->key, cp->keylen));
2342 if (found == NULL) {
2343 /* The key does not exist */
2344 top->value.ov = ucl_hash_insert_object (top->value.ov, cp, false);
2348 /* The key already exists, replace it */
2349 ucl_hash_replace (top->value.ov, found, cp);
2350 ucl_object_unref (found);
2357 const ucl_object_t *
2358 ucl_object_lookup_len (const ucl_object_t *obj, const char *key, size_t klen)
2360 const ucl_object_t *ret;
2363 if (obj == NULL || obj->type != UCL_OBJECT || key == NULL) {
2369 ret = ucl_hash_search_obj (obj->value.ov, &srch);
2374 const ucl_object_t *
2375 ucl_object_lookup (const ucl_object_t *obj, const char *key)
2381 return ucl_object_lookup_len (obj, key, strlen (key));
2385 ucl_object_lookup_any (const ucl_object_t *obj,
2386 const char *key, ...)
2389 const ucl_object_t *ret = NULL;
2390 const char *nk = NULL;
2392 if (obj == NULL || key == NULL) {
2396 ret = ucl_object_lookup_len (obj, key, strlen (key));
2401 while (ret == NULL) {
2402 nk = va_arg (ap, const char *);
2408 ret = ucl_object_lookup_len (obj, nk, strlen (nk));
2419 ucl_object_iterate (const ucl_object_t *obj, ucl_object_iter_t *iter, bool expand_values)
2421 const ucl_object_t *elt = NULL;
2423 if (obj == NULL || iter == NULL) {
2427 if (expand_values) {
2428 switch (obj->type) {
2430 return (const ucl_object_t*)ucl_hash_iterate (obj->value.ov, iter);
2434 UCL_ARRAY_GET (vec, obj);
2435 idx = (unsigned int)(uintptr_t)(*iter);
2438 while (idx < kv_size (*vec)) {
2439 if ((elt = kv_A (*vec, idx)) != NULL) {
2445 *iter = (void *)(uintptr_t)idx;
2452 /* Go to linear iteration */
2456 /* Treat everything as a linear list */
2461 else if (elt == obj) {
2464 *iter = __DECONST (void *, elt->next ? elt->next : obj);
2471 const char safe_iter_magic[4] = {'u', 'i', 't', 'e'};
2472 struct ucl_object_safe_iter {
2473 char magic[4]; /* safety check */
2474 const ucl_object_t *impl_it; /* implicit object iteration */
2475 ucl_object_iter_t expl_it; /* explicit iteration */
2478 #define UCL_SAFE_ITER(ptr) (struct ucl_object_safe_iter *)(ptr)
2479 #define UCL_SAFE_ITER_CHECK(it) do { \
2480 assert (it != NULL); \
2481 assert (memcmp (it->magic, safe_iter_magic, sizeof (it->magic)) == 0); \
2485 ucl_object_iterate_new (const ucl_object_t *obj)
2487 struct ucl_object_safe_iter *it;
2489 it = UCL_ALLOC (sizeof (*it));
2491 memcpy (it->magic, safe_iter_magic, sizeof (it->magic));
2496 return (ucl_object_iter_t)it;
2501 ucl_object_iterate_reset (ucl_object_iter_t it, const ucl_object_t *obj)
2503 struct ucl_object_safe_iter *rit = UCL_SAFE_ITER (it);
2505 UCL_SAFE_ITER_CHECK (rit);
2507 if (rit->expl_it != NULL) {
2508 UCL_FREE (sizeof (*rit->expl_it), rit->expl_it);
2512 rit->expl_it = NULL;
2518 ucl_object_iterate_safe (ucl_object_iter_t it, bool expand_values)
2520 return ucl_object_iterate_full (it, expand_values ? UCL_ITERATE_BOTH :
2521 UCL_ITERATE_IMPLICIT);
2525 ucl_object_iterate_full (ucl_object_iter_t it, enum ucl_iterate_type type)
2527 struct ucl_object_safe_iter *rit = UCL_SAFE_ITER (it);
2528 const ucl_object_t *ret = NULL;
2530 UCL_SAFE_ITER_CHECK (rit);
2532 if (rit->impl_it == NULL) {
2536 if (rit->impl_it->type == UCL_OBJECT || rit->impl_it->type == UCL_ARRAY) {
2537 ret = ucl_object_iterate (rit->impl_it, &rit->expl_it, true);
2539 if (ret == NULL && (type & UCL_ITERATE_IMPLICIT)) {
2540 /* Need to switch to another implicit object in chain */
2541 rit->impl_it = rit->impl_it->next;
2542 rit->expl_it = NULL;
2544 return ucl_object_iterate_safe (it, type);
2548 /* Just iterate over the implicit array */
2550 rit->impl_it = rit->impl_it->next;
2552 if (type & UCL_ITERATE_EXPLICIT) {
2553 /* We flatten objects if need to expand values */
2554 if (ret->type == UCL_OBJECT || ret->type == UCL_ARRAY) {
2555 return ucl_object_iterate_safe (it, type);
2564 ucl_object_iterate_free (ucl_object_iter_t it)
2566 struct ucl_object_safe_iter *rit = UCL_SAFE_ITER (it);
2568 UCL_SAFE_ITER_CHECK (rit);
2570 if (rit->expl_it != NULL) {
2571 UCL_FREE (sizeof (*rit->expl_it), rit->expl_it);
2574 UCL_FREE (sizeof (*rit), it);
2577 const ucl_object_t *
2578 ucl_object_lookup_path (const ucl_object_t *top, const char *path_in) {
2579 return ucl_object_lookup_path_char (top, path_in, '.');
2583 const ucl_object_t *
2584 ucl_object_lookup_path_char (const ucl_object_t *top, const char *path_in, const char sep) {
2585 const ucl_object_t *o = NULL, *found;
2590 if (path_in == NULL || top == NULL) {
2597 /* Skip leading dots */
2603 while (*p != '\0') {
2605 if (*p == sep || *p == '\0') {
2607 switch (top->type) {
2609 /* Key should be an int */
2610 index = strtoul (c, &err_str, 10);
2611 if (err_str != NULL && (*err_str != sep && *err_str != '\0')) {
2614 o = ucl_array_find_index (top, index);
2617 o = ucl_object_lookup_len (top, c, p - c);
2637 ucl_object_new (void)
2639 return ucl_object_typed_new (UCL_NULL);
2643 ucl_object_typed_new (ucl_type_t type)
2645 return ucl_object_new_full (type, 0);
2649 ucl_object_new_full (ucl_type_t type, unsigned priority)
2653 if (type != UCL_USERDATA) {
2654 new = UCL_ALLOC (sizeof (ucl_object_t));
2656 memset (new, 0, sizeof (ucl_object_t));
2658 new->type = (type <= UCL_NULL ? type : UCL_NULL);
2661 ucl_object_set_priority (new, priority);
2663 if (type == UCL_ARRAY) {
2664 new->value.av = UCL_ALLOC (sizeof (ucl_array_t));
2665 if (new->value.av) {
2666 memset (new->value.av, 0, sizeof (ucl_array_t));
2667 UCL_ARRAY_GET (vec, new);
2669 /* Preallocate some space for arrays */
2670 kv_resize (ucl_object_t *, *vec, 8);
2676 new = ucl_object_new_userdata (NULL, NULL, NULL);
2677 ucl_object_set_priority (new, priority);
2684 ucl_object_new_userdata (ucl_userdata_dtor dtor,
2685 ucl_userdata_emitter emitter,
2688 struct ucl_object_userdata *new;
2689 size_t nsize = sizeof (*new);
2691 new = UCL_ALLOC (nsize);
2693 memset (new, 0, nsize);
2695 new->obj.type = UCL_USERDATA;
2696 new->obj.next = NULL;
2697 new->obj.prev = (ucl_object_t *)new;
2699 new->emitter = emitter;
2700 new->obj.value.ud = ptr;
2703 return (ucl_object_t *)new;
2707 ucl_object_type (const ucl_object_t *obj)
2717 ucl_object_fromstring (const char *str)
2719 return ucl_object_fromstring_common (str, 0, UCL_STRING_ESCAPE);
2723 ucl_object_fromlstring (const char *str, size_t len)
2725 return ucl_object_fromstring_common (str, len, UCL_STRING_ESCAPE);
2729 ucl_object_fromint (int64_t iv)
2733 obj = ucl_object_new ();
2735 obj->type = UCL_INT;
2743 ucl_object_fromdouble (double dv)
2747 obj = ucl_object_new ();
2749 obj->type = UCL_FLOAT;
2757 ucl_object_frombool (bool bv)
2761 obj = ucl_object_new ();
2763 obj->type = UCL_BOOLEAN;
2771 ucl_array_append (ucl_object_t *top, ucl_object_t *elt)
2773 UCL_ARRAY_GET (vec, top);
2775 if (elt == NULL || top == NULL) {
2780 vec = UCL_ALLOC (sizeof (*vec));
2787 top->value.av = (void *)vec;
2790 kv_push (ucl_object_t *, *vec, elt);
2798 ucl_array_prepend (ucl_object_t *top, ucl_object_t *elt)
2800 UCL_ARRAY_GET (vec, top);
2802 if (elt == NULL || top == NULL) {
2807 vec = UCL_ALLOC (sizeof (*vec));
2809 top->value.av = (void *)vec;
2810 kv_push (ucl_object_t *, *vec, elt);
2813 /* Slow O(n) algorithm */
2814 kv_prepend (ucl_object_t *, *vec, elt);
2823 ucl_array_merge (ucl_object_t *top, ucl_object_t *elt, bool copy)
2826 ucl_object_t *cp = NULL;
2829 if (elt == NULL || top == NULL || top->type != UCL_ARRAY || elt->type != UCL_ARRAY) {
2834 cp = ucl_object_copy (elt);
2837 cp = ucl_object_ref (elt);
2840 UCL_ARRAY_GET (v1, top);
2841 UCL_ARRAY_GET (v2, cp);
2844 kv_concat (ucl_object_t *, *v1, *v2);
2846 for (i = v2->n; i < v1->n; i ++) {
2847 obj = &kv_A (*v1, i);
2859 ucl_array_delete (ucl_object_t *top, ucl_object_t *elt)
2861 UCL_ARRAY_GET (vec, top);
2862 ucl_object_t *ret = NULL;
2869 for (i = 0; i < vec->n; i ++) {
2870 if (kv_A (*vec, i) == elt) {
2871 kv_del (ucl_object_t *, *vec, i);
2881 const ucl_object_t *
2882 ucl_array_head (const ucl_object_t *top)
2884 UCL_ARRAY_GET (vec, top);
2886 if (vec == NULL || top == NULL || top->type != UCL_ARRAY ||
2887 top->value.av == NULL) {
2891 return (vec->n > 0 ? vec->a[0] : NULL);
2894 const ucl_object_t *
2895 ucl_array_tail (const ucl_object_t *top)
2897 UCL_ARRAY_GET (vec, top);
2899 if (top == NULL || top->type != UCL_ARRAY || top->value.av == NULL) {
2903 return (vec->n > 0 ? vec->a[vec->n - 1] : NULL);
2907 ucl_array_pop_last (ucl_object_t *top)
2909 UCL_ARRAY_GET (vec, top);
2910 ucl_object_t **obj, *ret = NULL;
2912 if (vec != NULL && vec->n > 0) {
2913 obj = &kv_A (*vec, vec->n - 1);
2915 kv_del (ucl_object_t *, *vec, vec->n - 1);
2923 ucl_array_pop_first (ucl_object_t *top)
2925 UCL_ARRAY_GET (vec, top);
2926 ucl_object_t **obj, *ret = NULL;
2928 if (vec != NULL && vec->n > 0) {
2929 obj = &kv_A (*vec, 0);
2931 kv_del (ucl_object_t *, *vec, 0);
2938 const ucl_object_t *
2939 ucl_array_find_index (const ucl_object_t *top, unsigned int index)
2941 UCL_ARRAY_GET (vec, top);
2943 if (vec != NULL && vec->n > 0 && index < vec->n) {
2944 return kv_A (*vec, index);
2951 ucl_array_index_of (ucl_object_t *top, ucl_object_t *elt)
2953 UCL_ARRAY_GET (vec, top);
2957 return (unsigned int)(-1);
2960 for (i = 0; i < vec->n; i ++) {
2961 if (kv_A (*vec, i) == elt) {
2966 return (unsigned int)(-1);
2970 ucl_array_replace_index (ucl_object_t *top, ucl_object_t *elt,
2973 UCL_ARRAY_GET (vec, top);
2974 ucl_object_t *ret = NULL;
2976 if (vec != NULL && vec->n > 0 && index < vec->n) {
2977 ret = kv_A (*vec, index);
2978 kv_A (*vec, index) = elt;
2985 ucl_elt_append (ucl_object_t *head, ucl_object_t *elt)
2994 elt->prev = head->prev;
2995 head->prev->next = elt;
3004 ucl_object_todouble_safe (const ucl_object_t *obj, double *target)
3006 if (obj == NULL || target == NULL) {
3009 switch (obj->type) {
3011 *target = obj->value.iv; /* Probaly could cause overflow */
3015 *target = obj->value.dv;
3025 ucl_object_todouble (const ucl_object_t *obj)
3029 ucl_object_todouble_safe (obj, &result);
3034 ucl_object_toint_safe (const ucl_object_t *obj, int64_t *target)
3036 if (obj == NULL || target == NULL) {
3039 switch (obj->type) {
3041 *target = obj->value.iv;
3045 *target = obj->value.dv; /* Loosing of decimal points */
3055 ucl_object_toint (const ucl_object_t *obj)
3059 ucl_object_toint_safe (obj, &result);
3064 ucl_object_toboolean_safe (const ucl_object_t *obj, bool *target)
3066 if (obj == NULL || target == NULL) {
3069 switch (obj->type) {
3071 *target = (obj->value.iv == true);
3081 ucl_object_toboolean (const ucl_object_t *obj)
3083 bool result = false;
3085 ucl_object_toboolean_safe (obj, &result);
3090 ucl_object_tostring_safe (const ucl_object_t *obj, const char **target)
3092 if (obj == NULL || target == NULL) {
3096 switch (obj->type) {
3098 if (!(obj->flags & UCL_OBJECT_BINARY)) {
3099 *target = ucl_copy_value_trash (obj);
3110 ucl_object_tostring (const ucl_object_t *obj)
3112 const char *result = NULL;
3114 ucl_object_tostring_safe (obj, &result);
3119 ucl_object_tostring_forced (const ucl_object_t *obj)
3121 /* TODO: For binary strings we might encode string here */
3122 if (!(obj->flags & UCL_OBJECT_BINARY)) {
3123 return ucl_copy_value_trash (obj);
3130 ucl_object_tolstring_safe (const ucl_object_t *obj, const char **target, size_t *tlen)
3132 if (obj == NULL || target == NULL) {
3135 switch (obj->type) {
3137 *target = obj->value.sv;
3150 ucl_object_tolstring (const ucl_object_t *obj, size_t *tlen)
3152 const char *result = NULL;
3154 ucl_object_tolstring_safe (obj, &result, tlen);
3159 ucl_object_key (const ucl_object_t *obj)
3161 return ucl_copy_key_trash (obj);
3165 ucl_object_keyl (const ucl_object_t *obj, size_t *len)
3167 if (len == NULL || obj == NULL) {
3175 ucl_object_ref (const ucl_object_t *obj)
3177 ucl_object_t *res = NULL;
3180 if (obj->flags & UCL_OBJECT_EPHEMERAL) {
3182 * Use deep copy for ephemeral objects, note that its refcount
3183 * is NOT increased, since ephemeral objects does not need refcount
3186 res = ucl_object_copy (obj);
3189 res = __DECONST (ucl_object_t *, obj);
3190 #ifdef HAVE_ATOMIC_BUILTINS
3191 (void)__sync_add_and_fetch (&res->ref, 1);
3200 static ucl_object_t *
3201 ucl_object_copy_internal (const ucl_object_t *other, bool allow_array)
3205 ucl_object_iter_t it = NULL;
3206 const ucl_object_t *cur;
3208 new = malloc (sizeof (*new));
3211 memcpy (new, other, sizeof (*new));
3212 if (other->flags & UCL_OBJECT_EPHEMERAL) {
3213 /* Copied object is always non ephemeral */
3214 new->flags &= ~UCL_OBJECT_EPHEMERAL;
3217 /* Unlink from others */
3221 /* deep copy of values stored */
3222 if (other->trash_stack[UCL_TRASH_KEY] != NULL) {
3223 new->trash_stack[UCL_TRASH_KEY] =
3224 strdup (other->trash_stack[UCL_TRASH_KEY]);
3225 if (other->key == (const char *)other->trash_stack[UCL_TRASH_KEY]) {
3226 new->key = new->trash_stack[UCL_TRASH_KEY];
3229 if (other->trash_stack[UCL_TRASH_VALUE] != NULL) {
3230 new->trash_stack[UCL_TRASH_VALUE] =
3231 strdup (other->trash_stack[UCL_TRASH_VALUE]);
3232 if (new->type == UCL_STRING) {
3233 new->value.sv = new->trash_stack[UCL_TRASH_VALUE];
3237 if (other->type == UCL_ARRAY || other->type == UCL_OBJECT) {
3238 /* reset old value */
3239 memset (&new->value, 0, sizeof (new->value));
3241 while ((cur = ucl_object_iterate (other, &it, true)) != NULL) {
3242 if (other->type == UCL_ARRAY) {
3243 ucl_array_append (new, ucl_object_copy_internal (cur, false));
3246 ucl_object_t *cp = ucl_object_copy_internal (cur, true);
3248 ucl_object_insert_key (new, cp, cp->key, cp->keylen,
3254 else if (allow_array && other->next != NULL) {
3255 LL_FOREACH (other->next, cur) {
3256 ucl_object_t *cp = ucl_object_copy_internal (cur, false);
3258 DL_APPEND (new, cp);
3268 ucl_object_copy (const ucl_object_t *other)
3270 return ucl_object_copy_internal (other, true);
3274 ucl_object_unref (ucl_object_t *obj)
3277 #ifdef HAVE_ATOMIC_BUILTINS
3278 unsigned int rc = __sync_sub_and_fetch (&obj->ref, 1);
3281 if (--obj->ref == 0) {
3283 ucl_object_free_internal (obj, true, ucl_object_dtor_unref);
3289 ucl_object_compare (const ucl_object_t *o1, const ucl_object_t *o2)
3291 const ucl_object_t *it1, *it2;
3292 ucl_object_iter_t iter = NULL;
3295 if (o1->type != o2->type) {
3296 return (o1->type) - (o2->type);
3301 if (o1->len == o2->len && o1->len > 0) {
3302 ret = strcmp (ucl_object_tostring(o1), ucl_object_tostring(o2));
3305 ret = o1->len - o2->len;
3311 ret = ucl_object_todouble (o1) - ucl_object_todouble (o2);
3314 ret = ucl_object_toboolean (o1) - ucl_object_toboolean (o2);
3317 if (o1->len == o2->len && o1->len > 0) {
3318 UCL_ARRAY_GET (vec1, o1);
3319 UCL_ARRAY_GET (vec2, o2);
3322 /* Compare all elements in both arrays */
3323 for (i = 0; i < vec1->n; i ++) {
3324 it1 = kv_A (*vec1, i);
3325 it2 = kv_A (*vec2, i);
3327 if (it1 == NULL && it2 != NULL) {
3330 else if (it2 == NULL && it1 != NULL) {
3333 else if (it1 != NULL && it2 != NULL) {
3334 ret = ucl_object_compare (it1, it2);
3342 ret = o1->len - o2->len;
3346 if (o1->len == o2->len && o1->len > 0) {
3347 while ((it1 = ucl_object_iterate (o1, &iter, true)) != NULL) {
3348 it2 = ucl_object_lookup (o2, ucl_object_key (it1));
3353 ret = ucl_object_compare (it1, it2);
3360 ret = o1->len - o2->len;
3372 ucl_object_compare_qsort (const ucl_object_t **o1,
3373 const ucl_object_t **o2)
3375 return ucl_object_compare (*o1, *o2);
3379 ucl_object_array_sort (ucl_object_t *ar,
3380 int (*cmp)(const ucl_object_t **o1, const ucl_object_t **o2))
3382 UCL_ARRAY_GET (vec, ar);
3384 if (cmp == NULL || ar == NULL || ar->type != UCL_ARRAY) {
3388 qsort (vec->a, vec->n, sizeof (ucl_object_t *),
3389 (int (*)(const void *, const void *))cmp);
3395 ucl_object_get_priority (const ucl_object_t *obj)
3401 return (obj->flags >> ((sizeof (obj->flags) * NBBY) - PRIOBITS));
3405 ucl_object_set_priority (ucl_object_t *obj,
3406 unsigned int priority)
3409 priority &= (0x1 << PRIOBITS) - 1;
3410 priority <<= ((sizeof (obj->flags) * NBBY) - PRIOBITS);
3411 priority |= obj->flags & ((1 << ((sizeof (obj->flags) * NBBY) -
3413 obj->flags = priority;
3418 ucl_object_string_to_type (const char *input, ucl_type_t *res)
3420 if (strcasecmp (input, "object") == 0) {
3423 else if (strcasecmp (input, "array") == 0) {
3426 else if (strcasecmp (input, "integer") == 0) {
3429 else if (strcasecmp (input, "number") == 0) {
3432 else if (strcasecmp (input, "string") == 0) {
3435 else if (strcasecmp (input, "boolean") == 0) {
3438 else if (strcasecmp (input, "null") == 0) {
3441 else if (strcasecmp (input, "userdata") == 0) {
3442 *res = UCL_USERDATA;
3452 ucl_object_type_to_string (ucl_type_t type)
3454 const char *res = "unknown";
3487 const ucl_object_t *
3488 ucl_parser_get_comments (struct ucl_parser *parser)
3490 if (parser && parser->comments) {
3491 return parser->comments;
3497 const ucl_object_t *
3498 ucl_comments_find (const ucl_object_t *comments,
3499 const ucl_object_t *srch)
3501 if (comments && srch) {
3502 return ucl_object_lookup_len (comments, (const char *)&srch,
3510 ucl_comments_move (ucl_object_t *comments,
3511 const ucl_object_t *from, const ucl_object_t *to)
3513 const ucl_object_t *found;
3516 if (comments && from && to) {
3517 found = ucl_object_lookup_len (comments,
3518 (const char *)&from, sizeof (void *));
3522 obj = ucl_object_ref (found);
3523 ucl_object_delete_keyl (comments, (const char *)&from,
3525 ucl_object_insert_key (comments, obj, (const char *)&to,
3526 sizeof (void *), true);
3536 ucl_comments_add (ucl_object_t *comments, const ucl_object_t *obj,
3537 const char *comment)
3539 if (comments && obj && comment) {
3540 ucl_object_insert_key (comments, ucl_object_fromstring (comment),
3541 (const char *)&obj, sizeof (void *), true);