1c99fb5f9SBaptiste Daroussin /* Copyright (c) 2013, Vsevolod Stakhov 239ee7a7aSBaptiste Daroussin * Copyright (c) 2015 Allan Jude <allanjude@freebsd.org> 3c99fb5f9SBaptiste Daroussin * All rights reserved. 4c99fb5f9SBaptiste Daroussin * 5c99fb5f9SBaptiste Daroussin * Redistribution and use in source and binary forms, with or without 6c99fb5f9SBaptiste Daroussin * modification, are permitted provided that the following conditions are met: 7c99fb5f9SBaptiste Daroussin * * Redistributions of source code must retain the above copyright 8c99fb5f9SBaptiste Daroussin * notice, this list of conditions and the following disclaimer. 9c99fb5f9SBaptiste Daroussin * * Redistributions in binary form must reproduce the above copyright 10c99fb5f9SBaptiste Daroussin * notice, this list of conditions and the following disclaimer in the 11c99fb5f9SBaptiste Daroussin * documentation and/or other materials provided with the distribution. 12c99fb5f9SBaptiste Daroussin * 13c99fb5f9SBaptiste Daroussin * THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY 14c99fb5f9SBaptiste Daroussin * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 15c99fb5f9SBaptiste Daroussin * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 16c99fb5f9SBaptiste Daroussin * DISCLAIMED. IN NO EVENT SHALL AUTHOR BE LIABLE FOR ANY 17c99fb5f9SBaptiste Daroussin * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 18c99fb5f9SBaptiste Daroussin * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 19c99fb5f9SBaptiste Daroussin * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 20c99fb5f9SBaptiste Daroussin * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 21c99fb5f9SBaptiste Daroussin * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 22c99fb5f9SBaptiste Daroussin * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 23c99fb5f9SBaptiste Daroussin */ 24c99fb5f9SBaptiste Daroussin 25c99fb5f9SBaptiste Daroussin #include "ucl.h" 26c99fb5f9SBaptiste Daroussin #include "ucl_internal.h" 27c99fb5f9SBaptiste Daroussin #include "ucl_chartable.h" 288e3b1ab2SBaptiste Daroussin #include "kvec.h" 2939ee7a7aSBaptiste Daroussin #include <stdarg.h> 30d9f0ce31SBaptiste Daroussin #include <stdio.h> /* for snprintf */ 31c99fb5f9SBaptiste Daroussin 328e3b1ab2SBaptiste Daroussin #ifndef _WIN32 334bf54857SBaptiste Daroussin #include <glob.h> 348e3b1ab2SBaptiste Daroussin #endif 354bf54857SBaptiste Daroussin 3697bd480fSBaptiste Daroussin #ifdef HAVE_LIBGEN_H 37c99fb5f9SBaptiste Daroussin #include <libgen.h> /* For dirname */ 3897bd480fSBaptiste Daroussin #endif 39c99fb5f9SBaptiste Daroussin 408e3b1ab2SBaptiste Daroussin typedef kvec_t(ucl_object_t *) ucl_array_t; 418e3b1ab2SBaptiste Daroussin 428e3b1ab2SBaptiste Daroussin #define UCL_ARRAY_GET(ar, obj) ucl_array_t *ar = \ 438e3b1ab2SBaptiste Daroussin (ucl_array_t *)((obj) != NULL ? (obj)->value.av : NULL) 448e3b1ab2SBaptiste Daroussin 45c99fb5f9SBaptiste Daroussin #ifdef HAVE_OPENSSL 46c99fb5f9SBaptiste Daroussin #include <openssl/err.h> 47c99fb5f9SBaptiste Daroussin #include <openssl/sha.h> 48c99fb5f9SBaptiste Daroussin #include <openssl/rsa.h> 49c99fb5f9SBaptiste Daroussin #include <openssl/ssl.h> 50c99fb5f9SBaptiste Daroussin #include <openssl/evp.h> 51c99fb5f9SBaptiste Daroussin #endif 52c99fb5f9SBaptiste Daroussin 5397bd480fSBaptiste Daroussin #ifdef CURL_FOUND 54d9f0ce31SBaptiste Daroussin /* Seems to be broken */ 55d9f0ce31SBaptiste Daroussin #define CURL_DISABLE_TYPECHECK 1 5697bd480fSBaptiste Daroussin #include <curl/curl.h> 5797bd480fSBaptiste Daroussin #endif 5897bd480fSBaptiste Daroussin #ifdef HAVE_FETCH_H 5997bd480fSBaptiste Daroussin #include <fetch.h> 6097bd480fSBaptiste Daroussin #endif 6197bd480fSBaptiste Daroussin 6236c53d67SBaptiste Daroussin #ifdef _WIN32 6336c53d67SBaptiste Daroussin #include <windows.h> 6436c53d67SBaptiste Daroussin 6597bd480fSBaptiste Daroussin #ifndef PROT_READ 6636c53d67SBaptiste Daroussin #define PROT_READ 1 6797bd480fSBaptiste Daroussin #endif 6897bd480fSBaptiste Daroussin #ifndef PROT_WRITE 6936c53d67SBaptiste Daroussin #define PROT_WRITE 2 7097bd480fSBaptiste Daroussin #endif 7197bd480fSBaptiste Daroussin #ifndef PROT_READWRITE 7236c53d67SBaptiste Daroussin #define PROT_READWRITE 3 7397bd480fSBaptiste Daroussin #endif 7497bd480fSBaptiste Daroussin #ifndef MAP_SHARED 7536c53d67SBaptiste Daroussin #define MAP_SHARED 1 7697bd480fSBaptiste Daroussin #endif 7797bd480fSBaptiste Daroussin #ifndef MAP_PRIVATE 7836c53d67SBaptiste Daroussin #define MAP_PRIVATE 2 7997bd480fSBaptiste Daroussin #endif 8097bd480fSBaptiste Daroussin #ifndef MAP_FAILED 8136c53d67SBaptiste Daroussin #define MAP_FAILED ((void *) -1) 8297bd480fSBaptiste Daroussin #endif 8336c53d67SBaptiste Daroussin 848e3b1ab2SBaptiste Daroussin #ifdef _WIN32 858e3b1ab2SBaptiste Daroussin #include <limits.h> 868e3b1ab2SBaptiste Daroussin #define NBBY CHAR_BIT 878e3b1ab2SBaptiste Daroussin #endif 888e3b1ab2SBaptiste Daroussin 8997bd480fSBaptiste Daroussin static void *ucl_mmap(char *addr, size_t length, int prot, int access, int fd, off_t offset) 9036c53d67SBaptiste Daroussin { 9136c53d67SBaptiste Daroussin void *map = NULL; 9236c53d67SBaptiste Daroussin HANDLE handle = INVALID_HANDLE_VALUE; 9336c53d67SBaptiste Daroussin 9436c53d67SBaptiste Daroussin switch (prot) { 9536c53d67SBaptiste Daroussin default: 9636c53d67SBaptiste Daroussin case PROT_READ: 9736c53d67SBaptiste Daroussin { 9836c53d67SBaptiste Daroussin handle = CreateFileMapping((HANDLE) _get_osfhandle(fd), 0, PAGE_READONLY, 0, length, 0); 9936c53d67SBaptiste Daroussin if (!handle) break; 10036c53d67SBaptiste Daroussin map = (void *) MapViewOfFile(handle, FILE_MAP_READ, 0, 0, length); 10136c53d67SBaptiste Daroussin CloseHandle(handle); 10236c53d67SBaptiste Daroussin break; 10336c53d67SBaptiste Daroussin } 10436c53d67SBaptiste Daroussin case PROT_WRITE: 10536c53d67SBaptiste Daroussin { 10636c53d67SBaptiste Daroussin handle = CreateFileMapping((HANDLE) _get_osfhandle(fd), 0, PAGE_READWRITE, 0, length, 0); 10736c53d67SBaptiste Daroussin if (!handle) break; 10836c53d67SBaptiste Daroussin map = (void *) MapViewOfFile(handle, FILE_MAP_WRITE, 0, 0, length); 10936c53d67SBaptiste Daroussin CloseHandle(handle); 11036c53d67SBaptiste Daroussin break; 11136c53d67SBaptiste Daroussin } 11236c53d67SBaptiste Daroussin case PROT_READWRITE: 11336c53d67SBaptiste Daroussin { 11436c53d67SBaptiste Daroussin handle = CreateFileMapping((HANDLE) _get_osfhandle(fd), 0, PAGE_READWRITE, 0, length, 0); 11536c53d67SBaptiste Daroussin if (!handle) break; 11636c53d67SBaptiste Daroussin map = (void *) MapViewOfFile(handle, FILE_MAP_ALL_ACCESS, 0, 0, length); 11736c53d67SBaptiste Daroussin CloseHandle(handle); 11836c53d67SBaptiste Daroussin break; 11936c53d67SBaptiste Daroussin } 12036c53d67SBaptiste Daroussin } 12136c53d67SBaptiste Daroussin if (map == (void *) NULL) { 12236c53d67SBaptiste Daroussin return (void *) MAP_FAILED; 12336c53d67SBaptiste Daroussin } 12436c53d67SBaptiste Daroussin return (void *) ((char *) map + offset); 12536c53d67SBaptiste Daroussin } 12636c53d67SBaptiste Daroussin 12797bd480fSBaptiste Daroussin static int ucl_munmap(void *map,size_t length) 12836c53d67SBaptiste Daroussin { 12936c53d67SBaptiste Daroussin if (!UnmapViewOfFile(map)) { 13036c53d67SBaptiste Daroussin return(-1); 13136c53d67SBaptiste Daroussin } 13236c53d67SBaptiste Daroussin return(0); 13336c53d67SBaptiste Daroussin } 13436c53d67SBaptiste Daroussin 13597bd480fSBaptiste Daroussin static char* ucl_realpath(const char *path, char *resolved_path) { 13636c53d67SBaptiste Daroussin char *p; 13736c53d67SBaptiste Daroussin char tmp[MAX_PATH + 1]; 13836c53d67SBaptiste Daroussin strncpy(tmp, path, sizeof(tmp)-1); 13936c53d67SBaptiste Daroussin p = tmp; 14036c53d67SBaptiste Daroussin while(*p) { 14136c53d67SBaptiste Daroussin if (*p == '/') *p = '\\'; 14236c53d67SBaptiste Daroussin p++; 14336c53d67SBaptiste Daroussin } 14436c53d67SBaptiste Daroussin return _fullpath(resolved_path, tmp, MAX_PATH); 14536c53d67SBaptiste Daroussin } 14697bd480fSBaptiste Daroussin #else 14797bd480fSBaptiste Daroussin #define ucl_mmap mmap 14897bd480fSBaptiste Daroussin #define ucl_munmap munmap 14997bd480fSBaptiste Daroussin #define ucl_realpath realpath 15036c53d67SBaptiste Daroussin #endif 15136c53d67SBaptiste Daroussin 152b04a7a0bSBaptiste Daroussin typedef void (*ucl_object_dtor) (ucl_object_t *obj); 153b04a7a0bSBaptiste Daroussin static void ucl_object_free_internal (ucl_object_t *obj, bool allow_rec, 154b04a7a0bSBaptiste Daroussin ucl_object_dtor dtor); 155b04a7a0bSBaptiste Daroussin static void ucl_object_dtor_unref (ucl_object_t *obj); 156c99fb5f9SBaptiste Daroussin 157c99fb5f9SBaptiste Daroussin static void 158b04a7a0bSBaptiste Daroussin ucl_object_dtor_free (ucl_object_t *obj) 159c99fb5f9SBaptiste Daroussin { 160c99fb5f9SBaptiste Daroussin if (obj->trash_stack[UCL_TRASH_KEY] != NULL) { 161c99fb5f9SBaptiste Daroussin UCL_FREE (obj->hh.keylen, obj->trash_stack[UCL_TRASH_KEY]); 162c99fb5f9SBaptiste Daroussin } 163c99fb5f9SBaptiste Daroussin if (obj->trash_stack[UCL_TRASH_VALUE] != NULL) { 164c99fb5f9SBaptiste Daroussin UCL_FREE (obj->len, obj->trash_stack[UCL_TRASH_VALUE]); 165c99fb5f9SBaptiste Daroussin } 1664bf54857SBaptiste Daroussin /* Do not free ephemeral objects */ 1674bf54857SBaptiste Daroussin if ((obj->flags & UCL_OBJECT_EPHEMERAL) == 0) { 1684bf54857SBaptiste Daroussin if (obj->type != UCL_USERDATA) { 169b04a7a0bSBaptiste Daroussin UCL_FREE (sizeof (ucl_object_t), obj); 170b04a7a0bSBaptiste Daroussin } 1714bf54857SBaptiste Daroussin else { 1724bf54857SBaptiste Daroussin struct ucl_object_userdata *ud = (struct ucl_object_userdata *)obj; 1734bf54857SBaptiste Daroussin if (ud->dtor) { 1744bf54857SBaptiste Daroussin ud->dtor (obj->value.ud); 1754bf54857SBaptiste Daroussin } 1764bf54857SBaptiste Daroussin UCL_FREE (sizeof (*ud), obj); 1774bf54857SBaptiste Daroussin } 1784bf54857SBaptiste Daroussin } 1794bf54857SBaptiste Daroussin } 180c99fb5f9SBaptiste Daroussin 181b04a7a0bSBaptiste Daroussin /* 182b04a7a0bSBaptiste Daroussin * This is a helper function that performs exactly the same as 183b04a7a0bSBaptiste Daroussin * `ucl_object_unref` but it doesn't iterate over elements allowing 184b04a7a0bSBaptiste Daroussin * to use it for individual elements of arrays and multiple values 185b04a7a0bSBaptiste Daroussin */ 186b04a7a0bSBaptiste Daroussin static void 187b04a7a0bSBaptiste Daroussin ucl_object_dtor_unref_single (ucl_object_t *obj) 188b04a7a0bSBaptiste Daroussin { 189b04a7a0bSBaptiste Daroussin if (obj != NULL) { 190b04a7a0bSBaptiste Daroussin #ifdef HAVE_ATOMIC_BUILTINS 191b04a7a0bSBaptiste Daroussin unsigned int rc = __sync_sub_and_fetch (&obj->ref, 1); 192b04a7a0bSBaptiste Daroussin if (rc == 0) { 193b04a7a0bSBaptiste Daroussin #else 194b04a7a0bSBaptiste Daroussin if (--obj->ref == 0) { 195b04a7a0bSBaptiste Daroussin #endif 196b04a7a0bSBaptiste Daroussin ucl_object_free_internal (obj, false, ucl_object_dtor_unref); 197b04a7a0bSBaptiste Daroussin } 198b04a7a0bSBaptiste Daroussin } 199b04a7a0bSBaptiste Daroussin } 200b04a7a0bSBaptiste Daroussin 201b04a7a0bSBaptiste Daroussin static void 202b04a7a0bSBaptiste Daroussin ucl_object_dtor_unref (ucl_object_t *obj) 203b04a7a0bSBaptiste Daroussin { 204b04a7a0bSBaptiste Daroussin if (obj->ref == 0) { 205b04a7a0bSBaptiste Daroussin ucl_object_dtor_free (obj); 206b04a7a0bSBaptiste Daroussin } 207b04a7a0bSBaptiste Daroussin else { 208b04a7a0bSBaptiste Daroussin /* This may cause dtor unref being called one more time */ 209b04a7a0bSBaptiste Daroussin ucl_object_dtor_unref_single (obj); 210b04a7a0bSBaptiste Daroussin } 211b04a7a0bSBaptiste Daroussin } 212b04a7a0bSBaptiste Daroussin 213b04a7a0bSBaptiste Daroussin static void 214b04a7a0bSBaptiste Daroussin ucl_object_free_internal (ucl_object_t *obj, bool allow_rec, ucl_object_dtor dtor) 215b04a7a0bSBaptiste Daroussin { 2168e3b1ab2SBaptiste Daroussin ucl_object_t *tmp, *sub; 217b04a7a0bSBaptiste Daroussin 218b04a7a0bSBaptiste Daroussin while (obj != NULL) { 219c99fb5f9SBaptiste Daroussin if (obj->type == UCL_ARRAY) { 2208e3b1ab2SBaptiste Daroussin UCL_ARRAY_GET (vec, obj); 2218e3b1ab2SBaptiste Daroussin unsigned int i; 2228e3b1ab2SBaptiste Daroussin 2238e3b1ab2SBaptiste Daroussin if (vec != NULL) { 2248e3b1ab2SBaptiste Daroussin for (i = 0; i < vec->n; i ++) { 2258e3b1ab2SBaptiste Daroussin sub = kv_A (*vec, i); 2268e3b1ab2SBaptiste Daroussin if (sub != NULL) { 2278e3b1ab2SBaptiste Daroussin tmp = sub; 2288e3b1ab2SBaptiste Daroussin while (sub) { 229c99fb5f9SBaptiste Daroussin tmp = sub->next; 230b04a7a0bSBaptiste Daroussin dtor (sub); 231c99fb5f9SBaptiste Daroussin sub = tmp; 232c99fb5f9SBaptiste Daroussin } 233c99fb5f9SBaptiste Daroussin } 2348e3b1ab2SBaptiste Daroussin } 2358e3b1ab2SBaptiste Daroussin kv_destroy (*vec); 2368e3b1ab2SBaptiste Daroussin UCL_FREE (sizeof (*vec), vec); 2378e3b1ab2SBaptiste Daroussin } 23839ee7a7aSBaptiste Daroussin obj->value.av = NULL; 2398e3b1ab2SBaptiste Daroussin } 240c99fb5f9SBaptiste Daroussin else if (obj->type == UCL_OBJECT) { 241c99fb5f9SBaptiste Daroussin if (obj->value.ov != NULL) { 242d9f0ce31SBaptiste Daroussin ucl_hash_destroy (obj->value.ov, (ucl_hash_free_func)dtor); 243c99fb5f9SBaptiste Daroussin } 24439ee7a7aSBaptiste Daroussin obj->value.ov = NULL; 245c99fb5f9SBaptiste Daroussin } 246c99fb5f9SBaptiste Daroussin tmp = obj->next; 247b04a7a0bSBaptiste Daroussin dtor (obj); 248c99fb5f9SBaptiste Daroussin obj = tmp; 249c99fb5f9SBaptiste Daroussin 250c99fb5f9SBaptiste Daroussin if (!allow_rec) { 251c99fb5f9SBaptiste Daroussin break; 252c99fb5f9SBaptiste Daroussin } 253c99fb5f9SBaptiste Daroussin } 254c99fb5f9SBaptiste Daroussin } 255c99fb5f9SBaptiste Daroussin 256c99fb5f9SBaptiste Daroussin void 257c99fb5f9SBaptiste Daroussin ucl_object_free (ucl_object_t *obj) 258c99fb5f9SBaptiste Daroussin { 259b04a7a0bSBaptiste Daroussin ucl_object_free_internal (obj, true, ucl_object_dtor_free); 260c99fb5f9SBaptiste Daroussin } 261c99fb5f9SBaptiste Daroussin 262c99fb5f9SBaptiste Daroussin size_t 263c99fb5f9SBaptiste Daroussin ucl_unescape_json_string (char *str, size_t len) 264c99fb5f9SBaptiste Daroussin { 265c99fb5f9SBaptiste Daroussin char *t = str, *h = str; 266c99fb5f9SBaptiste Daroussin int i, uval; 267c99fb5f9SBaptiste Daroussin 26897bd480fSBaptiste Daroussin if (len <= 1) { 26997bd480fSBaptiste Daroussin return len; 27097bd480fSBaptiste Daroussin } 271c99fb5f9SBaptiste Daroussin /* t is target (tortoise), h is source (hare) */ 272c99fb5f9SBaptiste Daroussin 273c99fb5f9SBaptiste Daroussin while (len) { 274c99fb5f9SBaptiste Daroussin if (*h == '\\') { 275c99fb5f9SBaptiste Daroussin h ++; 27639ee7a7aSBaptiste Daroussin 27739ee7a7aSBaptiste Daroussin if (len == 1) { 27839ee7a7aSBaptiste Daroussin /* 27939ee7a7aSBaptiste Daroussin * If \ is last, then do not try to go further 28039ee7a7aSBaptiste Daroussin * Issue: #74 28139ee7a7aSBaptiste Daroussin */ 28239ee7a7aSBaptiste Daroussin len --; 28339ee7a7aSBaptiste Daroussin *t++ = '\\'; 28439ee7a7aSBaptiste Daroussin continue; 28539ee7a7aSBaptiste Daroussin } 28639ee7a7aSBaptiste Daroussin 287c99fb5f9SBaptiste Daroussin switch (*h) { 288c99fb5f9SBaptiste Daroussin case 'n': 289c99fb5f9SBaptiste Daroussin *t++ = '\n'; 290c99fb5f9SBaptiste Daroussin break; 291c99fb5f9SBaptiste Daroussin case 'r': 292c99fb5f9SBaptiste Daroussin *t++ = '\r'; 293c99fb5f9SBaptiste Daroussin break; 294c99fb5f9SBaptiste Daroussin case 'b': 295c99fb5f9SBaptiste Daroussin *t++ = '\b'; 296c99fb5f9SBaptiste Daroussin break; 297c99fb5f9SBaptiste Daroussin case 't': 298c99fb5f9SBaptiste Daroussin *t++ = '\t'; 299c99fb5f9SBaptiste Daroussin break; 300c99fb5f9SBaptiste Daroussin case 'f': 301c99fb5f9SBaptiste Daroussin *t++ = '\f'; 302c99fb5f9SBaptiste Daroussin break; 303c99fb5f9SBaptiste Daroussin case '\\': 304c99fb5f9SBaptiste Daroussin *t++ = '\\'; 305c99fb5f9SBaptiste Daroussin break; 306c99fb5f9SBaptiste Daroussin case '"': 307c99fb5f9SBaptiste Daroussin *t++ = '"'; 308c99fb5f9SBaptiste Daroussin break; 309c99fb5f9SBaptiste Daroussin case 'u': 310c99fb5f9SBaptiste Daroussin /* Unicode escape */ 311c99fb5f9SBaptiste Daroussin uval = 0; 312d9f0ce31SBaptiste Daroussin h ++; /* u character */ 313d9f0ce31SBaptiste Daroussin len --; 314d9f0ce31SBaptiste Daroussin 31597bd480fSBaptiste Daroussin if (len > 3) { 316c99fb5f9SBaptiste Daroussin for (i = 0; i < 4; i++) { 317c99fb5f9SBaptiste Daroussin uval <<= 4; 318c99fb5f9SBaptiste Daroussin if (isdigit (h[i])) { 319c99fb5f9SBaptiste Daroussin uval += h[i] - '0'; 320c99fb5f9SBaptiste Daroussin } 321c99fb5f9SBaptiste Daroussin else if (h[i] >= 'a' && h[i] <= 'f') { 322c99fb5f9SBaptiste Daroussin uval += h[i] - 'a' + 10; 323c99fb5f9SBaptiste Daroussin } 324c99fb5f9SBaptiste Daroussin else if (h[i] >= 'A' && h[i] <= 'F') { 325c99fb5f9SBaptiste Daroussin uval += h[i] - 'A' + 10; 326c99fb5f9SBaptiste Daroussin } 32797bd480fSBaptiste Daroussin else { 32897bd480fSBaptiste Daroussin break; 32997bd480fSBaptiste Daroussin } 330c99fb5f9SBaptiste Daroussin } 331d9f0ce31SBaptiste Daroussin 332c99fb5f9SBaptiste Daroussin /* Encode */ 333c99fb5f9SBaptiste Daroussin if(uval < 0x80) { 334c99fb5f9SBaptiste Daroussin t[0] = (char)uval; 335c99fb5f9SBaptiste Daroussin t ++; 336c99fb5f9SBaptiste Daroussin } 337c99fb5f9SBaptiste Daroussin else if(uval < 0x800) { 338c99fb5f9SBaptiste Daroussin t[0] = 0xC0 + ((uval & 0x7C0) >> 6); 339c99fb5f9SBaptiste Daroussin t[1] = 0x80 + ((uval & 0x03F)); 340c99fb5f9SBaptiste Daroussin t += 2; 341c99fb5f9SBaptiste Daroussin } 342c99fb5f9SBaptiste Daroussin else if(uval < 0x10000) { 343c99fb5f9SBaptiste Daroussin t[0] = 0xE0 + ((uval & 0xF000) >> 12); 344c99fb5f9SBaptiste Daroussin t[1] = 0x80 + ((uval & 0x0FC0) >> 6); 345c99fb5f9SBaptiste Daroussin t[2] = 0x80 + ((uval & 0x003F)); 346c99fb5f9SBaptiste Daroussin t += 3; 347c99fb5f9SBaptiste Daroussin } 348d9f0ce31SBaptiste Daroussin #if 0 349d9f0ce31SBaptiste Daroussin /* It's not actually supported now */ 350c99fb5f9SBaptiste Daroussin else if(uval <= 0x10FFFF) { 351c99fb5f9SBaptiste Daroussin t[0] = 0xF0 + ((uval & 0x1C0000) >> 18); 352c99fb5f9SBaptiste Daroussin t[1] = 0x80 + ((uval & 0x03F000) >> 12); 353c99fb5f9SBaptiste Daroussin t[2] = 0x80 + ((uval & 0x000FC0) >> 6); 354c99fb5f9SBaptiste Daroussin t[3] = 0x80 + ((uval & 0x00003F)); 355c99fb5f9SBaptiste Daroussin t += 4; 356c99fb5f9SBaptiste Daroussin } 357d9f0ce31SBaptiste Daroussin #endif 358c99fb5f9SBaptiste Daroussin else { 359c99fb5f9SBaptiste Daroussin *t++ = '?'; 360c99fb5f9SBaptiste Daroussin } 361d9f0ce31SBaptiste Daroussin 362d9f0ce31SBaptiste Daroussin /* Consume 4 characters of source */ 363d9f0ce31SBaptiste Daroussin h += 4; 364d9f0ce31SBaptiste Daroussin len -= 4; 365d9f0ce31SBaptiste Daroussin 366d9f0ce31SBaptiste Daroussin if (len > 0) { 367d9f0ce31SBaptiste Daroussin len --; /* for '\' character */ 368d9f0ce31SBaptiste Daroussin } 369d9f0ce31SBaptiste Daroussin continue; 37097bd480fSBaptiste Daroussin } 37197bd480fSBaptiste Daroussin else { 37297bd480fSBaptiste Daroussin *t++ = 'u'; 37397bd480fSBaptiste Daroussin } 374c99fb5f9SBaptiste Daroussin break; 375c99fb5f9SBaptiste Daroussin default: 376c99fb5f9SBaptiste Daroussin *t++ = *h; 377c99fb5f9SBaptiste Daroussin break; 378c99fb5f9SBaptiste Daroussin } 379c99fb5f9SBaptiste Daroussin h ++; 380c99fb5f9SBaptiste Daroussin len --; 381c99fb5f9SBaptiste Daroussin } 382c99fb5f9SBaptiste Daroussin else { 383c99fb5f9SBaptiste Daroussin *t++ = *h++; 384c99fb5f9SBaptiste Daroussin } 38539ee7a7aSBaptiste Daroussin 38639ee7a7aSBaptiste Daroussin if (len > 0) { 387c99fb5f9SBaptiste Daroussin len --; 388c99fb5f9SBaptiste Daroussin } 38939ee7a7aSBaptiste Daroussin } 390c99fb5f9SBaptiste Daroussin *t = '\0'; 391c99fb5f9SBaptiste Daroussin 392c99fb5f9SBaptiste Daroussin return (t - str); 393c99fb5f9SBaptiste Daroussin } 394c99fb5f9SBaptiste Daroussin 395b04a7a0bSBaptiste Daroussin char * 396b04a7a0bSBaptiste Daroussin ucl_copy_key_trash (const ucl_object_t *obj) 397c99fb5f9SBaptiste Daroussin { 398b04a7a0bSBaptiste Daroussin ucl_object_t *deconst; 399b04a7a0bSBaptiste Daroussin 40097bd480fSBaptiste Daroussin if (obj == NULL) { 40197bd480fSBaptiste Daroussin return NULL; 40297bd480fSBaptiste Daroussin } 403c99fb5f9SBaptiste Daroussin if (obj->trash_stack[UCL_TRASH_KEY] == NULL && obj->key != NULL) { 404b04a7a0bSBaptiste Daroussin deconst = __DECONST (ucl_object_t *, obj); 405b04a7a0bSBaptiste Daroussin deconst->trash_stack[UCL_TRASH_KEY] = malloc (obj->keylen + 1); 406b04a7a0bSBaptiste Daroussin if (deconst->trash_stack[UCL_TRASH_KEY] != NULL) { 407b04a7a0bSBaptiste Daroussin memcpy (deconst->trash_stack[UCL_TRASH_KEY], obj->key, obj->keylen); 408b04a7a0bSBaptiste Daroussin deconst->trash_stack[UCL_TRASH_KEY][obj->keylen] = '\0'; 409c99fb5f9SBaptiste Daroussin } 410b04a7a0bSBaptiste Daroussin deconst->key = obj->trash_stack[UCL_TRASH_KEY]; 411b04a7a0bSBaptiste Daroussin deconst->flags |= UCL_OBJECT_ALLOCATED_KEY; 412c99fb5f9SBaptiste Daroussin } 413c99fb5f9SBaptiste Daroussin 414c99fb5f9SBaptiste Daroussin return obj->trash_stack[UCL_TRASH_KEY]; 415c99fb5f9SBaptiste Daroussin } 416c99fb5f9SBaptiste Daroussin 417b04a7a0bSBaptiste Daroussin char * 418b04a7a0bSBaptiste Daroussin ucl_copy_value_trash (const ucl_object_t *obj) 419c99fb5f9SBaptiste Daroussin { 420b04a7a0bSBaptiste Daroussin ucl_object_t *deconst; 421b04a7a0bSBaptiste Daroussin 42297bd480fSBaptiste Daroussin if (obj == NULL) { 42397bd480fSBaptiste Daroussin return NULL; 42497bd480fSBaptiste Daroussin } 425c99fb5f9SBaptiste Daroussin if (obj->trash_stack[UCL_TRASH_VALUE] == NULL) { 426b04a7a0bSBaptiste Daroussin deconst = __DECONST (ucl_object_t *, obj); 427c99fb5f9SBaptiste Daroussin if (obj->type == UCL_STRING) { 428b04a7a0bSBaptiste Daroussin 429c99fb5f9SBaptiste Daroussin /* Special case for strings */ 43039ee7a7aSBaptiste Daroussin if (obj->flags & UCL_OBJECT_BINARY) { 43139ee7a7aSBaptiste Daroussin deconst->trash_stack[UCL_TRASH_VALUE] = malloc (obj->len); 43239ee7a7aSBaptiste Daroussin if (deconst->trash_stack[UCL_TRASH_VALUE] != NULL) { 43339ee7a7aSBaptiste Daroussin memcpy (deconst->trash_stack[UCL_TRASH_VALUE], 43439ee7a7aSBaptiste Daroussin obj->value.sv, 43539ee7a7aSBaptiste Daroussin obj->len); 43639ee7a7aSBaptiste Daroussin deconst->value.sv = obj->trash_stack[UCL_TRASH_VALUE]; 43739ee7a7aSBaptiste Daroussin } 43839ee7a7aSBaptiste Daroussin } 43939ee7a7aSBaptiste Daroussin else { 440b04a7a0bSBaptiste Daroussin deconst->trash_stack[UCL_TRASH_VALUE] = malloc (obj->len + 1); 441b04a7a0bSBaptiste Daroussin if (deconst->trash_stack[UCL_TRASH_VALUE] != NULL) { 44239ee7a7aSBaptiste Daroussin memcpy (deconst->trash_stack[UCL_TRASH_VALUE], 44339ee7a7aSBaptiste Daroussin obj->value.sv, 44439ee7a7aSBaptiste Daroussin obj->len); 445b04a7a0bSBaptiste Daroussin deconst->trash_stack[UCL_TRASH_VALUE][obj->len] = '\0'; 446b04a7a0bSBaptiste Daroussin deconst->value.sv = obj->trash_stack[UCL_TRASH_VALUE]; 447c99fb5f9SBaptiste Daroussin } 448c99fb5f9SBaptiste Daroussin } 44939ee7a7aSBaptiste Daroussin } 450c99fb5f9SBaptiste Daroussin else { 451c99fb5f9SBaptiste Daroussin /* Just emit value in json notation */ 452b04a7a0bSBaptiste Daroussin deconst->trash_stack[UCL_TRASH_VALUE] = ucl_object_emit_single_json (obj); 453b04a7a0bSBaptiste Daroussin deconst->len = strlen (obj->trash_stack[UCL_TRASH_VALUE]); 454c99fb5f9SBaptiste Daroussin } 455b04a7a0bSBaptiste Daroussin deconst->flags |= UCL_OBJECT_ALLOCATED_VALUE; 456c99fb5f9SBaptiste Daroussin } 45739ee7a7aSBaptiste Daroussin 458c99fb5f9SBaptiste Daroussin return obj->trash_stack[UCL_TRASH_VALUE]; 459c99fb5f9SBaptiste Daroussin } 460c99fb5f9SBaptiste Daroussin 46139ee7a7aSBaptiste Daroussin ucl_object_t* 462c99fb5f9SBaptiste Daroussin ucl_parser_get_object (struct ucl_parser *parser) 463c99fb5f9SBaptiste Daroussin { 464c99fb5f9SBaptiste Daroussin if (parser->state != UCL_STATE_ERROR && parser->top_obj != NULL) { 465c99fb5f9SBaptiste Daroussin return ucl_object_ref (parser->top_obj); 466c99fb5f9SBaptiste Daroussin } 467c99fb5f9SBaptiste Daroussin 468c99fb5f9SBaptiste Daroussin return NULL; 469c99fb5f9SBaptiste Daroussin } 470c99fb5f9SBaptiste Daroussin 47139ee7a7aSBaptiste Daroussin void 472c99fb5f9SBaptiste Daroussin ucl_parser_free (struct ucl_parser *parser) 473c99fb5f9SBaptiste Daroussin { 474c99fb5f9SBaptiste Daroussin struct ucl_stack *stack, *stmp; 475c99fb5f9SBaptiste Daroussin struct ucl_macro *macro, *mtmp; 476c99fb5f9SBaptiste Daroussin struct ucl_chunk *chunk, *ctmp; 477c99fb5f9SBaptiste Daroussin struct ucl_pubkey *key, *ktmp; 478c99fb5f9SBaptiste Daroussin struct ucl_variable *var, *vtmp; 47939ee7a7aSBaptiste Daroussin ucl_object_t *tr, *trtmp; 480c99fb5f9SBaptiste Daroussin 48197bd480fSBaptiste Daroussin if (parser == NULL) { 48297bd480fSBaptiste Daroussin return; 48397bd480fSBaptiste Daroussin } 48497bd480fSBaptiste Daroussin 485c99fb5f9SBaptiste Daroussin if (parser->top_obj != NULL) { 486c99fb5f9SBaptiste Daroussin ucl_object_unref (parser->top_obj); 487c99fb5f9SBaptiste Daroussin } 488c99fb5f9SBaptiste Daroussin 48939ee7a7aSBaptiste Daroussin if (parser->includepaths != NULL) { 49039ee7a7aSBaptiste Daroussin ucl_object_unref (parser->includepaths); 49139ee7a7aSBaptiste Daroussin } 49239ee7a7aSBaptiste Daroussin 493c99fb5f9SBaptiste Daroussin LL_FOREACH_SAFE (parser->stack, stack, stmp) { 494c99fb5f9SBaptiste Daroussin free (stack); 495c99fb5f9SBaptiste Daroussin } 496c99fb5f9SBaptiste Daroussin HASH_ITER (hh, parser->macroes, macro, mtmp) { 497c99fb5f9SBaptiste Daroussin free (macro->name); 498c99fb5f9SBaptiste Daroussin HASH_DEL (parser->macroes, macro); 499c99fb5f9SBaptiste Daroussin UCL_FREE (sizeof (struct ucl_macro), macro); 500c99fb5f9SBaptiste Daroussin } 501c99fb5f9SBaptiste Daroussin LL_FOREACH_SAFE (parser->chunks, chunk, ctmp) { 502c99fb5f9SBaptiste Daroussin UCL_FREE (sizeof (struct ucl_chunk), chunk); 503c99fb5f9SBaptiste Daroussin } 504c99fb5f9SBaptiste Daroussin LL_FOREACH_SAFE (parser->keys, key, ktmp) { 505c99fb5f9SBaptiste Daroussin UCL_FREE (sizeof (struct ucl_pubkey), key); 506c99fb5f9SBaptiste Daroussin } 507c99fb5f9SBaptiste Daroussin LL_FOREACH_SAFE (parser->variables, var, vtmp) { 508c99fb5f9SBaptiste Daroussin free (var->value); 509c99fb5f9SBaptiste Daroussin free (var->var); 510c99fb5f9SBaptiste Daroussin UCL_FREE (sizeof (struct ucl_variable), var); 511c99fb5f9SBaptiste Daroussin } 51239ee7a7aSBaptiste Daroussin LL_FOREACH_SAFE (parser->trash_objs, tr, trtmp) { 51339ee7a7aSBaptiste Daroussin ucl_object_free_internal (tr, false, ucl_object_dtor_free); 51439ee7a7aSBaptiste Daroussin } 515c99fb5f9SBaptiste Daroussin 516c99fb5f9SBaptiste Daroussin if (parser->err != NULL) { 517c99fb5f9SBaptiste Daroussin utstring_free (parser->err); 518c99fb5f9SBaptiste Daroussin } 519c99fb5f9SBaptiste Daroussin 5204bf54857SBaptiste Daroussin if (parser->cur_file) { 5214bf54857SBaptiste Daroussin free (parser->cur_file); 5224bf54857SBaptiste Daroussin } 5234bf54857SBaptiste Daroussin 524d9f0ce31SBaptiste Daroussin if (parser->comments) { 525d9f0ce31SBaptiste Daroussin ucl_object_unref (parser->comments); 526d9f0ce31SBaptiste Daroussin } 527d9f0ce31SBaptiste Daroussin 528c99fb5f9SBaptiste Daroussin UCL_FREE (sizeof (struct ucl_parser), parser); 529c99fb5f9SBaptiste Daroussin } 530c99fb5f9SBaptiste Daroussin 53139ee7a7aSBaptiste Daroussin const char * 532c99fb5f9SBaptiste Daroussin ucl_parser_get_error(struct ucl_parser *parser) 533c99fb5f9SBaptiste Daroussin { 53497bd480fSBaptiste Daroussin if (parser == NULL) { 53597bd480fSBaptiste Daroussin return NULL; 53697bd480fSBaptiste Daroussin } 53797bd480fSBaptiste Daroussin 53839ee7a7aSBaptiste Daroussin if (parser->err == NULL) { 539c99fb5f9SBaptiste Daroussin return NULL; 54039ee7a7aSBaptiste Daroussin } 541c99fb5f9SBaptiste Daroussin 542c99fb5f9SBaptiste Daroussin return utstring_body (parser->err); 543c99fb5f9SBaptiste Daroussin } 544c99fb5f9SBaptiste Daroussin 54539ee7a7aSBaptiste Daroussin int 54639ee7a7aSBaptiste Daroussin ucl_parser_get_error_code(struct ucl_parser *parser) 54739ee7a7aSBaptiste Daroussin { 54839ee7a7aSBaptiste Daroussin if (parser == NULL) { 54939ee7a7aSBaptiste Daroussin return 0; 55039ee7a7aSBaptiste Daroussin } 55139ee7a7aSBaptiste Daroussin 55239ee7a7aSBaptiste Daroussin return parser->err_code; 55339ee7a7aSBaptiste Daroussin } 55439ee7a7aSBaptiste Daroussin 55539ee7a7aSBaptiste Daroussin unsigned 55639ee7a7aSBaptiste Daroussin ucl_parser_get_column(struct ucl_parser *parser) 55739ee7a7aSBaptiste Daroussin { 55839ee7a7aSBaptiste Daroussin if (parser == NULL || parser->chunks == NULL) { 55939ee7a7aSBaptiste Daroussin return 0; 56039ee7a7aSBaptiste Daroussin } 56139ee7a7aSBaptiste Daroussin 56239ee7a7aSBaptiste Daroussin return parser->chunks->column; 56339ee7a7aSBaptiste Daroussin } 56439ee7a7aSBaptiste Daroussin 56539ee7a7aSBaptiste Daroussin unsigned 56639ee7a7aSBaptiste Daroussin ucl_parser_get_linenum(struct ucl_parser *parser) 56739ee7a7aSBaptiste Daroussin { 56839ee7a7aSBaptiste Daroussin if (parser == NULL || parser->chunks == NULL) { 56939ee7a7aSBaptiste Daroussin return 0; 57039ee7a7aSBaptiste Daroussin } 57139ee7a7aSBaptiste Daroussin 57239ee7a7aSBaptiste Daroussin return parser->chunks->line; 57339ee7a7aSBaptiste Daroussin } 57439ee7a7aSBaptiste Daroussin 57539ee7a7aSBaptiste Daroussin void 5768e3b1ab2SBaptiste Daroussin ucl_parser_clear_error(struct ucl_parser *parser) 5778e3b1ab2SBaptiste Daroussin { 5788e3b1ab2SBaptiste Daroussin if (parser != NULL && parser->err != NULL) { 5798e3b1ab2SBaptiste Daroussin utstring_free(parser->err); 5808e3b1ab2SBaptiste Daroussin parser->err = NULL; 58139ee7a7aSBaptiste Daroussin parser->err_code = 0; 5828e3b1ab2SBaptiste Daroussin } 5838e3b1ab2SBaptiste Daroussin } 5848e3b1ab2SBaptiste Daroussin 58539ee7a7aSBaptiste Daroussin bool 586c99fb5f9SBaptiste Daroussin ucl_pubkey_add (struct ucl_parser *parser, const unsigned char *key, size_t len) 587c99fb5f9SBaptiste Daroussin { 588c99fb5f9SBaptiste Daroussin #ifndef HAVE_OPENSSL 589c99fb5f9SBaptiste Daroussin ucl_create_err (&parser->err, "cannot check signatures without openssl"); 590c99fb5f9SBaptiste Daroussin return false; 591c99fb5f9SBaptiste Daroussin #else 592c99fb5f9SBaptiste Daroussin # if (OPENSSL_VERSION_NUMBER < 0x10000000L) 593c99fb5f9SBaptiste Daroussin ucl_create_err (&parser->err, "cannot check signatures, openssl version is unsupported"); 594c99fb5f9SBaptiste Daroussin return EXIT_FAILURE; 595c99fb5f9SBaptiste Daroussin # else 596c99fb5f9SBaptiste Daroussin struct ucl_pubkey *nkey; 597c99fb5f9SBaptiste Daroussin BIO *mem; 598c99fb5f9SBaptiste Daroussin 599c99fb5f9SBaptiste Daroussin mem = BIO_new_mem_buf ((void *)key, len); 600c99fb5f9SBaptiste Daroussin nkey = UCL_ALLOC (sizeof (struct ucl_pubkey)); 60197bd480fSBaptiste Daroussin if (nkey == NULL) { 60297bd480fSBaptiste Daroussin ucl_create_err (&parser->err, "cannot allocate memory for key"); 60397bd480fSBaptiste Daroussin return false; 60497bd480fSBaptiste Daroussin } 605c99fb5f9SBaptiste Daroussin nkey->key = PEM_read_bio_PUBKEY (mem, &nkey->key, NULL, NULL); 606c99fb5f9SBaptiste Daroussin BIO_free (mem); 607c99fb5f9SBaptiste Daroussin if (nkey->key == NULL) { 608c99fb5f9SBaptiste Daroussin UCL_FREE (sizeof (struct ucl_pubkey), nkey); 609c99fb5f9SBaptiste Daroussin ucl_create_err (&parser->err, "%s", 610c99fb5f9SBaptiste Daroussin ERR_error_string (ERR_get_error (), NULL)); 611c99fb5f9SBaptiste Daroussin return false; 612c99fb5f9SBaptiste Daroussin } 613c99fb5f9SBaptiste Daroussin LL_PREPEND (parser->keys, nkey); 614c99fb5f9SBaptiste Daroussin # endif 615c99fb5f9SBaptiste Daroussin #endif 616c99fb5f9SBaptiste Daroussin return true; 617c99fb5f9SBaptiste Daroussin } 618c99fb5f9SBaptiste Daroussin 619c99fb5f9SBaptiste Daroussin #ifdef CURL_FOUND 620c99fb5f9SBaptiste Daroussin struct ucl_curl_cbdata { 621c99fb5f9SBaptiste Daroussin unsigned char *buf; 622c99fb5f9SBaptiste Daroussin size_t buflen; 623c99fb5f9SBaptiste Daroussin }; 624c99fb5f9SBaptiste Daroussin 625c99fb5f9SBaptiste Daroussin static size_t 626c99fb5f9SBaptiste Daroussin ucl_curl_write_callback (void* contents, size_t size, size_t nmemb, void* ud) 627c99fb5f9SBaptiste Daroussin { 628c99fb5f9SBaptiste Daroussin struct ucl_curl_cbdata *cbdata = ud; 629c99fb5f9SBaptiste Daroussin size_t realsize = size * nmemb; 630c99fb5f9SBaptiste Daroussin 631c99fb5f9SBaptiste Daroussin cbdata->buf = realloc (cbdata->buf, cbdata->buflen + realsize + 1); 632c99fb5f9SBaptiste Daroussin if (cbdata->buf == NULL) { 633c99fb5f9SBaptiste Daroussin return 0; 634c99fb5f9SBaptiste Daroussin } 635c99fb5f9SBaptiste Daroussin 636c99fb5f9SBaptiste Daroussin memcpy (&(cbdata->buf[cbdata->buflen]), contents, realsize); 637c99fb5f9SBaptiste Daroussin cbdata->buflen += realsize; 638c99fb5f9SBaptiste Daroussin cbdata->buf[cbdata->buflen] = 0; 639c99fb5f9SBaptiste Daroussin 640c99fb5f9SBaptiste Daroussin return realsize; 641c99fb5f9SBaptiste Daroussin } 642c99fb5f9SBaptiste Daroussin #endif 643c99fb5f9SBaptiste Daroussin 644c99fb5f9SBaptiste Daroussin /** 645c99fb5f9SBaptiste Daroussin * Fetch a url and save results to the memory buffer 646c99fb5f9SBaptiste Daroussin * @param url url to fetch 647c99fb5f9SBaptiste Daroussin * @param len length of url 648c99fb5f9SBaptiste Daroussin * @param buf target buffer 649c99fb5f9SBaptiste Daroussin * @param buflen target length 650c99fb5f9SBaptiste Daroussin * @return 651c99fb5f9SBaptiste Daroussin */ 652d9f0ce31SBaptiste Daroussin bool 653c99fb5f9SBaptiste Daroussin ucl_fetch_url (const unsigned char *url, unsigned char **buf, size_t *buflen, 654c99fb5f9SBaptiste Daroussin UT_string **err, bool must_exist) 655c99fb5f9SBaptiste Daroussin { 656c99fb5f9SBaptiste Daroussin 657c99fb5f9SBaptiste Daroussin #ifdef HAVE_FETCH_H 658c99fb5f9SBaptiste Daroussin struct url *fetch_url; 659c99fb5f9SBaptiste Daroussin struct url_stat us; 660c99fb5f9SBaptiste Daroussin FILE *in; 661c99fb5f9SBaptiste Daroussin 662c99fb5f9SBaptiste Daroussin fetch_url = fetchParseURL (url); 663c99fb5f9SBaptiste Daroussin if (fetch_url == NULL) { 664c99fb5f9SBaptiste Daroussin ucl_create_err (err, "invalid URL %s: %s", 665c99fb5f9SBaptiste Daroussin url, strerror (errno)); 666c99fb5f9SBaptiste Daroussin return false; 667c99fb5f9SBaptiste Daroussin } 668c99fb5f9SBaptiste Daroussin if ((in = fetchXGet (fetch_url, &us, "")) == NULL) { 669c99fb5f9SBaptiste Daroussin if (!must_exist) { 670c99fb5f9SBaptiste Daroussin ucl_create_err (err, "cannot fetch URL %s: %s", 671c99fb5f9SBaptiste Daroussin url, strerror (errno)); 672c99fb5f9SBaptiste Daroussin } 673c99fb5f9SBaptiste Daroussin fetchFreeURL (fetch_url); 674c99fb5f9SBaptiste Daroussin return false; 675c99fb5f9SBaptiste Daroussin } 676c99fb5f9SBaptiste Daroussin 677c99fb5f9SBaptiste Daroussin *buflen = us.size; 678c99fb5f9SBaptiste Daroussin *buf = malloc (*buflen); 679c99fb5f9SBaptiste Daroussin if (*buf == NULL) { 680c99fb5f9SBaptiste Daroussin ucl_create_err (err, "cannot allocate buffer for URL %s: %s", 681c99fb5f9SBaptiste Daroussin url, strerror (errno)); 682c99fb5f9SBaptiste Daroussin fclose (in); 683c99fb5f9SBaptiste Daroussin fetchFreeURL (fetch_url); 684c99fb5f9SBaptiste Daroussin return false; 685c99fb5f9SBaptiste Daroussin } 686c99fb5f9SBaptiste Daroussin 687c99fb5f9SBaptiste Daroussin if (fread (*buf, *buflen, 1, in) != 1) { 688c99fb5f9SBaptiste Daroussin ucl_create_err (err, "cannot read URL %s: %s", 689c99fb5f9SBaptiste Daroussin url, strerror (errno)); 690c99fb5f9SBaptiste Daroussin fclose (in); 691c99fb5f9SBaptiste Daroussin fetchFreeURL (fetch_url); 692c99fb5f9SBaptiste Daroussin return false; 693c99fb5f9SBaptiste Daroussin } 694c99fb5f9SBaptiste Daroussin 695c99fb5f9SBaptiste Daroussin fetchFreeURL (fetch_url); 696c99fb5f9SBaptiste Daroussin return true; 697c99fb5f9SBaptiste Daroussin #elif defined(CURL_FOUND) 698c99fb5f9SBaptiste Daroussin CURL *curl; 699c99fb5f9SBaptiste Daroussin int r; 700c99fb5f9SBaptiste Daroussin struct ucl_curl_cbdata cbdata; 701c99fb5f9SBaptiste Daroussin 702c99fb5f9SBaptiste Daroussin curl = curl_easy_init (); 703c99fb5f9SBaptiste Daroussin if (curl == NULL) { 704c99fb5f9SBaptiste Daroussin ucl_create_err (err, "CURL interface is broken"); 705c99fb5f9SBaptiste Daroussin return false; 706c99fb5f9SBaptiste Daroussin } 707c99fb5f9SBaptiste Daroussin if ((r = curl_easy_setopt (curl, CURLOPT_URL, url)) != CURLE_OK) { 708c99fb5f9SBaptiste Daroussin ucl_create_err (err, "invalid URL %s: %s", 709c99fb5f9SBaptiste Daroussin url, curl_easy_strerror (r)); 710c99fb5f9SBaptiste Daroussin curl_easy_cleanup (curl); 711c99fb5f9SBaptiste Daroussin return false; 712c99fb5f9SBaptiste Daroussin } 713c99fb5f9SBaptiste Daroussin curl_easy_setopt (curl, CURLOPT_WRITEFUNCTION, ucl_curl_write_callback); 714d9f0ce31SBaptiste Daroussin cbdata.buf = NULL; 715d9f0ce31SBaptiste Daroussin cbdata.buflen = 0; 716c99fb5f9SBaptiste Daroussin curl_easy_setopt (curl, CURLOPT_WRITEDATA, &cbdata); 717c99fb5f9SBaptiste Daroussin 718c99fb5f9SBaptiste Daroussin if ((r = curl_easy_perform (curl)) != CURLE_OK) { 719c99fb5f9SBaptiste Daroussin if (!must_exist) { 720c99fb5f9SBaptiste Daroussin ucl_create_err (err, "error fetching URL %s: %s", 721c99fb5f9SBaptiste Daroussin url, curl_easy_strerror (r)); 722c99fb5f9SBaptiste Daroussin } 723c99fb5f9SBaptiste Daroussin curl_easy_cleanup (curl); 724c99fb5f9SBaptiste Daroussin if (cbdata.buf) { 725c99fb5f9SBaptiste Daroussin free (cbdata.buf); 726c99fb5f9SBaptiste Daroussin } 727c99fb5f9SBaptiste Daroussin return false; 728c99fb5f9SBaptiste Daroussin } 729c99fb5f9SBaptiste Daroussin *buf = cbdata.buf; 730c99fb5f9SBaptiste Daroussin *buflen = cbdata.buflen; 731c99fb5f9SBaptiste Daroussin 732c99fb5f9SBaptiste Daroussin return true; 733c99fb5f9SBaptiste Daroussin #else 734c99fb5f9SBaptiste Daroussin ucl_create_err (err, "URL support is disabled"); 735c99fb5f9SBaptiste Daroussin return false; 736c99fb5f9SBaptiste Daroussin #endif 737c99fb5f9SBaptiste Daroussin } 738c99fb5f9SBaptiste Daroussin 739c99fb5f9SBaptiste Daroussin /** 740c99fb5f9SBaptiste Daroussin * Fetch a file and save results to the memory buffer 741c99fb5f9SBaptiste Daroussin * @param filename filename to fetch 742c99fb5f9SBaptiste Daroussin * @param len length of filename 743c99fb5f9SBaptiste Daroussin * @param buf target buffer 744c99fb5f9SBaptiste Daroussin * @param buflen target length 745c99fb5f9SBaptiste Daroussin * @return 746c99fb5f9SBaptiste Daroussin */ 747d9f0ce31SBaptiste Daroussin bool 748c99fb5f9SBaptiste Daroussin ucl_fetch_file (const unsigned char *filename, unsigned char **buf, size_t *buflen, 749c99fb5f9SBaptiste Daroussin UT_string **err, bool must_exist) 750c99fb5f9SBaptiste Daroussin { 751c99fb5f9SBaptiste Daroussin int fd; 752c99fb5f9SBaptiste Daroussin struct stat st; 753c99fb5f9SBaptiste Daroussin 754c99fb5f9SBaptiste Daroussin if (stat (filename, &st) == -1 || !S_ISREG (st.st_mode)) { 755c99fb5f9SBaptiste Daroussin if (must_exist) { 756c99fb5f9SBaptiste Daroussin ucl_create_err (err, "cannot stat file %s: %s", 757c99fb5f9SBaptiste Daroussin filename, strerror (errno)); 758c99fb5f9SBaptiste Daroussin } 759c99fb5f9SBaptiste Daroussin return false; 760c99fb5f9SBaptiste Daroussin } 761c99fb5f9SBaptiste Daroussin if (st.st_size == 0) { 762c99fb5f9SBaptiste Daroussin /* Do not map empty files */ 763d9f0ce31SBaptiste Daroussin *buf = NULL; 764c99fb5f9SBaptiste Daroussin *buflen = 0; 765c99fb5f9SBaptiste Daroussin } 766c99fb5f9SBaptiste Daroussin else { 767c99fb5f9SBaptiste Daroussin if ((fd = open (filename, O_RDONLY)) == -1) { 768c99fb5f9SBaptiste Daroussin ucl_create_err (err, "cannot open file %s: %s", 769c99fb5f9SBaptiste Daroussin filename, strerror (errno)); 770c99fb5f9SBaptiste Daroussin return false; 771c99fb5f9SBaptiste Daroussin } 77297bd480fSBaptiste Daroussin if ((*buf = ucl_mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) { 773c99fb5f9SBaptiste Daroussin close (fd); 774c99fb5f9SBaptiste Daroussin ucl_create_err (err, "cannot mmap file %s: %s", 775c99fb5f9SBaptiste Daroussin filename, strerror (errno)); 776d9f0ce31SBaptiste Daroussin *buf = NULL; 777d9f0ce31SBaptiste Daroussin 778c99fb5f9SBaptiste Daroussin return false; 779c99fb5f9SBaptiste Daroussin } 780c99fb5f9SBaptiste Daroussin *buflen = st.st_size; 781c99fb5f9SBaptiste Daroussin close (fd); 782c99fb5f9SBaptiste Daroussin } 783c99fb5f9SBaptiste Daroussin 784c99fb5f9SBaptiste Daroussin return true; 785c99fb5f9SBaptiste Daroussin } 786c99fb5f9SBaptiste Daroussin 787c99fb5f9SBaptiste Daroussin 788c99fb5f9SBaptiste Daroussin #if (defined(HAVE_OPENSSL) && OPENSSL_VERSION_NUMBER >= 0x10000000L) 789c99fb5f9SBaptiste Daroussin static inline bool 790c99fb5f9SBaptiste Daroussin ucl_sig_check (const unsigned char *data, size_t datalen, 791c99fb5f9SBaptiste Daroussin const unsigned char *sig, size_t siglen, struct ucl_parser *parser) 792c99fb5f9SBaptiste Daroussin { 793c99fb5f9SBaptiste Daroussin struct ucl_pubkey *key; 794c99fb5f9SBaptiste Daroussin char dig[EVP_MAX_MD_SIZE]; 795c99fb5f9SBaptiste Daroussin unsigned int diglen; 796c99fb5f9SBaptiste Daroussin EVP_PKEY_CTX *key_ctx; 797c99fb5f9SBaptiste Daroussin EVP_MD_CTX *sign_ctx = NULL; 798c99fb5f9SBaptiste Daroussin 799c99fb5f9SBaptiste Daroussin sign_ctx = EVP_MD_CTX_create (); 800c99fb5f9SBaptiste Daroussin 801c99fb5f9SBaptiste Daroussin LL_FOREACH (parser->keys, key) { 802c99fb5f9SBaptiste Daroussin key_ctx = EVP_PKEY_CTX_new (key->key, NULL); 803c99fb5f9SBaptiste Daroussin if (key_ctx != NULL) { 804c99fb5f9SBaptiste Daroussin if (EVP_PKEY_verify_init (key_ctx) <= 0) { 805c99fb5f9SBaptiste Daroussin EVP_PKEY_CTX_free (key_ctx); 806c99fb5f9SBaptiste Daroussin continue; 807c99fb5f9SBaptiste Daroussin } 808c99fb5f9SBaptiste Daroussin if (EVP_PKEY_CTX_set_rsa_padding (key_ctx, RSA_PKCS1_PADDING) <= 0) { 809c99fb5f9SBaptiste Daroussin EVP_PKEY_CTX_free (key_ctx); 810c99fb5f9SBaptiste Daroussin continue; 811c99fb5f9SBaptiste Daroussin } 812c99fb5f9SBaptiste Daroussin if (EVP_PKEY_CTX_set_signature_md (key_ctx, EVP_sha256 ()) <= 0) { 813c99fb5f9SBaptiste Daroussin EVP_PKEY_CTX_free (key_ctx); 814c99fb5f9SBaptiste Daroussin continue; 815c99fb5f9SBaptiste Daroussin } 816c99fb5f9SBaptiste Daroussin EVP_DigestInit (sign_ctx, EVP_sha256 ()); 817c99fb5f9SBaptiste Daroussin EVP_DigestUpdate (sign_ctx, data, datalen); 818c99fb5f9SBaptiste Daroussin EVP_DigestFinal (sign_ctx, dig, &diglen); 819c99fb5f9SBaptiste Daroussin 820c99fb5f9SBaptiste Daroussin if (EVP_PKEY_verify (key_ctx, sig, siglen, dig, diglen) == 1) { 821c99fb5f9SBaptiste Daroussin EVP_MD_CTX_destroy (sign_ctx); 822c99fb5f9SBaptiste Daroussin EVP_PKEY_CTX_free (key_ctx); 823c99fb5f9SBaptiste Daroussin return true; 824c99fb5f9SBaptiste Daroussin } 825c99fb5f9SBaptiste Daroussin 826c99fb5f9SBaptiste Daroussin EVP_PKEY_CTX_free (key_ctx); 827c99fb5f9SBaptiste Daroussin } 828c99fb5f9SBaptiste Daroussin } 829c99fb5f9SBaptiste Daroussin 830c99fb5f9SBaptiste Daroussin EVP_MD_CTX_destroy (sign_ctx); 831c99fb5f9SBaptiste Daroussin 832c99fb5f9SBaptiste Daroussin return false; 833c99fb5f9SBaptiste Daroussin } 834c99fb5f9SBaptiste Daroussin #endif 835c99fb5f9SBaptiste Daroussin 83639ee7a7aSBaptiste Daroussin struct ucl_include_params { 83739ee7a7aSBaptiste Daroussin bool check_signature; 83839ee7a7aSBaptiste Daroussin bool must_exist; 83939ee7a7aSBaptiste Daroussin bool use_glob; 84039ee7a7aSBaptiste Daroussin bool use_prefix; 84139ee7a7aSBaptiste Daroussin bool soft_fail; 84239ee7a7aSBaptiste Daroussin bool allow_glob; 84339ee7a7aSBaptiste Daroussin unsigned priority; 84439ee7a7aSBaptiste Daroussin enum ucl_duplicate_strategy strat; 84539ee7a7aSBaptiste Daroussin enum ucl_parse_type parse_type; 84639ee7a7aSBaptiste Daroussin const char *prefix; 84739ee7a7aSBaptiste Daroussin const char *target; 84839ee7a7aSBaptiste Daroussin }; 84939ee7a7aSBaptiste Daroussin 850c99fb5f9SBaptiste Daroussin /** 851c99fb5f9SBaptiste Daroussin * Include an url to configuration 852c99fb5f9SBaptiste Daroussin * @param data 853c99fb5f9SBaptiste Daroussin * @param len 854c99fb5f9SBaptiste Daroussin * @param parser 855c99fb5f9SBaptiste Daroussin * @param err 856c99fb5f9SBaptiste Daroussin * @return 857c99fb5f9SBaptiste Daroussin */ 858c99fb5f9SBaptiste Daroussin static bool 859c99fb5f9SBaptiste Daroussin ucl_include_url (const unsigned char *data, size_t len, 86039ee7a7aSBaptiste Daroussin struct ucl_parser *parser, 86139ee7a7aSBaptiste Daroussin struct ucl_include_params *params) 862c99fb5f9SBaptiste Daroussin { 863c99fb5f9SBaptiste Daroussin 864c99fb5f9SBaptiste Daroussin bool res; 865c99fb5f9SBaptiste Daroussin unsigned char *buf = NULL; 866c99fb5f9SBaptiste Daroussin size_t buflen = 0; 867c99fb5f9SBaptiste Daroussin struct ucl_chunk *chunk; 868c99fb5f9SBaptiste Daroussin char urlbuf[PATH_MAX]; 869c99fb5f9SBaptiste Daroussin int prev_state; 870c99fb5f9SBaptiste Daroussin 871c99fb5f9SBaptiste Daroussin snprintf (urlbuf, sizeof (urlbuf), "%.*s", (int)len, data); 872c99fb5f9SBaptiste Daroussin 87339ee7a7aSBaptiste Daroussin if (!ucl_fetch_url (urlbuf, &buf, &buflen, &parser->err, params->must_exist)) { 874d9f0ce31SBaptiste Daroussin return !params->must_exist; 875c99fb5f9SBaptiste Daroussin } 876c99fb5f9SBaptiste Daroussin 87739ee7a7aSBaptiste Daroussin if (params->check_signature) { 878c99fb5f9SBaptiste Daroussin #if (defined(HAVE_OPENSSL) && OPENSSL_VERSION_NUMBER >= 0x10000000L) 879c99fb5f9SBaptiste Daroussin unsigned char *sigbuf = NULL; 880c99fb5f9SBaptiste Daroussin size_t siglen = 0; 881c99fb5f9SBaptiste Daroussin /* We need to check signature first */ 882c99fb5f9SBaptiste Daroussin snprintf (urlbuf, sizeof (urlbuf), "%.*s.sig", (int)len, data); 883c99fb5f9SBaptiste Daroussin if (!ucl_fetch_url (urlbuf, &sigbuf, &siglen, &parser->err, true)) { 884c99fb5f9SBaptiste Daroussin return false; 885c99fb5f9SBaptiste Daroussin } 886c99fb5f9SBaptiste Daroussin if (!ucl_sig_check (buf, buflen, sigbuf, siglen, parser)) { 887c99fb5f9SBaptiste Daroussin ucl_create_err (&parser->err, "cannot verify url %s: %s", 888c99fb5f9SBaptiste Daroussin urlbuf, 889c99fb5f9SBaptiste Daroussin ERR_error_string (ERR_get_error (), NULL)); 890c99fb5f9SBaptiste Daroussin if (siglen > 0) { 89197bd480fSBaptiste Daroussin ucl_munmap (sigbuf, siglen); 892c99fb5f9SBaptiste Daroussin } 893c99fb5f9SBaptiste Daroussin return false; 894c99fb5f9SBaptiste Daroussin } 895c99fb5f9SBaptiste Daroussin if (siglen > 0) { 89697bd480fSBaptiste Daroussin ucl_munmap (sigbuf, siglen); 897c99fb5f9SBaptiste Daroussin } 898c99fb5f9SBaptiste Daroussin #endif 899c99fb5f9SBaptiste Daroussin } 900c99fb5f9SBaptiste Daroussin 901c99fb5f9SBaptiste Daroussin prev_state = parser->state; 902c99fb5f9SBaptiste Daroussin parser->state = UCL_STATE_INIT; 903c99fb5f9SBaptiste Daroussin 90439ee7a7aSBaptiste Daroussin res = ucl_parser_add_chunk_full (parser, buf, buflen, params->priority, 90539ee7a7aSBaptiste Daroussin params->strat, params->parse_type); 906c99fb5f9SBaptiste Daroussin if (res == true) { 907c99fb5f9SBaptiste Daroussin /* Remove chunk from the stack */ 908c99fb5f9SBaptiste Daroussin chunk = parser->chunks; 909c99fb5f9SBaptiste Daroussin if (chunk != NULL) { 910c99fb5f9SBaptiste Daroussin parser->chunks = chunk->next; 911c99fb5f9SBaptiste Daroussin UCL_FREE (sizeof (struct ucl_chunk), chunk); 912c99fb5f9SBaptiste Daroussin } 913c99fb5f9SBaptiste Daroussin } 914c99fb5f9SBaptiste Daroussin 915c99fb5f9SBaptiste Daroussin parser->state = prev_state; 916c99fb5f9SBaptiste Daroussin free (buf); 917c99fb5f9SBaptiste Daroussin 918c99fb5f9SBaptiste Daroussin return res; 919c99fb5f9SBaptiste Daroussin } 920c99fb5f9SBaptiste Daroussin 921c99fb5f9SBaptiste Daroussin /** 9224bf54857SBaptiste Daroussin * Include a single file to the parser 923c99fb5f9SBaptiste Daroussin * @param data 924c99fb5f9SBaptiste Daroussin * @param len 925c99fb5f9SBaptiste Daroussin * @param parser 9264bf54857SBaptiste Daroussin * @param check_signature 9274bf54857SBaptiste Daroussin * @param must_exist 9284bf54857SBaptiste Daroussin * @param allow_glob 9294bf54857SBaptiste Daroussin * @param priority 930c99fb5f9SBaptiste Daroussin * @return 931c99fb5f9SBaptiste Daroussin */ 932c99fb5f9SBaptiste Daroussin static bool 9334bf54857SBaptiste Daroussin ucl_include_file_single (const unsigned char *data, size_t len, 93439ee7a7aSBaptiste Daroussin struct ucl_parser *parser, struct ucl_include_params *params) 935c99fb5f9SBaptiste Daroussin { 936c99fb5f9SBaptiste Daroussin bool res; 937c99fb5f9SBaptiste Daroussin struct ucl_chunk *chunk; 938c99fb5f9SBaptiste Daroussin unsigned char *buf = NULL; 93939ee7a7aSBaptiste Daroussin char *old_curfile, *ext; 94039ee7a7aSBaptiste Daroussin size_t buflen = 0; 941c99fb5f9SBaptiste Daroussin char filebuf[PATH_MAX], realbuf[PATH_MAX]; 942c99fb5f9SBaptiste Daroussin int prev_state; 9434bf54857SBaptiste Daroussin struct ucl_variable *cur_var, *tmp_var, *old_curdir = NULL, 9444bf54857SBaptiste Daroussin *old_filename = NULL; 94539ee7a7aSBaptiste Daroussin ucl_object_t *nest_obj = NULL, *old_obj = NULL, *new_obj = NULL; 94639ee7a7aSBaptiste Daroussin ucl_hash_t *container = NULL; 94739ee7a7aSBaptiste Daroussin struct ucl_stack *st = NULL; 948c99fb5f9SBaptiste Daroussin 949c99fb5f9SBaptiste Daroussin snprintf (filebuf, sizeof (filebuf), "%.*s", (int)len, data); 95097bd480fSBaptiste Daroussin if (ucl_realpath (filebuf, realbuf) == NULL) { 95139ee7a7aSBaptiste Daroussin if (params->soft_fail) { 95239ee7a7aSBaptiste Daroussin return false; 95339ee7a7aSBaptiste Daroussin } 95439ee7a7aSBaptiste Daroussin if (!params->must_exist) { 955c99fb5f9SBaptiste Daroussin return true; 956c99fb5f9SBaptiste Daroussin } 957c99fb5f9SBaptiste Daroussin ucl_create_err (&parser->err, "cannot open file %s: %s", 958c99fb5f9SBaptiste Daroussin filebuf, 959c99fb5f9SBaptiste Daroussin strerror (errno)); 960c99fb5f9SBaptiste Daroussin return false; 961c99fb5f9SBaptiste Daroussin } 962c99fb5f9SBaptiste Daroussin 9634bf54857SBaptiste Daroussin if (parser->cur_file && strcmp (realbuf, parser->cur_file) == 0) { 9644bf54857SBaptiste Daroussin /* We are likely including the file itself */ 96539ee7a7aSBaptiste Daroussin if (params->soft_fail) { 96639ee7a7aSBaptiste Daroussin return false; 96739ee7a7aSBaptiste Daroussin } 96839ee7a7aSBaptiste Daroussin 9694bf54857SBaptiste Daroussin ucl_create_err (&parser->err, "trying to include the file %s from itself", 9704bf54857SBaptiste Daroussin realbuf); 9714bf54857SBaptiste Daroussin return false; 9724bf54857SBaptiste Daroussin } 9734bf54857SBaptiste Daroussin 97439ee7a7aSBaptiste Daroussin if (!ucl_fetch_file (realbuf, &buf, &buflen, &parser->err, params->must_exist)) { 97539ee7a7aSBaptiste Daroussin if (params->soft_fail) { 97639ee7a7aSBaptiste Daroussin return false; 97739ee7a7aSBaptiste Daroussin } 9786525738fSBaptiste Daroussin 97939ee7a7aSBaptiste Daroussin return (!params->must_exist || false); 980c99fb5f9SBaptiste Daroussin } 981c99fb5f9SBaptiste Daroussin 98239ee7a7aSBaptiste Daroussin if (params->check_signature) { 983c99fb5f9SBaptiste Daroussin #if (defined(HAVE_OPENSSL) && OPENSSL_VERSION_NUMBER >= 0x10000000L) 984c99fb5f9SBaptiste Daroussin unsigned char *sigbuf = NULL; 985c99fb5f9SBaptiste Daroussin size_t siglen = 0; 986c99fb5f9SBaptiste Daroussin /* We need to check signature first */ 987c99fb5f9SBaptiste Daroussin snprintf (filebuf, sizeof (filebuf), "%s.sig", realbuf); 988c99fb5f9SBaptiste Daroussin if (!ucl_fetch_file (filebuf, &sigbuf, &siglen, &parser->err, true)) { 989c99fb5f9SBaptiste Daroussin return false; 990c99fb5f9SBaptiste Daroussin } 991c99fb5f9SBaptiste Daroussin if (!ucl_sig_check (buf, buflen, sigbuf, siglen, parser)) { 992c99fb5f9SBaptiste Daroussin ucl_create_err (&parser->err, "cannot verify file %s: %s", 993c99fb5f9SBaptiste Daroussin filebuf, 994c99fb5f9SBaptiste Daroussin ERR_error_string (ERR_get_error (), NULL)); 995d9f0ce31SBaptiste Daroussin if (sigbuf) { 99697bd480fSBaptiste Daroussin ucl_munmap (sigbuf, siglen); 997c99fb5f9SBaptiste Daroussin } 998c99fb5f9SBaptiste Daroussin return false; 999c99fb5f9SBaptiste Daroussin } 1000d9f0ce31SBaptiste Daroussin if (sigbuf) { 100197bd480fSBaptiste Daroussin ucl_munmap (sigbuf, siglen); 1002c99fb5f9SBaptiste Daroussin } 1003c99fb5f9SBaptiste Daroussin #endif 1004c99fb5f9SBaptiste Daroussin } 1005c99fb5f9SBaptiste Daroussin 10064bf54857SBaptiste Daroussin old_curfile = parser->cur_file; 10074bf54857SBaptiste Daroussin parser->cur_file = strdup (realbuf); 10084bf54857SBaptiste Daroussin 10094bf54857SBaptiste Daroussin /* Store old file vars */ 10104bf54857SBaptiste Daroussin DL_FOREACH_SAFE (parser->variables, cur_var, tmp_var) { 10114bf54857SBaptiste Daroussin if (strcmp (cur_var->var, "CURDIR") == 0) { 10124bf54857SBaptiste Daroussin old_curdir = cur_var; 10134bf54857SBaptiste Daroussin DL_DELETE (parser->variables, cur_var); 10144bf54857SBaptiste Daroussin } 10154bf54857SBaptiste Daroussin else if (strcmp (cur_var->var, "FILENAME") == 0) { 10164bf54857SBaptiste Daroussin old_filename = cur_var; 10174bf54857SBaptiste Daroussin DL_DELETE (parser->variables, cur_var); 10184bf54857SBaptiste Daroussin } 10194bf54857SBaptiste Daroussin } 10204bf54857SBaptiste Daroussin 1021c99fb5f9SBaptiste Daroussin ucl_parser_set_filevars (parser, realbuf, false); 1022c99fb5f9SBaptiste Daroussin 1023c99fb5f9SBaptiste Daroussin prev_state = parser->state; 1024c99fb5f9SBaptiste Daroussin parser->state = UCL_STATE_INIT; 1025c99fb5f9SBaptiste Daroussin 102639ee7a7aSBaptiste Daroussin if (params->use_prefix && params->prefix == NULL) { 102739ee7a7aSBaptiste Daroussin /* Auto generate a key name based on the included filename */ 102839ee7a7aSBaptiste Daroussin params->prefix = basename (realbuf); 102939ee7a7aSBaptiste Daroussin ext = strrchr (params->prefix, '.'); 103039ee7a7aSBaptiste Daroussin if (ext != NULL && (strcmp (ext, ".conf") == 0 || strcmp (ext, ".ucl") == 0)) { 103139ee7a7aSBaptiste Daroussin /* Strip off .conf or .ucl */ 103239ee7a7aSBaptiste Daroussin *ext = '\0'; 103339ee7a7aSBaptiste Daroussin } 103439ee7a7aSBaptiste Daroussin } 103539ee7a7aSBaptiste Daroussin if (params->prefix != NULL) { 103639ee7a7aSBaptiste Daroussin /* This is a prefixed include */ 103739ee7a7aSBaptiste Daroussin container = parser->stack->obj->value.ov; 103839ee7a7aSBaptiste Daroussin 103939ee7a7aSBaptiste Daroussin old_obj = __DECONST (ucl_object_t *, ucl_hash_search (container, 104039ee7a7aSBaptiste Daroussin params->prefix, strlen (params->prefix))); 104139ee7a7aSBaptiste Daroussin 104239ee7a7aSBaptiste Daroussin if (strcasecmp (params->target, "array") == 0 && old_obj == NULL) { 104339ee7a7aSBaptiste Daroussin /* Create an array with key: prefix */ 104439ee7a7aSBaptiste Daroussin old_obj = ucl_object_new_full (UCL_ARRAY, params->priority); 104539ee7a7aSBaptiste Daroussin old_obj->key = params->prefix; 104639ee7a7aSBaptiste Daroussin old_obj->keylen = strlen (params->prefix); 104739ee7a7aSBaptiste Daroussin ucl_copy_key_trash(old_obj); 104839ee7a7aSBaptiste Daroussin old_obj->prev = old_obj; 104939ee7a7aSBaptiste Daroussin old_obj->next = NULL; 105039ee7a7aSBaptiste Daroussin 105139ee7a7aSBaptiste Daroussin container = ucl_hash_insert_object (container, old_obj, 105239ee7a7aSBaptiste Daroussin parser->flags & UCL_PARSER_KEY_LOWERCASE); 105339ee7a7aSBaptiste Daroussin parser->stack->obj->len ++; 105439ee7a7aSBaptiste Daroussin 105539ee7a7aSBaptiste Daroussin nest_obj = ucl_object_new_full (UCL_OBJECT, params->priority); 105639ee7a7aSBaptiste Daroussin nest_obj->prev = nest_obj; 105739ee7a7aSBaptiste Daroussin nest_obj->next = NULL; 105839ee7a7aSBaptiste Daroussin 105939ee7a7aSBaptiste Daroussin ucl_array_append (old_obj, nest_obj); 106039ee7a7aSBaptiste Daroussin } 106139ee7a7aSBaptiste Daroussin else if (old_obj == NULL) { 106239ee7a7aSBaptiste Daroussin /* Create an object with key: prefix */ 106339ee7a7aSBaptiste Daroussin nest_obj = ucl_object_new_full (UCL_OBJECT, params->priority); 1064d9f0ce31SBaptiste Daroussin 1065d9f0ce31SBaptiste Daroussin if (nest_obj == NULL) { 1066d9f0ce31SBaptiste Daroussin ucl_create_err (&parser->err, "cannot allocate memory for an object"); 1067d9f0ce31SBaptiste Daroussin if (buf) { 1068d9f0ce31SBaptiste Daroussin ucl_munmap (buf, buflen); 1069d9f0ce31SBaptiste Daroussin } 1070d9f0ce31SBaptiste Daroussin 1071d9f0ce31SBaptiste Daroussin return false; 1072d9f0ce31SBaptiste Daroussin } 1073d9f0ce31SBaptiste Daroussin 107439ee7a7aSBaptiste Daroussin nest_obj->key = params->prefix; 107539ee7a7aSBaptiste Daroussin nest_obj->keylen = strlen (params->prefix); 107639ee7a7aSBaptiste Daroussin ucl_copy_key_trash(nest_obj); 107739ee7a7aSBaptiste Daroussin nest_obj->prev = nest_obj; 107839ee7a7aSBaptiste Daroussin nest_obj->next = NULL; 107939ee7a7aSBaptiste Daroussin 108039ee7a7aSBaptiste Daroussin container = ucl_hash_insert_object (container, nest_obj, 108139ee7a7aSBaptiste Daroussin parser->flags & UCL_PARSER_KEY_LOWERCASE); 108239ee7a7aSBaptiste Daroussin parser->stack->obj->len ++; 108339ee7a7aSBaptiste Daroussin } 108439ee7a7aSBaptiste Daroussin else if (strcasecmp (params->target, "array") == 0 || 108539ee7a7aSBaptiste Daroussin ucl_object_type(old_obj) == UCL_ARRAY) { 108639ee7a7aSBaptiste Daroussin if (ucl_object_type(old_obj) == UCL_ARRAY) { 108739ee7a7aSBaptiste Daroussin /* Append to the existing array */ 108839ee7a7aSBaptiste Daroussin nest_obj = ucl_object_new_full (UCL_OBJECT, params->priority); 1089d9f0ce31SBaptiste Daroussin if (nest_obj == NULL) { 1090d9f0ce31SBaptiste Daroussin ucl_create_err (&parser->err, "cannot allocate memory for an object"); 1091d9f0ce31SBaptiste Daroussin if (buf) { 1092d9f0ce31SBaptiste Daroussin ucl_munmap (buf, buflen); 1093d9f0ce31SBaptiste Daroussin } 1094d9f0ce31SBaptiste Daroussin 1095d9f0ce31SBaptiste Daroussin return false; 1096d9f0ce31SBaptiste Daroussin } 109739ee7a7aSBaptiste Daroussin nest_obj->prev = nest_obj; 109839ee7a7aSBaptiste Daroussin nest_obj->next = NULL; 109939ee7a7aSBaptiste Daroussin 110039ee7a7aSBaptiste Daroussin ucl_array_append (old_obj, nest_obj); 110139ee7a7aSBaptiste Daroussin } 110239ee7a7aSBaptiste Daroussin else { 110339ee7a7aSBaptiste Daroussin /* Convert the object to an array */ 110439ee7a7aSBaptiste Daroussin new_obj = ucl_object_typed_new (UCL_ARRAY); 1105d9f0ce31SBaptiste Daroussin if (new_obj == NULL) { 1106d9f0ce31SBaptiste Daroussin ucl_create_err (&parser->err, "cannot allocate memory for an object"); 1107d9f0ce31SBaptiste Daroussin if (buf) { 1108d9f0ce31SBaptiste Daroussin ucl_munmap (buf, buflen); 1109d9f0ce31SBaptiste Daroussin } 1110d9f0ce31SBaptiste Daroussin 1111d9f0ce31SBaptiste Daroussin return false; 1112d9f0ce31SBaptiste Daroussin } 111339ee7a7aSBaptiste Daroussin new_obj->key = old_obj->key; 111439ee7a7aSBaptiste Daroussin new_obj->keylen = old_obj->keylen; 111539ee7a7aSBaptiste Daroussin new_obj->flags |= UCL_OBJECT_MULTIVALUE; 111639ee7a7aSBaptiste Daroussin new_obj->prev = new_obj; 111739ee7a7aSBaptiste Daroussin new_obj->next = NULL; 111839ee7a7aSBaptiste Daroussin 111939ee7a7aSBaptiste Daroussin nest_obj = ucl_object_new_full (UCL_OBJECT, params->priority); 1120d9f0ce31SBaptiste Daroussin if (nest_obj == NULL) { 1121d9f0ce31SBaptiste Daroussin ucl_create_err (&parser->err, "cannot allocate memory for an object"); 1122d9f0ce31SBaptiste Daroussin if (buf) { 1123d9f0ce31SBaptiste Daroussin ucl_munmap (buf, buflen); 1124d9f0ce31SBaptiste Daroussin } 1125d9f0ce31SBaptiste Daroussin 1126d9f0ce31SBaptiste Daroussin return false; 1127d9f0ce31SBaptiste Daroussin } 112839ee7a7aSBaptiste Daroussin nest_obj->prev = nest_obj; 112939ee7a7aSBaptiste Daroussin nest_obj->next = NULL; 113039ee7a7aSBaptiste Daroussin 113139ee7a7aSBaptiste Daroussin ucl_array_append (new_obj, old_obj); 113239ee7a7aSBaptiste Daroussin ucl_array_append (new_obj, nest_obj); 113339ee7a7aSBaptiste Daroussin ucl_hash_replace (container, old_obj, new_obj); 113439ee7a7aSBaptiste Daroussin } 113539ee7a7aSBaptiste Daroussin } 113639ee7a7aSBaptiste Daroussin else { 113739ee7a7aSBaptiste Daroussin if (ucl_object_type (old_obj) == UCL_OBJECT) { 113839ee7a7aSBaptiste Daroussin /* Append to existing Object*/ 113939ee7a7aSBaptiste Daroussin nest_obj = old_obj; 114039ee7a7aSBaptiste Daroussin } 114139ee7a7aSBaptiste Daroussin else { 114239ee7a7aSBaptiste Daroussin /* The key is not an object */ 114339ee7a7aSBaptiste Daroussin ucl_create_err (&parser->err, 114439ee7a7aSBaptiste Daroussin "Conflicting type for key: %s", 114539ee7a7aSBaptiste Daroussin params->prefix); 1146d9f0ce31SBaptiste Daroussin if (buf) { 1147d9f0ce31SBaptiste Daroussin ucl_munmap (buf, buflen); 1148d9f0ce31SBaptiste Daroussin } 1149d9f0ce31SBaptiste Daroussin 115039ee7a7aSBaptiste Daroussin return false; 115139ee7a7aSBaptiste Daroussin } 115239ee7a7aSBaptiste Daroussin } 115339ee7a7aSBaptiste Daroussin 115439ee7a7aSBaptiste Daroussin /* Put all of the content of the include inside that object */ 115539ee7a7aSBaptiste Daroussin parser->stack->obj->value.ov = container; 115639ee7a7aSBaptiste Daroussin 115739ee7a7aSBaptiste Daroussin st = UCL_ALLOC (sizeof (struct ucl_stack)); 115839ee7a7aSBaptiste Daroussin if (st == NULL) { 115939ee7a7aSBaptiste Daroussin ucl_create_err (&parser->err, "cannot allocate memory for an object"); 116039ee7a7aSBaptiste Daroussin ucl_object_unref (nest_obj); 1161d9f0ce31SBaptiste Daroussin 1162d9f0ce31SBaptiste Daroussin if (buf) { 1163d9f0ce31SBaptiste Daroussin ucl_munmap (buf, buflen); 1164d9f0ce31SBaptiste Daroussin } 1165d9f0ce31SBaptiste Daroussin 1166d9f0ce31SBaptiste Daroussin return false; 116739ee7a7aSBaptiste Daroussin } 116839ee7a7aSBaptiste Daroussin st->obj = nest_obj; 116939ee7a7aSBaptiste Daroussin st->level = parser->stack->level; 117039ee7a7aSBaptiste Daroussin LL_PREPEND (parser->stack, st); 117139ee7a7aSBaptiste Daroussin parser->cur_obj = nest_obj; 117239ee7a7aSBaptiste Daroussin } 117339ee7a7aSBaptiste Daroussin 117439ee7a7aSBaptiste Daroussin res = ucl_parser_add_chunk_full (parser, buf, buflen, params->priority, 117539ee7a7aSBaptiste Daroussin params->strat, params->parse_type); 11766525738fSBaptiste Daroussin 11776525738fSBaptiste Daroussin if (!res) { 11786525738fSBaptiste Daroussin if (!params->must_exist) { 11794bf54857SBaptiste Daroussin /* Free error */ 11804bf54857SBaptiste Daroussin utstring_free (parser->err); 11814bf54857SBaptiste Daroussin parser->err = NULL; 11826525738fSBaptiste Daroussin res = true; 11836525738fSBaptiste Daroussin } 11844bf54857SBaptiste Daroussin } 11854bf54857SBaptiste Daroussin 118639ee7a7aSBaptiste Daroussin /* Stop nesting the include, take 1 level off the stack */ 118739ee7a7aSBaptiste Daroussin if (params->prefix != NULL && nest_obj != NULL) { 118839ee7a7aSBaptiste Daroussin parser->stack = st->next; 118939ee7a7aSBaptiste Daroussin UCL_FREE (sizeof (struct ucl_stack), st); 119039ee7a7aSBaptiste Daroussin } 119139ee7a7aSBaptiste Daroussin 1192c99fb5f9SBaptiste Daroussin /* Remove chunk from the stack */ 1193c99fb5f9SBaptiste Daroussin chunk = parser->chunks; 1194c99fb5f9SBaptiste Daroussin if (chunk != NULL) { 1195c99fb5f9SBaptiste Daroussin parser->chunks = chunk->next; 1196c99fb5f9SBaptiste Daroussin UCL_FREE (sizeof (struct ucl_chunk), chunk); 11974bf54857SBaptiste Daroussin parser->recursion --; 1198c99fb5f9SBaptiste Daroussin } 11994bf54857SBaptiste Daroussin 12004bf54857SBaptiste Daroussin /* Restore old file vars */ 120139ee7a7aSBaptiste Daroussin if (parser->cur_file) { 120239ee7a7aSBaptiste Daroussin free (parser->cur_file); 120339ee7a7aSBaptiste Daroussin } 120439ee7a7aSBaptiste Daroussin 12054bf54857SBaptiste Daroussin parser->cur_file = old_curfile; 12064bf54857SBaptiste Daroussin DL_FOREACH_SAFE (parser->variables, cur_var, tmp_var) { 12074bf54857SBaptiste Daroussin if (strcmp (cur_var->var, "CURDIR") == 0 && old_curdir) { 12084bf54857SBaptiste Daroussin DL_DELETE (parser->variables, cur_var); 12094bf54857SBaptiste Daroussin free (cur_var->var); 12104bf54857SBaptiste Daroussin free (cur_var->value); 12114bf54857SBaptiste Daroussin UCL_FREE (sizeof (struct ucl_variable), cur_var); 12124bf54857SBaptiste Daroussin } 12134bf54857SBaptiste Daroussin else if (strcmp (cur_var->var, "FILENAME") == 0 && old_filename) { 12144bf54857SBaptiste Daroussin DL_DELETE (parser->variables, cur_var); 12154bf54857SBaptiste Daroussin free (cur_var->var); 12164bf54857SBaptiste Daroussin free (cur_var->value); 12174bf54857SBaptiste Daroussin UCL_FREE (sizeof (struct ucl_variable), cur_var); 12184bf54857SBaptiste Daroussin } 12194bf54857SBaptiste Daroussin } 12204bf54857SBaptiste Daroussin if (old_filename) { 12214bf54857SBaptiste Daroussin DL_APPEND (parser->variables, old_filename); 12224bf54857SBaptiste Daroussin } 12234bf54857SBaptiste Daroussin if (old_curdir) { 12244bf54857SBaptiste Daroussin DL_APPEND (parser->variables, old_curdir); 12254bf54857SBaptiste Daroussin } 1226c99fb5f9SBaptiste Daroussin 1227c99fb5f9SBaptiste Daroussin parser->state = prev_state; 1228c99fb5f9SBaptiste Daroussin 1229c99fb5f9SBaptiste Daroussin if (buflen > 0) { 123097bd480fSBaptiste Daroussin ucl_munmap (buf, buflen); 1231c99fb5f9SBaptiste Daroussin } 1232c99fb5f9SBaptiste Daroussin 1233c99fb5f9SBaptiste Daroussin return res; 1234c99fb5f9SBaptiste Daroussin } 1235c99fb5f9SBaptiste Daroussin 1236c99fb5f9SBaptiste Daroussin /** 12374bf54857SBaptiste Daroussin * Include a file to configuration 12384bf54857SBaptiste Daroussin * @param data 12394bf54857SBaptiste Daroussin * @param len 12404bf54857SBaptiste Daroussin * @param parser 12414bf54857SBaptiste Daroussin * @param err 12424bf54857SBaptiste Daroussin * @return 12434bf54857SBaptiste Daroussin */ 12444bf54857SBaptiste Daroussin static bool 12454bf54857SBaptiste Daroussin ucl_include_file (const unsigned char *data, size_t len, 124639ee7a7aSBaptiste Daroussin struct ucl_parser *parser, struct ucl_include_params *params) 12474bf54857SBaptiste Daroussin { 12484bf54857SBaptiste Daroussin const unsigned char *p = data, *end = data + len; 12494bf54857SBaptiste Daroussin bool need_glob = false; 12504bf54857SBaptiste Daroussin int cnt = 0; 12514bf54857SBaptiste Daroussin char glob_pattern[PATH_MAX]; 12524bf54857SBaptiste Daroussin size_t i; 12534bf54857SBaptiste Daroussin 12548e3b1ab2SBaptiste Daroussin #ifndef _WIN32 125539ee7a7aSBaptiste Daroussin if (!params->allow_glob) { 125639ee7a7aSBaptiste Daroussin return ucl_include_file_single (data, len, parser, params); 12574bf54857SBaptiste Daroussin } 12584bf54857SBaptiste Daroussin else { 12594bf54857SBaptiste Daroussin /* Check for special symbols in a filename */ 12604bf54857SBaptiste Daroussin while (p != end) { 12614bf54857SBaptiste Daroussin if (*p == '*' || *p == '?') { 12624bf54857SBaptiste Daroussin need_glob = true; 12634bf54857SBaptiste Daroussin break; 12644bf54857SBaptiste Daroussin } 12654bf54857SBaptiste Daroussin p ++; 12664bf54857SBaptiste Daroussin } 12674bf54857SBaptiste Daroussin if (need_glob) { 12688e3b1ab2SBaptiste Daroussin glob_t globbuf; 12694bf54857SBaptiste Daroussin memset (&globbuf, 0, sizeof (globbuf)); 127039ee7a7aSBaptiste Daroussin ucl_strlcpy (glob_pattern, (const char *)data, 127139ee7a7aSBaptiste Daroussin (len + 1 < sizeof (glob_pattern) ? len + 1 : sizeof (glob_pattern))); 12724bf54857SBaptiste Daroussin if (glob (glob_pattern, 0, NULL, &globbuf) != 0) { 127339ee7a7aSBaptiste Daroussin return (!params->must_exist || false); 12744bf54857SBaptiste Daroussin } 12754bf54857SBaptiste Daroussin for (i = 0; i < globbuf.gl_pathc; i ++) { 12764bf54857SBaptiste Daroussin if (!ucl_include_file_single ((unsigned char *)globbuf.gl_pathv[i], 127739ee7a7aSBaptiste Daroussin strlen (globbuf.gl_pathv[i]), parser, params)) { 127839ee7a7aSBaptiste Daroussin if (params->soft_fail) { 127939ee7a7aSBaptiste Daroussin continue; 128039ee7a7aSBaptiste Daroussin } 12814bf54857SBaptiste Daroussin globfree (&globbuf); 12824bf54857SBaptiste Daroussin return false; 12834bf54857SBaptiste Daroussin } 12844bf54857SBaptiste Daroussin cnt ++; 12854bf54857SBaptiste Daroussin } 12864bf54857SBaptiste Daroussin globfree (&globbuf); 12874bf54857SBaptiste Daroussin 128839ee7a7aSBaptiste Daroussin if (cnt == 0 && params->must_exist) { 12894bf54857SBaptiste Daroussin ucl_create_err (&parser->err, "cannot match any files for pattern %s", 12904bf54857SBaptiste Daroussin glob_pattern); 12914bf54857SBaptiste Daroussin return false; 12924bf54857SBaptiste Daroussin } 12934bf54857SBaptiste Daroussin } 12944bf54857SBaptiste Daroussin else { 129539ee7a7aSBaptiste Daroussin return ucl_include_file_single (data, len, parser, params); 12964bf54857SBaptiste Daroussin } 12974bf54857SBaptiste Daroussin } 12988e3b1ab2SBaptiste Daroussin #else 12998e3b1ab2SBaptiste Daroussin /* Win32 compilers do not support globbing. Therefore, for Win32, 13008e3b1ab2SBaptiste Daroussin treat allow_glob/need_glob as a NOOP and just return */ 130139ee7a7aSBaptiste Daroussin return ucl_include_file_single (data, len, parser, params); 13028e3b1ab2SBaptiste Daroussin #endif 13034bf54857SBaptiste Daroussin 13044bf54857SBaptiste Daroussin return true; 13054bf54857SBaptiste Daroussin } 13064bf54857SBaptiste Daroussin 13074bf54857SBaptiste Daroussin /** 13084bf54857SBaptiste Daroussin * Common function to handle .*include* macros 13094bf54857SBaptiste Daroussin * @param data 13104bf54857SBaptiste Daroussin * @param len 13114bf54857SBaptiste Daroussin * @param args 13124bf54857SBaptiste Daroussin * @param parser 13134bf54857SBaptiste Daroussin * @param default_try 13144bf54857SBaptiste Daroussin * @param default_sign 13154bf54857SBaptiste Daroussin * @return 13164bf54857SBaptiste Daroussin */ 13174bf54857SBaptiste Daroussin static bool 13184bf54857SBaptiste Daroussin ucl_include_common (const unsigned char *data, size_t len, 13194bf54857SBaptiste Daroussin const ucl_object_t *args, struct ucl_parser *parser, 13204bf54857SBaptiste Daroussin bool default_try, 13214bf54857SBaptiste Daroussin bool default_sign) 13224bf54857SBaptiste Daroussin { 1323d9f0ce31SBaptiste Daroussin bool allow_url = false, search = false; 132439ee7a7aSBaptiste Daroussin const char *duplicate; 13254bf54857SBaptiste Daroussin const ucl_object_t *param; 132639ee7a7aSBaptiste Daroussin ucl_object_iter_t it = NULL, ip = NULL; 132739ee7a7aSBaptiste Daroussin char ipath[PATH_MAX]; 132839ee7a7aSBaptiste Daroussin struct ucl_include_params params; 13294bf54857SBaptiste Daroussin 13304bf54857SBaptiste Daroussin /* Default values */ 133139ee7a7aSBaptiste Daroussin params.soft_fail = default_try; 133239ee7a7aSBaptiste Daroussin params.allow_glob = false; 133339ee7a7aSBaptiste Daroussin params.check_signature = default_sign; 133439ee7a7aSBaptiste Daroussin params.use_prefix = false; 133539ee7a7aSBaptiste Daroussin params.target = "object"; 133639ee7a7aSBaptiste Daroussin params.prefix = NULL; 133739ee7a7aSBaptiste Daroussin params.priority = 0; 133839ee7a7aSBaptiste Daroussin params.parse_type = UCL_PARSE_UCL; 133939ee7a7aSBaptiste Daroussin params.strat = UCL_DUPLICATE_APPEND; 134039ee7a7aSBaptiste Daroussin params.must_exist = !default_try; 134139ee7a7aSBaptiste Daroussin 13424bf54857SBaptiste Daroussin /* Process arguments */ 13434bf54857SBaptiste Daroussin if (args != NULL && args->type == UCL_OBJECT) { 1344d9f0ce31SBaptiste Daroussin while ((param = ucl_object_iterate (args, &it, true)) != NULL) { 13454bf54857SBaptiste Daroussin if (param->type == UCL_BOOLEAN) { 134639ee7a7aSBaptiste Daroussin if (strncmp (param->key, "try", param->keylen) == 0) { 134739ee7a7aSBaptiste Daroussin params.must_exist = !ucl_object_toboolean (param); 13484bf54857SBaptiste Daroussin } 134939ee7a7aSBaptiste Daroussin else if (strncmp (param->key, "sign", param->keylen) == 0) { 135039ee7a7aSBaptiste Daroussin params.check_signature = ucl_object_toboolean (param); 13514bf54857SBaptiste Daroussin } 135239ee7a7aSBaptiste Daroussin else if (strncmp (param->key, "glob", param->keylen) == 0) { 135339ee7a7aSBaptiste Daroussin params.allow_glob = ucl_object_toboolean (param); 13544bf54857SBaptiste Daroussin } 135539ee7a7aSBaptiste Daroussin else if (strncmp (param->key, "url", param->keylen) == 0) { 13564bf54857SBaptiste Daroussin allow_url = ucl_object_toboolean (param); 13574bf54857SBaptiste Daroussin } 135839ee7a7aSBaptiste Daroussin else if (strncmp (param->key, "prefix", param->keylen) == 0) { 135939ee7a7aSBaptiste Daroussin params.use_prefix = ucl_object_toboolean (param); 136039ee7a7aSBaptiste Daroussin } 136139ee7a7aSBaptiste Daroussin } 136239ee7a7aSBaptiste Daroussin else if (param->type == UCL_STRING) { 136339ee7a7aSBaptiste Daroussin if (strncmp (param->key, "key", param->keylen) == 0) { 136439ee7a7aSBaptiste Daroussin params.prefix = ucl_object_tostring (param); 136539ee7a7aSBaptiste Daroussin } 136639ee7a7aSBaptiste Daroussin else if (strncmp (param->key, "target", param->keylen) == 0) { 136739ee7a7aSBaptiste Daroussin params.target = ucl_object_tostring (param); 136839ee7a7aSBaptiste Daroussin } 136939ee7a7aSBaptiste Daroussin else if (strncmp (param->key, "duplicate", param->keylen) == 0) { 137039ee7a7aSBaptiste Daroussin duplicate = ucl_object_tostring (param); 137139ee7a7aSBaptiste Daroussin 137239ee7a7aSBaptiste Daroussin if (strcmp (duplicate, "append") == 0) { 137339ee7a7aSBaptiste Daroussin params.strat = UCL_DUPLICATE_APPEND; 137439ee7a7aSBaptiste Daroussin } 137539ee7a7aSBaptiste Daroussin else if (strcmp (duplicate, "merge") == 0) { 137639ee7a7aSBaptiste Daroussin params.strat = UCL_DUPLICATE_MERGE; 137739ee7a7aSBaptiste Daroussin } 137839ee7a7aSBaptiste Daroussin else if (strcmp (duplicate, "rewrite") == 0) { 137939ee7a7aSBaptiste Daroussin params.strat = UCL_DUPLICATE_REWRITE; 138039ee7a7aSBaptiste Daroussin } 138139ee7a7aSBaptiste Daroussin else if (strcmp (duplicate, "error") == 0) { 138239ee7a7aSBaptiste Daroussin params.strat = UCL_DUPLICATE_ERROR; 138339ee7a7aSBaptiste Daroussin } 138439ee7a7aSBaptiste Daroussin } 138539ee7a7aSBaptiste Daroussin } 138639ee7a7aSBaptiste Daroussin else if (param->type == UCL_ARRAY) { 138739ee7a7aSBaptiste Daroussin if (strncmp (param->key, "path", param->keylen) == 0) { 138839ee7a7aSBaptiste Daroussin ucl_set_include_path (parser, __DECONST(ucl_object_t *, param)); 138939ee7a7aSBaptiste Daroussin } 13904bf54857SBaptiste Daroussin } 13914bf54857SBaptiste Daroussin else if (param->type == UCL_INT) { 139239ee7a7aSBaptiste Daroussin if (strncmp (param->key, "priority", param->keylen) == 0) { 139339ee7a7aSBaptiste Daroussin params.priority = ucl_object_toint (param); 13944bf54857SBaptiste Daroussin } 13954bf54857SBaptiste Daroussin } 13964bf54857SBaptiste Daroussin } 13974bf54857SBaptiste Daroussin } 13984bf54857SBaptiste Daroussin 139939ee7a7aSBaptiste Daroussin if (parser->includepaths == NULL) { 140039ee7a7aSBaptiste Daroussin if (allow_url && ucl_strnstr (data, "://", len) != NULL) { 14014bf54857SBaptiste Daroussin /* Globbing is not used for URL's */ 140239ee7a7aSBaptiste Daroussin return ucl_include_url (data, len, parser, ¶ms); 140339ee7a7aSBaptiste Daroussin } 140439ee7a7aSBaptiste Daroussin else if (data != NULL) { 140539ee7a7aSBaptiste Daroussin /* Try to load a file */ 140639ee7a7aSBaptiste Daroussin return ucl_include_file (data, len, parser, ¶ms); 140739ee7a7aSBaptiste Daroussin } 140839ee7a7aSBaptiste Daroussin } 140939ee7a7aSBaptiste Daroussin else { 141039ee7a7aSBaptiste Daroussin if (allow_url && ucl_strnstr (data, "://", len) != NULL) { 141139ee7a7aSBaptiste Daroussin /* Globbing is not used for URL's */ 141239ee7a7aSBaptiste Daroussin return ucl_include_url (data, len, parser, ¶ms); 141339ee7a7aSBaptiste Daroussin } 141439ee7a7aSBaptiste Daroussin 141539ee7a7aSBaptiste Daroussin ip = ucl_object_iterate_new (parser->includepaths); 141639ee7a7aSBaptiste Daroussin while ((param = ucl_object_iterate_safe (ip, true)) != NULL) { 141739ee7a7aSBaptiste Daroussin if (ucl_object_type(param) == UCL_STRING) { 141839ee7a7aSBaptiste Daroussin snprintf (ipath, sizeof (ipath), "%s/%.*s", ucl_object_tostring(param), 141939ee7a7aSBaptiste Daroussin (int)len, data); 142039ee7a7aSBaptiste Daroussin if ((search = ucl_include_file (ipath, strlen (ipath), 142139ee7a7aSBaptiste Daroussin parser, ¶ms))) { 142239ee7a7aSBaptiste Daroussin if (!params.allow_glob) { 142339ee7a7aSBaptiste Daroussin break; 142439ee7a7aSBaptiste Daroussin } 142539ee7a7aSBaptiste Daroussin } 142639ee7a7aSBaptiste Daroussin } 142739ee7a7aSBaptiste Daroussin } 142839ee7a7aSBaptiste Daroussin ucl_object_iterate_free (ip); 142939ee7a7aSBaptiste Daroussin if (search == true) { 143039ee7a7aSBaptiste Daroussin return true; 143139ee7a7aSBaptiste Daroussin } 143239ee7a7aSBaptiste Daroussin else { 143339ee7a7aSBaptiste Daroussin ucl_create_err (&parser->err, 143439ee7a7aSBaptiste Daroussin "cannot find file: %.*s in search path", 143539ee7a7aSBaptiste Daroussin (int)len, data); 143639ee7a7aSBaptiste Daroussin return false; 143739ee7a7aSBaptiste Daroussin } 14384bf54857SBaptiste Daroussin } 14394bf54857SBaptiste Daroussin 14404bf54857SBaptiste Daroussin return false; 14414bf54857SBaptiste Daroussin } 14424bf54857SBaptiste Daroussin 14434bf54857SBaptiste Daroussin /** 1444c99fb5f9SBaptiste Daroussin * Handle include macro 1445c99fb5f9SBaptiste Daroussin * @param data include data 1446c99fb5f9SBaptiste Daroussin * @param len length of data 144739ee7a7aSBaptiste Daroussin * @param args UCL object representing arguments to the macro 1448c99fb5f9SBaptiste Daroussin * @param ud user data 1449c99fb5f9SBaptiste Daroussin * @return 1450c99fb5f9SBaptiste Daroussin */ 145139ee7a7aSBaptiste Daroussin bool 14524bf54857SBaptiste Daroussin ucl_include_handler (const unsigned char *data, size_t len, 14534bf54857SBaptiste Daroussin const ucl_object_t *args, void* ud) 1454c99fb5f9SBaptiste Daroussin { 1455c99fb5f9SBaptiste Daroussin struct ucl_parser *parser = ud; 1456c99fb5f9SBaptiste Daroussin 14574bf54857SBaptiste Daroussin return ucl_include_common (data, len, args, parser, false, false); 1458c99fb5f9SBaptiste Daroussin } 1459c99fb5f9SBaptiste Daroussin 1460c99fb5f9SBaptiste Daroussin /** 1461c99fb5f9SBaptiste Daroussin * Handle includes macro 1462c99fb5f9SBaptiste Daroussin * @param data include data 1463c99fb5f9SBaptiste Daroussin * @param len length of data 146439ee7a7aSBaptiste Daroussin * @param args UCL object representing arguments to the macro 1465c99fb5f9SBaptiste Daroussin * @param ud user data 1466c99fb5f9SBaptiste Daroussin * @return 1467c99fb5f9SBaptiste Daroussin */ 146839ee7a7aSBaptiste Daroussin bool 14694bf54857SBaptiste Daroussin ucl_includes_handler (const unsigned char *data, size_t len, 14704bf54857SBaptiste Daroussin const ucl_object_t *args, void* ud) 1471c99fb5f9SBaptiste Daroussin { 1472c99fb5f9SBaptiste Daroussin struct ucl_parser *parser = ud; 1473c99fb5f9SBaptiste Daroussin 14744bf54857SBaptiste Daroussin return ucl_include_common (data, len, args, parser, false, true); 1475c99fb5f9SBaptiste Daroussin } 1476c99fb5f9SBaptiste Daroussin 147739ee7a7aSBaptiste Daroussin /** 147839ee7a7aSBaptiste Daroussin * Handle tryinclude macro 147939ee7a7aSBaptiste Daroussin * @param data include data 148039ee7a7aSBaptiste Daroussin * @param len length of data 148139ee7a7aSBaptiste Daroussin * @param args UCL object representing arguments to the macro 148239ee7a7aSBaptiste Daroussin * @param ud user data 148339ee7a7aSBaptiste Daroussin * @return 148439ee7a7aSBaptiste Daroussin */ 148539ee7a7aSBaptiste Daroussin bool 14864bf54857SBaptiste Daroussin ucl_try_include_handler (const unsigned char *data, size_t len, 14874bf54857SBaptiste Daroussin const ucl_object_t *args, void* ud) 1488c99fb5f9SBaptiste Daroussin { 1489c99fb5f9SBaptiste Daroussin struct ucl_parser *parser = ud; 1490c99fb5f9SBaptiste Daroussin 14914bf54857SBaptiste Daroussin return ucl_include_common (data, len, args, parser, true, false); 1492c99fb5f9SBaptiste Daroussin } 1493c99fb5f9SBaptiste Daroussin 149439ee7a7aSBaptiste Daroussin /** 149539ee7a7aSBaptiste Daroussin * Handle priority macro 149639ee7a7aSBaptiste Daroussin * @param data include data 149739ee7a7aSBaptiste Daroussin * @param len length of data 149839ee7a7aSBaptiste Daroussin * @param args UCL object representing arguments to the macro 149939ee7a7aSBaptiste Daroussin * @param ud user data 150039ee7a7aSBaptiste Daroussin * @return 150139ee7a7aSBaptiste Daroussin */ 150239ee7a7aSBaptiste Daroussin bool 150339ee7a7aSBaptiste Daroussin ucl_priority_handler (const unsigned char *data, size_t len, 150439ee7a7aSBaptiste Daroussin const ucl_object_t *args, void* ud) 150539ee7a7aSBaptiste Daroussin { 150639ee7a7aSBaptiste Daroussin struct ucl_parser *parser = ud; 150739ee7a7aSBaptiste Daroussin unsigned priority = 255; 150839ee7a7aSBaptiste Daroussin const ucl_object_t *param; 150939ee7a7aSBaptiste Daroussin bool found = false; 151039ee7a7aSBaptiste Daroussin char *value = NULL, *leftover = NULL; 151139ee7a7aSBaptiste Daroussin ucl_object_iter_t it = NULL; 151239ee7a7aSBaptiste Daroussin 151339ee7a7aSBaptiste Daroussin if (parser == NULL) { 151439ee7a7aSBaptiste Daroussin return false; 151539ee7a7aSBaptiste Daroussin } 151639ee7a7aSBaptiste Daroussin 151739ee7a7aSBaptiste Daroussin /* Process arguments */ 151839ee7a7aSBaptiste Daroussin if (args != NULL && args->type == UCL_OBJECT) { 1519d9f0ce31SBaptiste Daroussin while ((param = ucl_object_iterate (args, &it, true)) != NULL) { 152039ee7a7aSBaptiste Daroussin if (param->type == UCL_INT) { 152139ee7a7aSBaptiste Daroussin if (strncmp (param->key, "priority", param->keylen) == 0) { 152239ee7a7aSBaptiste Daroussin priority = ucl_object_toint (param); 152339ee7a7aSBaptiste Daroussin found = true; 152439ee7a7aSBaptiste Daroussin } 152539ee7a7aSBaptiste Daroussin } 152639ee7a7aSBaptiste Daroussin } 152739ee7a7aSBaptiste Daroussin } 152839ee7a7aSBaptiste Daroussin 152939ee7a7aSBaptiste Daroussin if (len > 0) { 153039ee7a7aSBaptiste Daroussin value = malloc(len + 1); 153139ee7a7aSBaptiste Daroussin ucl_strlcpy(value, (const char *)data, len + 1); 153239ee7a7aSBaptiste Daroussin priority = strtol(value, &leftover, 10); 153339ee7a7aSBaptiste Daroussin if (*leftover != '\0') { 153439ee7a7aSBaptiste Daroussin ucl_create_err (&parser->err, "Invalid priority value in macro: %s", 153539ee7a7aSBaptiste Daroussin value); 153639ee7a7aSBaptiste Daroussin free(value); 153739ee7a7aSBaptiste Daroussin return false; 153839ee7a7aSBaptiste Daroussin } 153939ee7a7aSBaptiste Daroussin free(value); 154039ee7a7aSBaptiste Daroussin found = true; 154139ee7a7aSBaptiste Daroussin } 154239ee7a7aSBaptiste Daroussin 154339ee7a7aSBaptiste Daroussin if (found == true) { 154439ee7a7aSBaptiste Daroussin parser->chunks->priority = priority; 154539ee7a7aSBaptiste Daroussin return true; 154639ee7a7aSBaptiste Daroussin } 154739ee7a7aSBaptiste Daroussin 154839ee7a7aSBaptiste Daroussin ucl_create_err (&parser->err, "Unable to parse priority macro"); 154939ee7a7aSBaptiste Daroussin return false; 155039ee7a7aSBaptiste Daroussin } 155139ee7a7aSBaptiste Daroussin 155239ee7a7aSBaptiste Daroussin /** 155339ee7a7aSBaptiste Daroussin * Handle load macro 155439ee7a7aSBaptiste Daroussin * @param data include data 155539ee7a7aSBaptiste Daroussin * @param len length of data 155639ee7a7aSBaptiste Daroussin * @param args UCL object representing arguments to the macro 155739ee7a7aSBaptiste Daroussin * @param ud user data 155839ee7a7aSBaptiste Daroussin * @return 155939ee7a7aSBaptiste Daroussin */ 156039ee7a7aSBaptiste Daroussin bool 156139ee7a7aSBaptiste Daroussin ucl_load_handler (const unsigned char *data, size_t len, 156239ee7a7aSBaptiste Daroussin const ucl_object_t *args, void* ud) 156339ee7a7aSBaptiste Daroussin { 156439ee7a7aSBaptiste Daroussin struct ucl_parser *parser = ud; 156539ee7a7aSBaptiste Daroussin const ucl_object_t *param; 156639ee7a7aSBaptiste Daroussin ucl_object_t *obj, *old_obj; 156739ee7a7aSBaptiste Daroussin ucl_object_iter_t it = NULL; 156839ee7a7aSBaptiste Daroussin bool try_load, multiline, test; 156939ee7a7aSBaptiste Daroussin const char *target, *prefix; 157039ee7a7aSBaptiste Daroussin char *load_file, *tmp; 157139ee7a7aSBaptiste Daroussin unsigned char *buf; 157239ee7a7aSBaptiste Daroussin size_t buflen; 157339ee7a7aSBaptiste Daroussin unsigned priority; 157439ee7a7aSBaptiste Daroussin int64_t iv; 1575d9f0ce31SBaptiste Daroussin ucl_object_t *container = NULL; 157639ee7a7aSBaptiste Daroussin enum ucl_string_flags flags; 157739ee7a7aSBaptiste Daroussin 157839ee7a7aSBaptiste Daroussin /* Default values */ 157939ee7a7aSBaptiste Daroussin try_load = false; 158039ee7a7aSBaptiste Daroussin multiline = false; 158139ee7a7aSBaptiste Daroussin test = false; 158239ee7a7aSBaptiste Daroussin target = "string"; 158339ee7a7aSBaptiste Daroussin prefix = NULL; 158439ee7a7aSBaptiste Daroussin load_file = NULL; 158539ee7a7aSBaptiste Daroussin buf = NULL; 158639ee7a7aSBaptiste Daroussin buflen = 0; 158739ee7a7aSBaptiste Daroussin priority = 0; 158839ee7a7aSBaptiste Daroussin obj = NULL; 158939ee7a7aSBaptiste Daroussin old_obj = NULL; 159039ee7a7aSBaptiste Daroussin flags = 0; 159139ee7a7aSBaptiste Daroussin 159239ee7a7aSBaptiste Daroussin if (parser == NULL) { 159339ee7a7aSBaptiste Daroussin return false; 159439ee7a7aSBaptiste Daroussin } 159539ee7a7aSBaptiste Daroussin 159639ee7a7aSBaptiste Daroussin /* Process arguments */ 159739ee7a7aSBaptiste Daroussin if (args != NULL && args->type == UCL_OBJECT) { 1598d9f0ce31SBaptiste Daroussin while ((param = ucl_object_iterate (args, &it, true)) != NULL) { 159939ee7a7aSBaptiste Daroussin if (param->type == UCL_BOOLEAN) { 160039ee7a7aSBaptiste Daroussin if (strncmp (param->key, "try", param->keylen) == 0) { 160139ee7a7aSBaptiste Daroussin try_load = ucl_object_toboolean (param); 160239ee7a7aSBaptiste Daroussin } 160339ee7a7aSBaptiste Daroussin else if (strncmp (param->key, "multiline", param->keylen) == 0) { 160439ee7a7aSBaptiste Daroussin multiline = ucl_object_toboolean (param); 160539ee7a7aSBaptiste Daroussin } 160639ee7a7aSBaptiste Daroussin else if (strncmp (param->key, "escape", param->keylen) == 0) { 160739ee7a7aSBaptiste Daroussin test = ucl_object_toboolean (param); 160839ee7a7aSBaptiste Daroussin if (test) { 160939ee7a7aSBaptiste Daroussin flags |= UCL_STRING_ESCAPE; 161039ee7a7aSBaptiste Daroussin } 161139ee7a7aSBaptiste Daroussin } 161239ee7a7aSBaptiste Daroussin else if (strncmp (param->key, "trim", param->keylen) == 0) { 161339ee7a7aSBaptiste Daroussin test = ucl_object_toboolean (param); 161439ee7a7aSBaptiste Daroussin if (test) { 161539ee7a7aSBaptiste Daroussin flags |= UCL_STRING_TRIM; 161639ee7a7aSBaptiste Daroussin } 161739ee7a7aSBaptiste Daroussin } 161839ee7a7aSBaptiste Daroussin } 161939ee7a7aSBaptiste Daroussin else if (param->type == UCL_STRING) { 162039ee7a7aSBaptiste Daroussin if (strncmp (param->key, "key", param->keylen) == 0) { 162139ee7a7aSBaptiste Daroussin prefix = ucl_object_tostring (param); 162239ee7a7aSBaptiste Daroussin } 162339ee7a7aSBaptiste Daroussin else if (strncmp (param->key, "target", param->keylen) == 0) { 162439ee7a7aSBaptiste Daroussin target = ucl_object_tostring (param); 162539ee7a7aSBaptiste Daroussin } 162639ee7a7aSBaptiste Daroussin } 162739ee7a7aSBaptiste Daroussin else if (param->type == UCL_INT) { 162839ee7a7aSBaptiste Daroussin if (strncmp (param->key, "priority", param->keylen) == 0) { 162939ee7a7aSBaptiste Daroussin priority = ucl_object_toint (param); 163039ee7a7aSBaptiste Daroussin } 163139ee7a7aSBaptiste Daroussin } 163239ee7a7aSBaptiste Daroussin } 163339ee7a7aSBaptiste Daroussin } 163439ee7a7aSBaptiste Daroussin 163539ee7a7aSBaptiste Daroussin if (prefix == NULL || strlen (prefix) == 0) { 163639ee7a7aSBaptiste Daroussin ucl_create_err (&parser->err, "No Key specified in load macro"); 163739ee7a7aSBaptiste Daroussin return false; 163839ee7a7aSBaptiste Daroussin } 163939ee7a7aSBaptiste Daroussin 164039ee7a7aSBaptiste Daroussin if (len > 0) { 1641d9f0ce31SBaptiste Daroussin load_file = malloc (len + 1); 1642d9f0ce31SBaptiste Daroussin if (!load_file) { 1643d9f0ce31SBaptiste Daroussin ucl_create_err (&parser->err, "cannot allocate memory for suffix"); 1644d9f0ce31SBaptiste Daroussin 1645d9f0ce31SBaptiste Daroussin return false; 1646d9f0ce31SBaptiste Daroussin } 1647d9f0ce31SBaptiste Daroussin 1648d9f0ce31SBaptiste Daroussin snprintf (load_file, len + 1, "%.*s", (int)len, data); 1649d9f0ce31SBaptiste Daroussin 1650d9f0ce31SBaptiste Daroussin if (!ucl_fetch_file (load_file, &buf, &buflen, &parser->err, 1651d9f0ce31SBaptiste Daroussin !try_load)) { 1652d9f0ce31SBaptiste Daroussin free (load_file); 1653d9f0ce31SBaptiste Daroussin 165439ee7a7aSBaptiste Daroussin return (try_load || false); 165539ee7a7aSBaptiste Daroussin } 165639ee7a7aSBaptiste Daroussin 1657d9f0ce31SBaptiste Daroussin free (load_file); 1658d9f0ce31SBaptiste Daroussin container = parser->stack->obj; 1659d9f0ce31SBaptiste Daroussin old_obj = __DECONST (ucl_object_t *, ucl_object_lookup (container, 1660d9f0ce31SBaptiste Daroussin prefix)); 1661d9f0ce31SBaptiste Daroussin 166239ee7a7aSBaptiste Daroussin if (old_obj != NULL) { 166339ee7a7aSBaptiste Daroussin ucl_create_err (&parser->err, "Key %s already exists", prefix); 1664d9f0ce31SBaptiste Daroussin if (buf) { 1665d9f0ce31SBaptiste Daroussin ucl_munmap (buf, buflen); 1666d9f0ce31SBaptiste Daroussin } 1667d9f0ce31SBaptiste Daroussin 166839ee7a7aSBaptiste Daroussin return false; 166939ee7a7aSBaptiste Daroussin } 167039ee7a7aSBaptiste Daroussin 167139ee7a7aSBaptiste Daroussin if (strcasecmp (target, "string") == 0) { 167239ee7a7aSBaptiste Daroussin obj = ucl_object_fromstring_common (buf, buflen, flags); 167339ee7a7aSBaptiste Daroussin ucl_copy_value_trash (obj); 167439ee7a7aSBaptiste Daroussin if (multiline) { 167539ee7a7aSBaptiste Daroussin obj->flags |= UCL_OBJECT_MULTILINE; 167639ee7a7aSBaptiste Daroussin } 167739ee7a7aSBaptiste Daroussin } 167839ee7a7aSBaptiste Daroussin else if (strcasecmp (target, "int") == 0) { 1679d9f0ce31SBaptiste Daroussin tmp = malloc (buflen + 1); 1680d9f0ce31SBaptiste Daroussin 1681d9f0ce31SBaptiste Daroussin if (tmp == NULL) { 1682d9f0ce31SBaptiste Daroussin ucl_create_err (&parser->err, "Memory allocation failed"); 1683d9f0ce31SBaptiste Daroussin if (buf) { 1684d9f0ce31SBaptiste Daroussin ucl_munmap (buf, buflen); 168539ee7a7aSBaptiste Daroussin } 168639ee7a7aSBaptiste Daroussin 1687d9f0ce31SBaptiste Daroussin return false; 1688d9f0ce31SBaptiste Daroussin } 1689d9f0ce31SBaptiste Daroussin 1690d9f0ce31SBaptiste Daroussin snprintf (tmp, buflen + 1, "%.*s", (int)buflen, buf); 1691d9f0ce31SBaptiste Daroussin iv = strtoll (tmp, NULL, 10); 1692d9f0ce31SBaptiste Daroussin obj = ucl_object_fromint (iv); 1693d9f0ce31SBaptiste Daroussin free (tmp); 1694d9f0ce31SBaptiste Daroussin } 1695d9f0ce31SBaptiste Daroussin 1696d9f0ce31SBaptiste Daroussin if (buf) { 169739ee7a7aSBaptiste Daroussin ucl_munmap (buf, buflen); 169839ee7a7aSBaptiste Daroussin } 169939ee7a7aSBaptiste Daroussin 170039ee7a7aSBaptiste Daroussin if (obj != NULL) { 170139ee7a7aSBaptiste Daroussin obj->key = prefix; 170239ee7a7aSBaptiste Daroussin obj->keylen = strlen (prefix); 170339ee7a7aSBaptiste Daroussin ucl_copy_key_trash (obj); 170439ee7a7aSBaptiste Daroussin obj->prev = obj; 170539ee7a7aSBaptiste Daroussin obj->next = NULL; 170639ee7a7aSBaptiste Daroussin ucl_object_set_priority (obj, priority); 1707d9f0ce31SBaptiste Daroussin ucl_object_insert_key (container, obj, obj->key, obj->keylen, false); 170839ee7a7aSBaptiste Daroussin } 1709d9f0ce31SBaptiste Daroussin 171039ee7a7aSBaptiste Daroussin return true; 171139ee7a7aSBaptiste Daroussin } 171239ee7a7aSBaptiste Daroussin 171339ee7a7aSBaptiste Daroussin ucl_create_err (&parser->err, "Unable to parse load macro"); 171439ee7a7aSBaptiste Daroussin return false; 171539ee7a7aSBaptiste Daroussin } 171639ee7a7aSBaptiste Daroussin 171739ee7a7aSBaptiste Daroussin bool 171839ee7a7aSBaptiste Daroussin ucl_inherit_handler (const unsigned char *data, size_t len, 171939ee7a7aSBaptiste Daroussin const ucl_object_t *args, const ucl_object_t *ctx, void* ud) 172039ee7a7aSBaptiste Daroussin { 172139ee7a7aSBaptiste Daroussin const ucl_object_t *parent, *cur; 172239ee7a7aSBaptiste Daroussin ucl_object_t *target, *copy; 172339ee7a7aSBaptiste Daroussin ucl_object_iter_t it = NULL; 172439ee7a7aSBaptiste Daroussin bool replace = false; 172539ee7a7aSBaptiste Daroussin struct ucl_parser *parser = ud; 172639ee7a7aSBaptiste Daroussin 1727d9f0ce31SBaptiste Daroussin parent = ucl_object_lookup_len (ctx, data, len); 172839ee7a7aSBaptiste Daroussin 172939ee7a7aSBaptiste Daroussin /* Some sanity checks */ 173039ee7a7aSBaptiste Daroussin if (parent == NULL || ucl_object_type (parent) != UCL_OBJECT) { 173139ee7a7aSBaptiste Daroussin ucl_create_err (&parser->err, "Unable to find inherited object %*.s", 173239ee7a7aSBaptiste Daroussin (int)len, data); 173339ee7a7aSBaptiste Daroussin return false; 173439ee7a7aSBaptiste Daroussin } 173539ee7a7aSBaptiste Daroussin 173639ee7a7aSBaptiste Daroussin if (parser->stack == NULL || parser->stack->obj == NULL || 173739ee7a7aSBaptiste Daroussin ucl_object_type (parser->stack->obj) != UCL_OBJECT) { 173839ee7a7aSBaptiste Daroussin ucl_create_err (&parser->err, "Invalid inherit context"); 173939ee7a7aSBaptiste Daroussin return false; 174039ee7a7aSBaptiste Daroussin } 174139ee7a7aSBaptiste Daroussin 174239ee7a7aSBaptiste Daroussin target = parser->stack->obj; 174339ee7a7aSBaptiste Daroussin 1744d9f0ce31SBaptiste Daroussin if (args && (cur = ucl_object_lookup (args, "replace")) != NULL) { 174539ee7a7aSBaptiste Daroussin replace = ucl_object_toboolean (cur); 174639ee7a7aSBaptiste Daroussin } 174739ee7a7aSBaptiste Daroussin 1748d9f0ce31SBaptiste Daroussin while ((cur = ucl_object_iterate (parent, &it, true))) { 174939ee7a7aSBaptiste Daroussin /* We do not replace existing keys */ 1750d9f0ce31SBaptiste Daroussin if (!replace && ucl_object_lookup_len (target, cur->key, cur->keylen)) { 175139ee7a7aSBaptiste Daroussin continue; 175239ee7a7aSBaptiste Daroussin } 175339ee7a7aSBaptiste Daroussin 175439ee7a7aSBaptiste Daroussin copy = ucl_object_copy (cur); 175539ee7a7aSBaptiste Daroussin 175639ee7a7aSBaptiste Daroussin if (!replace) { 175739ee7a7aSBaptiste Daroussin copy->flags |= UCL_OBJECT_INHERITED; 175839ee7a7aSBaptiste Daroussin } 175939ee7a7aSBaptiste Daroussin 176039ee7a7aSBaptiste Daroussin ucl_object_insert_key (target, copy, copy->key, 176139ee7a7aSBaptiste Daroussin copy->keylen, false); 176239ee7a7aSBaptiste Daroussin } 176339ee7a7aSBaptiste Daroussin 176439ee7a7aSBaptiste Daroussin return true; 176539ee7a7aSBaptiste Daroussin } 176639ee7a7aSBaptiste Daroussin 176739ee7a7aSBaptiste Daroussin bool 1768c99fb5f9SBaptiste Daroussin ucl_parser_set_filevars (struct ucl_parser *parser, const char *filename, bool need_expand) 1769c99fb5f9SBaptiste Daroussin { 1770c99fb5f9SBaptiste Daroussin char realbuf[PATH_MAX], *curdir; 1771c99fb5f9SBaptiste Daroussin 1772c99fb5f9SBaptiste Daroussin if (filename != NULL) { 1773c99fb5f9SBaptiste Daroussin if (need_expand) { 177497bd480fSBaptiste Daroussin if (ucl_realpath (filename, realbuf) == NULL) { 1775c99fb5f9SBaptiste Daroussin return false; 1776c99fb5f9SBaptiste Daroussin } 1777c99fb5f9SBaptiste Daroussin } 1778c99fb5f9SBaptiste Daroussin else { 1779c99fb5f9SBaptiste Daroussin ucl_strlcpy (realbuf, filename, sizeof (realbuf)); 1780c99fb5f9SBaptiste Daroussin } 1781c99fb5f9SBaptiste Daroussin 1782c99fb5f9SBaptiste Daroussin /* Define variables */ 1783c99fb5f9SBaptiste Daroussin ucl_parser_register_variable (parser, "FILENAME", realbuf); 1784c99fb5f9SBaptiste Daroussin curdir = dirname (realbuf); 1785c99fb5f9SBaptiste Daroussin ucl_parser_register_variable (parser, "CURDIR", curdir); 1786c99fb5f9SBaptiste Daroussin } 1787c99fb5f9SBaptiste Daroussin else { 1788c99fb5f9SBaptiste Daroussin /* Set everything from the current dir */ 1789c99fb5f9SBaptiste Daroussin curdir = getcwd (realbuf, sizeof (realbuf)); 1790c99fb5f9SBaptiste Daroussin ucl_parser_register_variable (parser, "FILENAME", "undef"); 1791c99fb5f9SBaptiste Daroussin ucl_parser_register_variable (parser, "CURDIR", curdir); 1792c99fb5f9SBaptiste Daroussin } 1793c99fb5f9SBaptiste Daroussin 1794c99fb5f9SBaptiste Daroussin return true; 1795c99fb5f9SBaptiste Daroussin } 1796c99fb5f9SBaptiste Daroussin 179739ee7a7aSBaptiste Daroussin bool 1798*273c26a3SBaptiste Daroussin ucl_parser_add_file_full (struct ucl_parser *parser, const char *filename, 1799*273c26a3SBaptiste Daroussin unsigned priority, enum ucl_duplicate_strategy strat, 1800*273c26a3SBaptiste Daroussin enum ucl_parse_type parse_type) 1801c99fb5f9SBaptiste Daroussin { 1802c99fb5f9SBaptiste Daroussin unsigned char *buf; 1803c99fb5f9SBaptiste Daroussin size_t len; 1804c99fb5f9SBaptiste Daroussin bool ret; 1805c99fb5f9SBaptiste Daroussin char realbuf[PATH_MAX]; 1806c99fb5f9SBaptiste Daroussin 180797bd480fSBaptiste Daroussin if (ucl_realpath (filename, realbuf) == NULL) { 1808c99fb5f9SBaptiste Daroussin ucl_create_err (&parser->err, "cannot open file %s: %s", 1809c99fb5f9SBaptiste Daroussin filename, 1810c99fb5f9SBaptiste Daroussin strerror (errno)); 1811c99fb5f9SBaptiste Daroussin return false; 1812c99fb5f9SBaptiste Daroussin } 1813c99fb5f9SBaptiste Daroussin 1814c99fb5f9SBaptiste Daroussin if (!ucl_fetch_file (realbuf, &buf, &len, &parser->err, true)) { 1815c99fb5f9SBaptiste Daroussin return false; 1816c99fb5f9SBaptiste Daroussin } 1817c99fb5f9SBaptiste Daroussin 18184bf54857SBaptiste Daroussin if (parser->cur_file) { 18194bf54857SBaptiste Daroussin free (parser->cur_file); 18204bf54857SBaptiste Daroussin } 18214bf54857SBaptiste Daroussin parser->cur_file = strdup (realbuf); 1822c99fb5f9SBaptiste Daroussin ucl_parser_set_filevars (parser, realbuf, false); 1823*273c26a3SBaptiste Daroussin ret = ucl_parser_add_chunk_full (parser, buf, len, priority, strat, 1824*273c26a3SBaptiste Daroussin parse_type); 1825c99fb5f9SBaptiste Daroussin 1826c99fb5f9SBaptiste Daroussin if (len > 0) { 182797bd480fSBaptiste Daroussin ucl_munmap (buf, len); 1828c99fb5f9SBaptiste Daroussin } 1829c99fb5f9SBaptiste Daroussin 1830c99fb5f9SBaptiste Daroussin return ret; 1831c99fb5f9SBaptiste Daroussin } 1832c99fb5f9SBaptiste Daroussin 183339ee7a7aSBaptiste Daroussin bool 1834*273c26a3SBaptiste Daroussin ucl_parser_add_file_priority (struct ucl_parser *parser, const char *filename, 1835*273c26a3SBaptiste Daroussin unsigned priority) 1836*273c26a3SBaptiste Daroussin { 1837*273c26a3SBaptiste Daroussin if (parser == NULL) { 1838*273c26a3SBaptiste Daroussin return false; 1839*273c26a3SBaptiste Daroussin } 1840*273c26a3SBaptiste Daroussin 1841*273c26a3SBaptiste Daroussin return ucl_parser_add_file_full(parser, filename, priority, 1842*273c26a3SBaptiste Daroussin UCL_DUPLICATE_APPEND, UCL_PARSE_UCL); 1843*273c26a3SBaptiste Daroussin } 1844*273c26a3SBaptiste Daroussin 1845*273c26a3SBaptiste Daroussin bool 184639ee7a7aSBaptiste Daroussin ucl_parser_add_file (struct ucl_parser *parser, const char *filename) 184739ee7a7aSBaptiste Daroussin { 184839ee7a7aSBaptiste Daroussin if (parser == NULL) { 184939ee7a7aSBaptiste Daroussin return false; 185039ee7a7aSBaptiste Daroussin } 185139ee7a7aSBaptiste Daroussin 1852*273c26a3SBaptiste Daroussin return ucl_parser_add_file_full(parser, filename, 1853*273c26a3SBaptiste Daroussin parser->default_priority, UCL_DUPLICATE_APPEND, 1854*273c26a3SBaptiste Daroussin UCL_PARSE_UCL); 185539ee7a7aSBaptiste Daroussin } 185639ee7a7aSBaptiste Daroussin 185739ee7a7aSBaptiste Daroussin bool 185839ee7a7aSBaptiste Daroussin ucl_parser_add_fd_priority (struct ucl_parser *parser, int fd, 185939ee7a7aSBaptiste Daroussin unsigned priority) 18604bf54857SBaptiste Daroussin { 18614bf54857SBaptiste Daroussin unsigned char *buf; 18624bf54857SBaptiste Daroussin size_t len; 18634bf54857SBaptiste Daroussin bool ret; 18644bf54857SBaptiste Daroussin struct stat st; 18654bf54857SBaptiste Daroussin 18664bf54857SBaptiste Daroussin if (fstat (fd, &st) == -1) { 18674bf54857SBaptiste Daroussin ucl_create_err (&parser->err, "cannot stat fd %d: %s", 18684bf54857SBaptiste Daroussin fd, strerror (errno)); 18694bf54857SBaptiste Daroussin return false; 18704bf54857SBaptiste Daroussin } 18716525738fSBaptiste Daroussin if (st.st_size == 0) { 18726525738fSBaptiste Daroussin return true; 18736525738fSBaptiste Daroussin } 18744bf54857SBaptiste Daroussin if ((buf = ucl_mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) { 18754bf54857SBaptiste Daroussin ucl_create_err (&parser->err, "cannot mmap fd %d: %s", 18764bf54857SBaptiste Daroussin fd, strerror (errno)); 18774bf54857SBaptiste Daroussin return false; 18784bf54857SBaptiste Daroussin } 18794bf54857SBaptiste Daroussin 18804bf54857SBaptiste Daroussin if (parser->cur_file) { 18814bf54857SBaptiste Daroussin free (parser->cur_file); 18824bf54857SBaptiste Daroussin } 18834bf54857SBaptiste Daroussin parser->cur_file = NULL; 18844bf54857SBaptiste Daroussin len = st.st_size; 188539ee7a7aSBaptiste Daroussin ret = ucl_parser_add_chunk_priority (parser, buf, len, priority); 18864bf54857SBaptiste Daroussin 18874bf54857SBaptiste Daroussin if (len > 0) { 18884bf54857SBaptiste Daroussin ucl_munmap (buf, len); 18894bf54857SBaptiste Daroussin } 18904bf54857SBaptiste Daroussin 18914bf54857SBaptiste Daroussin return ret; 18924bf54857SBaptiste Daroussin } 18934bf54857SBaptiste Daroussin 189439ee7a7aSBaptiste Daroussin bool 189539ee7a7aSBaptiste Daroussin ucl_parser_add_fd (struct ucl_parser *parser, int fd) 189639ee7a7aSBaptiste Daroussin { 189739ee7a7aSBaptiste Daroussin if (parser == NULL) { 189839ee7a7aSBaptiste Daroussin return false; 189939ee7a7aSBaptiste Daroussin } 190039ee7a7aSBaptiste Daroussin 190139ee7a7aSBaptiste Daroussin return ucl_parser_add_fd_priority(parser, fd, parser->default_priority); 190239ee7a7aSBaptiste Daroussin } 190339ee7a7aSBaptiste Daroussin 1904c99fb5f9SBaptiste Daroussin size_t 1905c99fb5f9SBaptiste Daroussin ucl_strlcpy (char *dst, const char *src, size_t siz) 1906c99fb5f9SBaptiste Daroussin { 1907c99fb5f9SBaptiste Daroussin char *d = dst; 1908c99fb5f9SBaptiste Daroussin const char *s = src; 1909c99fb5f9SBaptiste Daroussin size_t n = siz; 1910c99fb5f9SBaptiste Daroussin 1911c99fb5f9SBaptiste Daroussin /* Copy as many bytes as will fit */ 1912c99fb5f9SBaptiste Daroussin if (n != 0) { 1913c99fb5f9SBaptiste Daroussin while (--n != 0) { 1914c99fb5f9SBaptiste Daroussin if ((*d++ = *s++) == '\0') { 1915c99fb5f9SBaptiste Daroussin break; 1916c99fb5f9SBaptiste Daroussin } 1917c99fb5f9SBaptiste Daroussin } 1918c99fb5f9SBaptiste Daroussin } 1919c99fb5f9SBaptiste Daroussin 1920c99fb5f9SBaptiste Daroussin if (n == 0 && siz != 0) { 1921c99fb5f9SBaptiste Daroussin *d = '\0'; 1922c99fb5f9SBaptiste Daroussin } 1923c99fb5f9SBaptiste Daroussin 1924c99fb5f9SBaptiste Daroussin return (s - src - 1); /* count does not include NUL */ 1925c99fb5f9SBaptiste Daroussin } 1926c99fb5f9SBaptiste Daroussin 1927c99fb5f9SBaptiste Daroussin size_t 1928c99fb5f9SBaptiste Daroussin ucl_strlcpy_unsafe (char *dst, const char *src, size_t siz) 1929c99fb5f9SBaptiste Daroussin { 1930c99fb5f9SBaptiste Daroussin memcpy (dst, src, siz - 1); 1931c99fb5f9SBaptiste Daroussin dst[siz - 1] = '\0'; 1932c99fb5f9SBaptiste Daroussin 1933c99fb5f9SBaptiste Daroussin return siz - 1; 1934c99fb5f9SBaptiste Daroussin } 1935c99fb5f9SBaptiste Daroussin 1936c99fb5f9SBaptiste Daroussin size_t 1937c99fb5f9SBaptiste Daroussin ucl_strlcpy_tolower (char *dst, const char *src, size_t siz) 1938c99fb5f9SBaptiste Daroussin { 1939c99fb5f9SBaptiste Daroussin char *d = dst; 1940c99fb5f9SBaptiste Daroussin const char *s = src; 1941c99fb5f9SBaptiste Daroussin size_t n = siz; 1942c99fb5f9SBaptiste Daroussin 1943c99fb5f9SBaptiste Daroussin /* Copy as many bytes as will fit */ 1944c99fb5f9SBaptiste Daroussin if (n != 0) { 1945c99fb5f9SBaptiste Daroussin while (--n != 0) { 1946c99fb5f9SBaptiste Daroussin if ((*d++ = tolower (*s++)) == '\0') { 1947c99fb5f9SBaptiste Daroussin break; 1948c99fb5f9SBaptiste Daroussin } 1949c99fb5f9SBaptiste Daroussin } 1950c99fb5f9SBaptiste Daroussin } 1951c99fb5f9SBaptiste Daroussin 1952c99fb5f9SBaptiste Daroussin if (n == 0 && siz != 0) { 1953c99fb5f9SBaptiste Daroussin *d = '\0'; 1954c99fb5f9SBaptiste Daroussin } 1955c99fb5f9SBaptiste Daroussin 1956c99fb5f9SBaptiste Daroussin return (s - src); /* count does not include NUL */ 1957c99fb5f9SBaptiste Daroussin } 1958c99fb5f9SBaptiste Daroussin 195939ee7a7aSBaptiste Daroussin /* 196039ee7a7aSBaptiste Daroussin * Find the first occurrence of find in s 196139ee7a7aSBaptiste Daroussin */ 196239ee7a7aSBaptiste Daroussin char * 196339ee7a7aSBaptiste Daroussin ucl_strnstr (const char *s, const char *find, int len) 196439ee7a7aSBaptiste Daroussin { 196539ee7a7aSBaptiste Daroussin char c, sc; 196639ee7a7aSBaptiste Daroussin int mlen; 196739ee7a7aSBaptiste Daroussin 196839ee7a7aSBaptiste Daroussin if ((c = *find++) != 0) { 196939ee7a7aSBaptiste Daroussin mlen = strlen (find); 197039ee7a7aSBaptiste Daroussin do { 197139ee7a7aSBaptiste Daroussin do { 197239ee7a7aSBaptiste Daroussin if ((sc = *s++) == 0 || len-- == 0) 197339ee7a7aSBaptiste Daroussin return (NULL); 197439ee7a7aSBaptiste Daroussin } while (sc != c); 197539ee7a7aSBaptiste Daroussin } while (strncmp (s, find, mlen) != 0); 197639ee7a7aSBaptiste Daroussin s--; 197739ee7a7aSBaptiste Daroussin } 197839ee7a7aSBaptiste Daroussin return ((char *)s); 197939ee7a7aSBaptiste Daroussin } 198039ee7a7aSBaptiste Daroussin 198139ee7a7aSBaptiste Daroussin /* 198239ee7a7aSBaptiste Daroussin * Find the first occurrence of find in s, ignore case. 198339ee7a7aSBaptiste Daroussin */ 198439ee7a7aSBaptiste Daroussin char * 198539ee7a7aSBaptiste Daroussin ucl_strncasestr (const char *s, const char *find, int len) 198639ee7a7aSBaptiste Daroussin { 198739ee7a7aSBaptiste Daroussin char c, sc; 198839ee7a7aSBaptiste Daroussin int mlen; 198939ee7a7aSBaptiste Daroussin 199039ee7a7aSBaptiste Daroussin if ((c = *find++) != 0) { 199139ee7a7aSBaptiste Daroussin c = tolower (c); 199239ee7a7aSBaptiste Daroussin mlen = strlen (find); 199339ee7a7aSBaptiste Daroussin do { 199439ee7a7aSBaptiste Daroussin do { 199539ee7a7aSBaptiste Daroussin if ((sc = *s++) == 0 || len-- == 0) 199639ee7a7aSBaptiste Daroussin return (NULL); 199739ee7a7aSBaptiste Daroussin } while (tolower (sc) != c); 199839ee7a7aSBaptiste Daroussin } while (strncasecmp (s, find, mlen) != 0); 199939ee7a7aSBaptiste Daroussin s--; 200039ee7a7aSBaptiste Daroussin } 200139ee7a7aSBaptiste Daroussin return ((char *)s); 200239ee7a7aSBaptiste Daroussin } 200339ee7a7aSBaptiste Daroussin 2004c99fb5f9SBaptiste Daroussin ucl_object_t * 2005c99fb5f9SBaptiste Daroussin ucl_object_fromstring_common (const char *str, size_t len, enum ucl_string_flags flags) 2006c99fb5f9SBaptiste Daroussin { 2007c99fb5f9SBaptiste Daroussin ucl_object_t *obj; 2008c99fb5f9SBaptiste Daroussin const char *start, *end, *p, *pos; 2009c99fb5f9SBaptiste Daroussin char *dst, *d; 2010c99fb5f9SBaptiste Daroussin size_t escaped_len; 2011c99fb5f9SBaptiste Daroussin 2012c99fb5f9SBaptiste Daroussin if (str == NULL) { 2013c99fb5f9SBaptiste Daroussin return NULL; 2014c99fb5f9SBaptiste Daroussin } 2015c99fb5f9SBaptiste Daroussin 2016c99fb5f9SBaptiste Daroussin obj = ucl_object_new (); 2017c99fb5f9SBaptiste Daroussin if (obj) { 2018c99fb5f9SBaptiste Daroussin if (len == 0) { 2019c99fb5f9SBaptiste Daroussin len = strlen (str); 2020c99fb5f9SBaptiste Daroussin } 2021c99fb5f9SBaptiste Daroussin if (flags & UCL_STRING_TRIM) { 2022c99fb5f9SBaptiste Daroussin /* Skip leading spaces */ 2023c99fb5f9SBaptiste Daroussin for (start = str; (size_t)(start - str) < len; start ++) { 2024c99fb5f9SBaptiste Daroussin if (!ucl_test_character (*start, UCL_CHARACTER_WHITESPACE_UNSAFE)) { 2025c99fb5f9SBaptiste Daroussin break; 2026c99fb5f9SBaptiste Daroussin } 2027c99fb5f9SBaptiste Daroussin } 2028c99fb5f9SBaptiste Daroussin /* Skip trailing spaces */ 2029c99fb5f9SBaptiste Daroussin for (end = str + len - 1; end > start; end --) { 2030c99fb5f9SBaptiste Daroussin if (!ucl_test_character (*end, UCL_CHARACTER_WHITESPACE_UNSAFE)) { 2031c99fb5f9SBaptiste Daroussin break; 2032c99fb5f9SBaptiste Daroussin } 2033c99fb5f9SBaptiste Daroussin } 2034c99fb5f9SBaptiste Daroussin end ++; 2035c99fb5f9SBaptiste Daroussin } 2036c99fb5f9SBaptiste Daroussin else { 2037c99fb5f9SBaptiste Daroussin start = str; 2038c99fb5f9SBaptiste Daroussin end = str + len; 2039c99fb5f9SBaptiste Daroussin } 2040c99fb5f9SBaptiste Daroussin 2041c99fb5f9SBaptiste Daroussin obj->type = UCL_STRING; 2042c99fb5f9SBaptiste Daroussin if (flags & UCL_STRING_ESCAPE) { 2043c99fb5f9SBaptiste Daroussin for (p = start, escaped_len = 0; p < end; p ++, escaped_len ++) { 2044c99fb5f9SBaptiste Daroussin if (ucl_test_character (*p, UCL_CHARACTER_JSON_UNSAFE)) { 2045c99fb5f9SBaptiste Daroussin escaped_len ++; 2046c99fb5f9SBaptiste Daroussin } 2047c99fb5f9SBaptiste Daroussin } 2048c99fb5f9SBaptiste Daroussin dst = malloc (escaped_len + 1); 2049c99fb5f9SBaptiste Daroussin if (dst != NULL) { 2050c99fb5f9SBaptiste Daroussin for (p = start, d = dst; p < end; p ++, d ++) { 2051c99fb5f9SBaptiste Daroussin if (ucl_test_character (*p, UCL_CHARACTER_JSON_UNSAFE)) { 2052c99fb5f9SBaptiste Daroussin switch (*p) { 2053c99fb5f9SBaptiste Daroussin case '\n': 2054c99fb5f9SBaptiste Daroussin *d++ = '\\'; 2055c99fb5f9SBaptiste Daroussin *d = 'n'; 2056c99fb5f9SBaptiste Daroussin break; 2057c99fb5f9SBaptiste Daroussin case '\r': 2058c99fb5f9SBaptiste Daroussin *d++ = '\\'; 2059c99fb5f9SBaptiste Daroussin *d = 'r'; 2060c99fb5f9SBaptiste Daroussin break; 2061c99fb5f9SBaptiste Daroussin case '\b': 2062c99fb5f9SBaptiste Daroussin *d++ = '\\'; 2063c99fb5f9SBaptiste Daroussin *d = 'b'; 2064c99fb5f9SBaptiste Daroussin break; 2065c99fb5f9SBaptiste Daroussin case '\t': 2066c99fb5f9SBaptiste Daroussin *d++ = '\\'; 2067c99fb5f9SBaptiste Daroussin *d = 't'; 2068c99fb5f9SBaptiste Daroussin break; 2069c99fb5f9SBaptiste Daroussin case '\f': 2070c99fb5f9SBaptiste Daroussin *d++ = '\\'; 2071c99fb5f9SBaptiste Daroussin *d = 'f'; 2072c99fb5f9SBaptiste Daroussin break; 2073c99fb5f9SBaptiste Daroussin case '\\': 2074c99fb5f9SBaptiste Daroussin *d++ = '\\'; 2075c99fb5f9SBaptiste Daroussin *d = '\\'; 2076c99fb5f9SBaptiste Daroussin break; 2077c99fb5f9SBaptiste Daroussin case '"': 2078c99fb5f9SBaptiste Daroussin *d++ = '\\'; 2079c99fb5f9SBaptiste Daroussin *d = '"'; 2080c99fb5f9SBaptiste Daroussin break; 2081c99fb5f9SBaptiste Daroussin } 2082c99fb5f9SBaptiste Daroussin } 2083c99fb5f9SBaptiste Daroussin else { 2084c99fb5f9SBaptiste Daroussin *d = *p; 2085c99fb5f9SBaptiste Daroussin } 2086c99fb5f9SBaptiste Daroussin } 2087c99fb5f9SBaptiste Daroussin *d = '\0'; 2088c99fb5f9SBaptiste Daroussin obj->value.sv = dst; 2089c99fb5f9SBaptiste Daroussin obj->trash_stack[UCL_TRASH_VALUE] = dst; 2090c99fb5f9SBaptiste Daroussin obj->len = escaped_len; 2091c99fb5f9SBaptiste Daroussin } 2092c99fb5f9SBaptiste Daroussin } 2093c99fb5f9SBaptiste Daroussin else { 2094c99fb5f9SBaptiste Daroussin dst = malloc (end - start + 1); 2095c99fb5f9SBaptiste Daroussin if (dst != NULL) { 2096c99fb5f9SBaptiste Daroussin ucl_strlcpy_unsafe (dst, start, end - start + 1); 2097c99fb5f9SBaptiste Daroussin obj->value.sv = dst; 2098c99fb5f9SBaptiste Daroussin obj->trash_stack[UCL_TRASH_VALUE] = dst; 2099c99fb5f9SBaptiste Daroussin obj->len = end - start; 2100c99fb5f9SBaptiste Daroussin } 2101c99fb5f9SBaptiste Daroussin } 2102c99fb5f9SBaptiste Daroussin if ((flags & UCL_STRING_PARSE) && dst != NULL) { 2103c99fb5f9SBaptiste Daroussin /* Parse what we have */ 2104c99fb5f9SBaptiste Daroussin if (flags & UCL_STRING_PARSE_BOOLEAN) { 2105c99fb5f9SBaptiste Daroussin if (!ucl_maybe_parse_boolean (obj, dst, obj->len) && (flags & UCL_STRING_PARSE_NUMBER)) { 2106c99fb5f9SBaptiste Daroussin ucl_maybe_parse_number (obj, dst, dst + obj->len, &pos, 2107c99fb5f9SBaptiste Daroussin flags & UCL_STRING_PARSE_DOUBLE, 210897bd480fSBaptiste Daroussin flags & UCL_STRING_PARSE_BYTES, 210997bd480fSBaptiste Daroussin flags & UCL_STRING_PARSE_TIME); 2110c99fb5f9SBaptiste Daroussin } 2111c99fb5f9SBaptiste Daroussin } 2112c99fb5f9SBaptiste Daroussin else { 2113c99fb5f9SBaptiste Daroussin ucl_maybe_parse_number (obj, dst, dst + obj->len, &pos, 2114c99fb5f9SBaptiste Daroussin flags & UCL_STRING_PARSE_DOUBLE, 211597bd480fSBaptiste Daroussin flags & UCL_STRING_PARSE_BYTES, 211697bd480fSBaptiste Daroussin flags & UCL_STRING_PARSE_TIME); 2117c99fb5f9SBaptiste Daroussin } 2118c99fb5f9SBaptiste Daroussin } 2119c99fb5f9SBaptiste Daroussin } 2120c99fb5f9SBaptiste Daroussin 2121c99fb5f9SBaptiste Daroussin return obj; 2122c99fb5f9SBaptiste Daroussin } 2123c99fb5f9SBaptiste Daroussin 2124b04a7a0bSBaptiste Daroussin static bool 2125c99fb5f9SBaptiste Daroussin ucl_object_insert_key_common (ucl_object_t *top, ucl_object_t *elt, 2126c99fb5f9SBaptiste Daroussin const char *key, size_t keylen, bool copy_key, bool merge, bool replace) 2127c99fb5f9SBaptiste Daroussin { 2128b04a7a0bSBaptiste Daroussin ucl_object_t *found, *tmp; 2129b04a7a0bSBaptiste Daroussin const ucl_object_t *cur; 2130c99fb5f9SBaptiste Daroussin ucl_object_iter_t it = NULL; 2131c99fb5f9SBaptiste Daroussin const char *p; 2132b04a7a0bSBaptiste Daroussin int ret = true; 2133c99fb5f9SBaptiste Daroussin 2134c99fb5f9SBaptiste Daroussin if (elt == NULL || key == NULL) { 2135b04a7a0bSBaptiste Daroussin return false; 2136c99fb5f9SBaptiste Daroussin } 2137c99fb5f9SBaptiste Daroussin 2138c99fb5f9SBaptiste Daroussin if (top == NULL) { 2139b04a7a0bSBaptiste Daroussin return false; 2140c99fb5f9SBaptiste Daroussin } 2141c99fb5f9SBaptiste Daroussin 2142c99fb5f9SBaptiste Daroussin if (top->type != UCL_OBJECT) { 2143c99fb5f9SBaptiste Daroussin /* It is possible to convert NULL type to an object */ 2144c99fb5f9SBaptiste Daroussin if (top->type == UCL_NULL) { 2145c99fb5f9SBaptiste Daroussin top->type = UCL_OBJECT; 2146c99fb5f9SBaptiste Daroussin } 2147c99fb5f9SBaptiste Daroussin else { 2148c99fb5f9SBaptiste Daroussin /* Refuse converting of other object types */ 2149b04a7a0bSBaptiste Daroussin return false; 2150c99fb5f9SBaptiste Daroussin } 2151c99fb5f9SBaptiste Daroussin } 2152c99fb5f9SBaptiste Daroussin 2153c99fb5f9SBaptiste Daroussin if (top->value.ov == NULL) { 21548e3b1ab2SBaptiste Daroussin top->value.ov = ucl_hash_create (false); 2155c99fb5f9SBaptiste Daroussin } 2156c99fb5f9SBaptiste Daroussin 2157c99fb5f9SBaptiste Daroussin if (keylen == 0) { 2158c99fb5f9SBaptiste Daroussin keylen = strlen (key); 2159c99fb5f9SBaptiste Daroussin } 2160c99fb5f9SBaptiste Daroussin 2161c99fb5f9SBaptiste Daroussin for (p = key; p < key + keylen; p ++) { 2162c99fb5f9SBaptiste Daroussin if (ucl_test_character (*p, UCL_CHARACTER_UCL_UNSAFE)) { 2163c99fb5f9SBaptiste Daroussin elt->flags |= UCL_OBJECT_NEED_KEY_ESCAPE; 2164c99fb5f9SBaptiste Daroussin break; 2165c99fb5f9SBaptiste Daroussin } 2166c99fb5f9SBaptiste Daroussin } 2167c99fb5f9SBaptiste Daroussin 21684bf54857SBaptiste Daroussin /* workaround for some use cases */ 21694bf54857SBaptiste Daroussin if (elt->trash_stack[UCL_TRASH_KEY] != NULL && 21704bf54857SBaptiste Daroussin key != (const char *)elt->trash_stack[UCL_TRASH_KEY]) { 21714bf54857SBaptiste Daroussin /* Remove copied key */ 21724bf54857SBaptiste Daroussin free (elt->trash_stack[UCL_TRASH_KEY]); 21734bf54857SBaptiste Daroussin elt->trash_stack[UCL_TRASH_KEY] = NULL; 21744bf54857SBaptiste Daroussin elt->flags &= ~UCL_OBJECT_ALLOCATED_KEY; 21754bf54857SBaptiste Daroussin } 21764bf54857SBaptiste Daroussin 2177c99fb5f9SBaptiste Daroussin elt->key = key; 2178c99fb5f9SBaptiste Daroussin elt->keylen = keylen; 2179c99fb5f9SBaptiste Daroussin 2180c99fb5f9SBaptiste Daroussin if (copy_key) { 2181c99fb5f9SBaptiste Daroussin ucl_copy_key_trash (elt); 2182c99fb5f9SBaptiste Daroussin } 2183c99fb5f9SBaptiste Daroussin 2184b04a7a0bSBaptiste Daroussin found = __DECONST (ucl_object_t *, ucl_hash_search_obj (top->value.ov, elt)); 2185c99fb5f9SBaptiste Daroussin 21864bf54857SBaptiste Daroussin if (found == NULL) { 21878e3b1ab2SBaptiste Daroussin top->value.ov = ucl_hash_insert_object (top->value.ov, elt, false); 218897bd480fSBaptiste Daroussin top->len ++; 2189b04a7a0bSBaptiste Daroussin if (replace) { 2190b04a7a0bSBaptiste Daroussin ret = false; 2191b04a7a0bSBaptiste Daroussin } 2192c99fb5f9SBaptiste Daroussin } 2193c99fb5f9SBaptiste Daroussin else { 2194c99fb5f9SBaptiste Daroussin if (replace) { 21954bf54857SBaptiste Daroussin ucl_hash_replace (top->value.ov, found, elt); 2196c99fb5f9SBaptiste Daroussin ucl_object_unref (found); 2197c99fb5f9SBaptiste Daroussin } 2198c99fb5f9SBaptiste Daroussin else if (merge) { 2199c99fb5f9SBaptiste Daroussin if (found->type != UCL_OBJECT && elt->type == UCL_OBJECT) { 2200c99fb5f9SBaptiste Daroussin /* Insert old elt to new one */ 2201b04a7a0bSBaptiste Daroussin ucl_object_insert_key_common (elt, found, found->key, 2202b04a7a0bSBaptiste Daroussin found->keylen, copy_key, false, false); 2203c99fb5f9SBaptiste Daroussin ucl_hash_delete (top->value.ov, found); 22048e3b1ab2SBaptiste Daroussin top->value.ov = ucl_hash_insert_object (top->value.ov, elt, false); 2205c99fb5f9SBaptiste Daroussin } 2206c99fb5f9SBaptiste Daroussin else if (found->type == UCL_OBJECT && elt->type != UCL_OBJECT) { 2207c99fb5f9SBaptiste Daroussin /* Insert new to old */ 2208b04a7a0bSBaptiste Daroussin ucl_object_insert_key_common (found, elt, elt->key, 2209b04a7a0bSBaptiste Daroussin elt->keylen, copy_key, false, false); 2210c99fb5f9SBaptiste Daroussin } 2211c99fb5f9SBaptiste Daroussin else if (found->type == UCL_OBJECT && elt->type == UCL_OBJECT) { 2212c99fb5f9SBaptiste Daroussin /* Mix two hashes */ 2213d9f0ce31SBaptiste Daroussin while ((cur = ucl_object_iterate (elt, &it, true)) != NULL) { 2214b04a7a0bSBaptiste Daroussin tmp = ucl_object_ref (cur); 2215b04a7a0bSBaptiste Daroussin ucl_object_insert_key_common (found, tmp, cur->key, 2216b04a7a0bSBaptiste Daroussin cur->keylen, copy_key, false, false); 2217c99fb5f9SBaptiste Daroussin } 2218c99fb5f9SBaptiste Daroussin ucl_object_unref (elt); 2219c99fb5f9SBaptiste Daroussin } 2220c99fb5f9SBaptiste Daroussin else { 2221c99fb5f9SBaptiste Daroussin /* Just make a list of scalars */ 2222c99fb5f9SBaptiste Daroussin DL_APPEND (found, elt); 2223c99fb5f9SBaptiste Daroussin } 2224c99fb5f9SBaptiste Daroussin } 2225c99fb5f9SBaptiste Daroussin else { 2226c99fb5f9SBaptiste Daroussin DL_APPEND (found, elt); 2227c99fb5f9SBaptiste Daroussin } 2228c99fb5f9SBaptiste Daroussin } 2229c99fb5f9SBaptiste Daroussin 2230b04a7a0bSBaptiste Daroussin return ret; 2231c99fb5f9SBaptiste Daroussin } 2232c99fb5f9SBaptiste Daroussin 223336c53d67SBaptiste Daroussin bool 223436c53d67SBaptiste Daroussin ucl_object_delete_keyl (ucl_object_t *top, const char *key, size_t keylen) 223536c53d67SBaptiste Daroussin { 223636c53d67SBaptiste Daroussin ucl_object_t *found; 223736c53d67SBaptiste Daroussin 223897bd480fSBaptiste Daroussin if (top == NULL || key == NULL) { 223997bd480fSBaptiste Daroussin return false; 224097bd480fSBaptiste Daroussin } 224197bd480fSBaptiste Daroussin 2242d9f0ce31SBaptiste Daroussin found = __DECONST (ucl_object_t *, ucl_object_lookup_len (top, key, keylen)); 224336c53d67SBaptiste Daroussin 224497bd480fSBaptiste Daroussin if (found == NULL) { 224536c53d67SBaptiste Daroussin return false; 224697bd480fSBaptiste Daroussin } 224736c53d67SBaptiste Daroussin 224836c53d67SBaptiste Daroussin ucl_hash_delete (top->value.ov, found); 224936c53d67SBaptiste Daroussin ucl_object_unref (found); 225036c53d67SBaptiste Daroussin top->len --; 225136c53d67SBaptiste Daroussin 225236c53d67SBaptiste Daroussin return true; 225336c53d67SBaptiste Daroussin } 225436c53d67SBaptiste Daroussin 225536c53d67SBaptiste Daroussin bool 225636c53d67SBaptiste Daroussin ucl_object_delete_key (ucl_object_t *top, const char *key) 225736c53d67SBaptiste Daroussin { 2258b04a7a0bSBaptiste Daroussin return ucl_object_delete_keyl (top, key, strlen (key)); 225936c53d67SBaptiste Daroussin } 226036c53d67SBaptiste Daroussin 2261c99fb5f9SBaptiste Daroussin ucl_object_t* 226297bd480fSBaptiste Daroussin ucl_object_pop_keyl (ucl_object_t *top, const char *key, size_t keylen) 226397bd480fSBaptiste Daroussin { 2264b04a7a0bSBaptiste Daroussin const ucl_object_t *found; 226597bd480fSBaptiste Daroussin 226697bd480fSBaptiste Daroussin if (top == NULL || key == NULL) { 226797bd480fSBaptiste Daroussin return false; 226897bd480fSBaptiste Daroussin } 2269d9f0ce31SBaptiste Daroussin found = ucl_object_lookup_len (top, key, keylen); 227097bd480fSBaptiste Daroussin 227197bd480fSBaptiste Daroussin if (found == NULL) { 227297bd480fSBaptiste Daroussin return NULL; 227397bd480fSBaptiste Daroussin } 227497bd480fSBaptiste Daroussin ucl_hash_delete (top->value.ov, found); 227597bd480fSBaptiste Daroussin top->len --; 227697bd480fSBaptiste Daroussin 2277b04a7a0bSBaptiste Daroussin return __DECONST (ucl_object_t *, found); 227897bd480fSBaptiste Daroussin } 227997bd480fSBaptiste Daroussin 228097bd480fSBaptiste Daroussin ucl_object_t* 228197bd480fSBaptiste Daroussin ucl_object_pop_key (ucl_object_t *top, const char *key) 228297bd480fSBaptiste Daroussin { 2283b04a7a0bSBaptiste Daroussin return ucl_object_pop_keyl (top, key, strlen (key)); 228497bd480fSBaptiste Daroussin } 228597bd480fSBaptiste Daroussin 2286b04a7a0bSBaptiste Daroussin bool 2287c99fb5f9SBaptiste Daroussin ucl_object_insert_key (ucl_object_t *top, ucl_object_t *elt, 2288c99fb5f9SBaptiste Daroussin const char *key, size_t keylen, bool copy_key) 2289c99fb5f9SBaptiste Daroussin { 2290c99fb5f9SBaptiste Daroussin return ucl_object_insert_key_common (top, elt, key, keylen, copy_key, false, false); 2291c99fb5f9SBaptiste Daroussin } 2292c99fb5f9SBaptiste Daroussin 2293b04a7a0bSBaptiste Daroussin bool 2294c99fb5f9SBaptiste Daroussin ucl_object_insert_key_merged (ucl_object_t *top, ucl_object_t *elt, 2295c99fb5f9SBaptiste Daroussin const char *key, size_t keylen, bool copy_key) 2296c99fb5f9SBaptiste Daroussin { 2297c99fb5f9SBaptiste Daroussin return ucl_object_insert_key_common (top, elt, key, keylen, copy_key, true, false); 2298c99fb5f9SBaptiste Daroussin } 2299c99fb5f9SBaptiste Daroussin 2300b04a7a0bSBaptiste Daroussin bool 2301c99fb5f9SBaptiste Daroussin ucl_object_replace_key (ucl_object_t *top, ucl_object_t *elt, 2302c99fb5f9SBaptiste Daroussin const char *key, size_t keylen, bool copy_key) 2303c99fb5f9SBaptiste Daroussin { 2304c99fb5f9SBaptiste Daroussin return ucl_object_insert_key_common (top, elt, key, keylen, copy_key, false, true); 2305c99fb5f9SBaptiste Daroussin } 2306c99fb5f9SBaptiste Daroussin 23074bf54857SBaptiste Daroussin bool 23084bf54857SBaptiste Daroussin ucl_object_merge (ucl_object_t *top, ucl_object_t *elt, bool copy) 23094bf54857SBaptiste Daroussin { 23104bf54857SBaptiste Daroussin ucl_object_t *cur = NULL, *cp = NULL, *found = NULL; 23114bf54857SBaptiste Daroussin ucl_object_iter_t iter = NULL; 23124bf54857SBaptiste Daroussin 23134bf54857SBaptiste Daroussin if (top == NULL || top->type != UCL_OBJECT || elt == NULL || elt->type != UCL_OBJECT) { 23144bf54857SBaptiste Daroussin return false; 23154bf54857SBaptiste Daroussin } 23164bf54857SBaptiste Daroussin 23174bf54857SBaptiste Daroussin /* Mix two hashes */ 23184bf54857SBaptiste Daroussin while ((cur = (ucl_object_t*)ucl_hash_iterate (elt->value.ov, &iter))) { 23194bf54857SBaptiste Daroussin if (copy) { 23204bf54857SBaptiste Daroussin cp = ucl_object_copy (cur); 23214bf54857SBaptiste Daroussin } 23224bf54857SBaptiste Daroussin else { 23234bf54857SBaptiste Daroussin cp = ucl_object_ref (cur); 23244bf54857SBaptiste Daroussin } 23254bf54857SBaptiste Daroussin found = __DECONST(ucl_object_t *, ucl_hash_search (top->value.ov, cp->key, cp->keylen)); 23264bf54857SBaptiste Daroussin if (found == NULL) { 23274bf54857SBaptiste Daroussin /* The key does not exist */ 23288e3b1ab2SBaptiste Daroussin top->value.ov = ucl_hash_insert_object (top->value.ov, cp, false); 23294bf54857SBaptiste Daroussin top->len ++; 23304bf54857SBaptiste Daroussin } 23314bf54857SBaptiste Daroussin else { 23324bf54857SBaptiste Daroussin /* The key already exists, replace it */ 23334bf54857SBaptiste Daroussin ucl_hash_replace (top->value.ov, found, cp); 23344bf54857SBaptiste Daroussin ucl_object_unref (found); 23354bf54857SBaptiste Daroussin } 23364bf54857SBaptiste Daroussin } 23374bf54857SBaptiste Daroussin 23384bf54857SBaptiste Daroussin return true; 23394bf54857SBaptiste Daroussin } 23404bf54857SBaptiste Daroussin 2341b04a7a0bSBaptiste Daroussin const ucl_object_t * 2342d9f0ce31SBaptiste Daroussin ucl_object_lookup_len (const ucl_object_t *obj, const char *key, size_t klen) 2343c99fb5f9SBaptiste Daroussin { 2344b04a7a0bSBaptiste Daroussin const ucl_object_t *ret; 2345b04a7a0bSBaptiste Daroussin ucl_object_t srch; 2346c99fb5f9SBaptiste Daroussin 2347c99fb5f9SBaptiste Daroussin if (obj == NULL || obj->type != UCL_OBJECT || key == NULL) { 2348c99fb5f9SBaptiste Daroussin return NULL; 2349c99fb5f9SBaptiste Daroussin } 2350c99fb5f9SBaptiste Daroussin 2351c99fb5f9SBaptiste Daroussin srch.key = key; 2352c99fb5f9SBaptiste Daroussin srch.keylen = klen; 2353c99fb5f9SBaptiste Daroussin ret = ucl_hash_search_obj (obj->value.ov, &srch); 2354c99fb5f9SBaptiste Daroussin 2355c99fb5f9SBaptiste Daroussin return ret; 2356c99fb5f9SBaptiste Daroussin } 2357c99fb5f9SBaptiste Daroussin 2358b04a7a0bSBaptiste Daroussin const ucl_object_t * 2359d9f0ce31SBaptiste Daroussin ucl_object_lookup (const ucl_object_t *obj, const char *key) 2360c99fb5f9SBaptiste Daroussin { 236139ee7a7aSBaptiste Daroussin if (key == NULL) { 2362c99fb5f9SBaptiste Daroussin return NULL; 236339ee7a7aSBaptiste Daroussin } 2364c99fb5f9SBaptiste Daroussin 2365d9f0ce31SBaptiste Daroussin return ucl_object_lookup_len (obj, key, strlen (key)); 2366c99fb5f9SBaptiste Daroussin } 2367c99fb5f9SBaptiste Daroussin 2368b04a7a0bSBaptiste Daroussin const ucl_object_t* 2369d9f0ce31SBaptiste Daroussin ucl_object_lookup_any (const ucl_object_t *obj, 237039ee7a7aSBaptiste Daroussin const char *key, ...) 237139ee7a7aSBaptiste Daroussin { 237239ee7a7aSBaptiste Daroussin va_list ap; 237339ee7a7aSBaptiste Daroussin const ucl_object_t *ret = NULL; 237439ee7a7aSBaptiste Daroussin const char *nk = NULL; 237539ee7a7aSBaptiste Daroussin 237639ee7a7aSBaptiste Daroussin if (obj == NULL || key == NULL) { 237739ee7a7aSBaptiste Daroussin return NULL; 237839ee7a7aSBaptiste Daroussin } 237939ee7a7aSBaptiste Daroussin 2380d9f0ce31SBaptiste Daroussin ret = ucl_object_lookup_len (obj, key, strlen (key)); 238139ee7a7aSBaptiste Daroussin 238239ee7a7aSBaptiste Daroussin if (ret == NULL) { 238339ee7a7aSBaptiste Daroussin va_start (ap, key); 238439ee7a7aSBaptiste Daroussin 238539ee7a7aSBaptiste Daroussin while (ret == NULL) { 238639ee7a7aSBaptiste Daroussin nk = va_arg (ap, const char *); 238739ee7a7aSBaptiste Daroussin 238839ee7a7aSBaptiste Daroussin if (nk == NULL) { 238939ee7a7aSBaptiste Daroussin break; 239039ee7a7aSBaptiste Daroussin } 239139ee7a7aSBaptiste Daroussin else { 2392d9f0ce31SBaptiste Daroussin ret = ucl_object_lookup_len (obj, nk, strlen (nk)); 239339ee7a7aSBaptiste Daroussin } 239439ee7a7aSBaptiste Daroussin } 239539ee7a7aSBaptiste Daroussin 239639ee7a7aSBaptiste Daroussin va_end (ap); 239739ee7a7aSBaptiste Daroussin } 239839ee7a7aSBaptiste Daroussin 239939ee7a7aSBaptiste Daroussin return ret; 240039ee7a7aSBaptiste Daroussin } 240139ee7a7aSBaptiste Daroussin 240239ee7a7aSBaptiste Daroussin const ucl_object_t* 2403d9f0ce31SBaptiste Daroussin ucl_object_iterate (const ucl_object_t *obj, ucl_object_iter_t *iter, bool expand_values) 2404c99fb5f9SBaptiste Daroussin { 24058e3b1ab2SBaptiste Daroussin const ucl_object_t *elt = NULL; 2406c99fb5f9SBaptiste Daroussin 240797bd480fSBaptiste Daroussin if (obj == NULL || iter == NULL) { 240897bd480fSBaptiste Daroussin return NULL; 240997bd480fSBaptiste Daroussin } 241097bd480fSBaptiste Daroussin 2411c99fb5f9SBaptiste Daroussin if (expand_values) { 2412c99fb5f9SBaptiste Daroussin switch (obj->type) { 2413c99fb5f9SBaptiste Daroussin case UCL_OBJECT: 2414b04a7a0bSBaptiste Daroussin return (const ucl_object_t*)ucl_hash_iterate (obj->value.ov, iter); 2415c99fb5f9SBaptiste Daroussin break; 24168e3b1ab2SBaptiste Daroussin case UCL_ARRAY: { 24178e3b1ab2SBaptiste Daroussin unsigned int idx; 24188e3b1ab2SBaptiste Daroussin UCL_ARRAY_GET (vec, obj); 24198e3b1ab2SBaptiste Daroussin idx = (unsigned int)(uintptr_t)(*iter); 24208e3b1ab2SBaptiste Daroussin 24218e3b1ab2SBaptiste Daroussin if (vec != NULL) { 24228e3b1ab2SBaptiste Daroussin while (idx < kv_size (*vec)) { 24238e3b1ab2SBaptiste Daroussin if ((elt = kv_A (*vec, idx)) != NULL) { 24248e3b1ab2SBaptiste Daroussin idx ++; 24258e3b1ab2SBaptiste Daroussin break; 2426c99fb5f9SBaptiste Daroussin } 24278e3b1ab2SBaptiste Daroussin idx ++; 2428c99fb5f9SBaptiste Daroussin } 24298e3b1ab2SBaptiste Daroussin *iter = (void *)(uintptr_t)idx; 2430c99fb5f9SBaptiste Daroussin } 24318e3b1ab2SBaptiste Daroussin 2432c99fb5f9SBaptiste Daroussin return elt; 24338e3b1ab2SBaptiste Daroussin break; 24348e3b1ab2SBaptiste Daroussin } 2435c99fb5f9SBaptiste Daroussin default: 2436c99fb5f9SBaptiste Daroussin /* Go to linear iteration */ 2437c99fb5f9SBaptiste Daroussin break; 2438c99fb5f9SBaptiste Daroussin } 2439c99fb5f9SBaptiste Daroussin } 2440c99fb5f9SBaptiste Daroussin /* Treat everything as a linear list */ 2441c99fb5f9SBaptiste Daroussin elt = *iter; 2442c99fb5f9SBaptiste Daroussin if (elt == NULL) { 2443c99fb5f9SBaptiste Daroussin elt = obj; 2444c99fb5f9SBaptiste Daroussin } 2445c99fb5f9SBaptiste Daroussin else if (elt == obj) { 2446c99fb5f9SBaptiste Daroussin return NULL; 2447c99fb5f9SBaptiste Daroussin } 2448b04a7a0bSBaptiste Daroussin *iter = __DECONST (void *, elt->next ? elt->next : obj); 2449c99fb5f9SBaptiste Daroussin return elt; 2450c99fb5f9SBaptiste Daroussin 2451c99fb5f9SBaptiste Daroussin /* Not reached */ 2452c99fb5f9SBaptiste Daroussin return NULL; 2453c99fb5f9SBaptiste Daroussin } 245497bd480fSBaptiste Daroussin 24558e3b1ab2SBaptiste Daroussin const char safe_iter_magic[4] = {'u', 'i', 't', 'e'}; 24568e3b1ab2SBaptiste Daroussin struct ucl_object_safe_iter { 24578e3b1ab2SBaptiste Daroussin char magic[4]; /* safety check */ 24588e3b1ab2SBaptiste Daroussin const ucl_object_t *impl_it; /* implicit object iteration */ 24598e3b1ab2SBaptiste Daroussin ucl_object_iter_t expl_it; /* explicit iteration */ 24608e3b1ab2SBaptiste Daroussin }; 24618e3b1ab2SBaptiste Daroussin 24628e3b1ab2SBaptiste Daroussin #define UCL_SAFE_ITER(ptr) (struct ucl_object_safe_iter *)(ptr) 24638e3b1ab2SBaptiste Daroussin #define UCL_SAFE_ITER_CHECK(it) do { \ 24648e3b1ab2SBaptiste Daroussin assert (it != NULL); \ 24658e3b1ab2SBaptiste Daroussin assert (memcmp (it->magic, safe_iter_magic, sizeof (it->magic)) == 0); \ 24668e3b1ab2SBaptiste Daroussin } while (0) 24678e3b1ab2SBaptiste Daroussin 24688e3b1ab2SBaptiste Daroussin ucl_object_iter_t 24698e3b1ab2SBaptiste Daroussin ucl_object_iterate_new (const ucl_object_t *obj) 24708e3b1ab2SBaptiste Daroussin { 24718e3b1ab2SBaptiste Daroussin struct ucl_object_safe_iter *it; 24728e3b1ab2SBaptiste Daroussin 24738e3b1ab2SBaptiste Daroussin it = UCL_ALLOC (sizeof (*it)); 24748e3b1ab2SBaptiste Daroussin if (it != NULL) { 24758e3b1ab2SBaptiste Daroussin memcpy (it->magic, safe_iter_magic, sizeof (it->magic)); 24768e3b1ab2SBaptiste Daroussin it->expl_it = NULL; 24778e3b1ab2SBaptiste Daroussin it->impl_it = obj; 24788e3b1ab2SBaptiste Daroussin } 24798e3b1ab2SBaptiste Daroussin 24808e3b1ab2SBaptiste Daroussin return (ucl_object_iter_t)it; 24818e3b1ab2SBaptiste Daroussin } 24828e3b1ab2SBaptiste Daroussin 24838e3b1ab2SBaptiste Daroussin 24848e3b1ab2SBaptiste Daroussin ucl_object_iter_t 24858e3b1ab2SBaptiste Daroussin ucl_object_iterate_reset (ucl_object_iter_t it, const ucl_object_t *obj) 24868e3b1ab2SBaptiste Daroussin { 24878e3b1ab2SBaptiste Daroussin struct ucl_object_safe_iter *rit = UCL_SAFE_ITER (it); 24888e3b1ab2SBaptiste Daroussin 24898e3b1ab2SBaptiste Daroussin UCL_SAFE_ITER_CHECK (rit); 24908e3b1ab2SBaptiste Daroussin 24918e3b1ab2SBaptiste Daroussin rit->impl_it = obj; 24928e3b1ab2SBaptiste Daroussin rit->expl_it = NULL; 24938e3b1ab2SBaptiste Daroussin 24948e3b1ab2SBaptiste Daroussin return it; 24958e3b1ab2SBaptiste Daroussin } 24968e3b1ab2SBaptiste Daroussin 24978e3b1ab2SBaptiste Daroussin const ucl_object_t* 24988e3b1ab2SBaptiste Daroussin ucl_object_iterate_safe (ucl_object_iter_t it, bool expand_values) 24998e3b1ab2SBaptiste Daroussin { 25008e3b1ab2SBaptiste Daroussin struct ucl_object_safe_iter *rit = UCL_SAFE_ITER (it); 25018e3b1ab2SBaptiste Daroussin const ucl_object_t *ret = NULL; 25028e3b1ab2SBaptiste Daroussin 25038e3b1ab2SBaptiste Daroussin UCL_SAFE_ITER_CHECK (rit); 25048e3b1ab2SBaptiste Daroussin 25058e3b1ab2SBaptiste Daroussin if (rit->impl_it == NULL) { 25068e3b1ab2SBaptiste Daroussin return NULL; 25078e3b1ab2SBaptiste Daroussin } 25088e3b1ab2SBaptiste Daroussin 25098e3b1ab2SBaptiste Daroussin if (rit->impl_it->type == UCL_OBJECT || rit->impl_it->type == UCL_ARRAY) { 2510d9f0ce31SBaptiste Daroussin ret = ucl_object_iterate (rit->impl_it, &rit->expl_it, true); 25118e3b1ab2SBaptiste Daroussin 25128e3b1ab2SBaptiste Daroussin if (ret == NULL) { 25138e3b1ab2SBaptiste Daroussin /* Need to switch to another implicit object in chain */ 25148e3b1ab2SBaptiste Daroussin rit->impl_it = rit->impl_it->next; 25158e3b1ab2SBaptiste Daroussin rit->expl_it = NULL; 25168e3b1ab2SBaptiste Daroussin return ucl_object_iterate_safe (it, expand_values); 25178e3b1ab2SBaptiste Daroussin } 25188e3b1ab2SBaptiste Daroussin } 25198e3b1ab2SBaptiste Daroussin else { 25208e3b1ab2SBaptiste Daroussin /* Just iterate over the implicit array */ 25218e3b1ab2SBaptiste Daroussin ret = rit->impl_it; 25228e3b1ab2SBaptiste Daroussin rit->impl_it = rit->impl_it->next; 25238e3b1ab2SBaptiste Daroussin if (expand_values) { 25248e3b1ab2SBaptiste Daroussin /* We flatten objects if need to expand values */ 25258e3b1ab2SBaptiste Daroussin if (ret->type == UCL_OBJECT || ret->type == UCL_ARRAY) { 25268e3b1ab2SBaptiste Daroussin return ucl_object_iterate_safe (it, expand_values); 25278e3b1ab2SBaptiste Daroussin } 25288e3b1ab2SBaptiste Daroussin } 25298e3b1ab2SBaptiste Daroussin } 25308e3b1ab2SBaptiste Daroussin 25318e3b1ab2SBaptiste Daroussin return ret; 25328e3b1ab2SBaptiste Daroussin } 25338e3b1ab2SBaptiste Daroussin 25348e3b1ab2SBaptiste Daroussin void 25358e3b1ab2SBaptiste Daroussin ucl_object_iterate_free (ucl_object_iter_t it) 25368e3b1ab2SBaptiste Daroussin { 25378e3b1ab2SBaptiste Daroussin struct ucl_object_safe_iter *rit = UCL_SAFE_ITER (it); 25388e3b1ab2SBaptiste Daroussin 25398e3b1ab2SBaptiste Daroussin UCL_SAFE_ITER_CHECK (rit); 25408e3b1ab2SBaptiste Daroussin 25418e3b1ab2SBaptiste Daroussin UCL_FREE (sizeof (*rit), it); 25428e3b1ab2SBaptiste Daroussin } 25438e3b1ab2SBaptiste Daroussin 25442e8ed2b8SBaptiste Daroussin const ucl_object_t * 2545d9f0ce31SBaptiste Daroussin ucl_object_lookup_path (const ucl_object_t *top, const char *path_in) { 2546d9f0ce31SBaptiste Daroussin return ucl_object_lookup_path_char (top, path_in, '.'); 254739ee7a7aSBaptiste Daroussin } 254839ee7a7aSBaptiste Daroussin 254939ee7a7aSBaptiste Daroussin 255039ee7a7aSBaptiste Daroussin const ucl_object_t * 2551d9f0ce31SBaptiste Daroussin ucl_object_lookup_path_char (const ucl_object_t *top, const char *path_in, const char sep) { 25522e8ed2b8SBaptiste Daroussin const ucl_object_t *o = NULL, *found; 25532e8ed2b8SBaptiste Daroussin const char *p, *c; 25542e8ed2b8SBaptiste Daroussin char *err_str; 25552e8ed2b8SBaptiste Daroussin unsigned index; 25562e8ed2b8SBaptiste Daroussin 25572e8ed2b8SBaptiste Daroussin if (path_in == NULL || top == NULL) { 25582e8ed2b8SBaptiste Daroussin return NULL; 25592e8ed2b8SBaptiste Daroussin } 25602e8ed2b8SBaptiste Daroussin 25612e8ed2b8SBaptiste Daroussin found = NULL; 25622e8ed2b8SBaptiste Daroussin p = path_in; 25632e8ed2b8SBaptiste Daroussin 25642e8ed2b8SBaptiste Daroussin /* Skip leading dots */ 256539ee7a7aSBaptiste Daroussin while (*p == sep) { 25662e8ed2b8SBaptiste Daroussin p ++; 25672e8ed2b8SBaptiste Daroussin } 25682e8ed2b8SBaptiste Daroussin 25692e8ed2b8SBaptiste Daroussin c = p; 25702e8ed2b8SBaptiste Daroussin while (*p != '\0') { 25712e8ed2b8SBaptiste Daroussin p ++; 257239ee7a7aSBaptiste Daroussin if (*p == sep || *p == '\0') { 25732e8ed2b8SBaptiste Daroussin if (p > c) { 25742e8ed2b8SBaptiste Daroussin switch (top->type) { 25752e8ed2b8SBaptiste Daroussin case UCL_ARRAY: 25762e8ed2b8SBaptiste Daroussin /* Key should be an int */ 25772e8ed2b8SBaptiste Daroussin index = strtoul (c, &err_str, 10); 257839ee7a7aSBaptiste Daroussin if (err_str != NULL && (*err_str != sep && *err_str != '\0')) { 25792e8ed2b8SBaptiste Daroussin return NULL; 25802e8ed2b8SBaptiste Daroussin } 25812e8ed2b8SBaptiste Daroussin o = ucl_array_find_index (top, index); 25822e8ed2b8SBaptiste Daroussin break; 25832e8ed2b8SBaptiste Daroussin default: 2584d9f0ce31SBaptiste Daroussin o = ucl_object_lookup_len (top, c, p - c); 25852e8ed2b8SBaptiste Daroussin break; 25862e8ed2b8SBaptiste Daroussin } 25872e8ed2b8SBaptiste Daroussin if (o == NULL) { 25882e8ed2b8SBaptiste Daroussin return NULL; 25892e8ed2b8SBaptiste Daroussin } 25902e8ed2b8SBaptiste Daroussin top = o; 25912e8ed2b8SBaptiste Daroussin } 25922e8ed2b8SBaptiste Daroussin if (*p != '\0') { 25932e8ed2b8SBaptiste Daroussin c = p + 1; 25942e8ed2b8SBaptiste Daroussin } 25952e8ed2b8SBaptiste Daroussin } 25962e8ed2b8SBaptiste Daroussin } 25972e8ed2b8SBaptiste Daroussin found = o; 25982e8ed2b8SBaptiste Daroussin 25992e8ed2b8SBaptiste Daroussin return found; 26002e8ed2b8SBaptiste Daroussin } 26012e8ed2b8SBaptiste Daroussin 260297bd480fSBaptiste Daroussin 260397bd480fSBaptiste Daroussin ucl_object_t * 260497bd480fSBaptiste Daroussin ucl_object_new (void) 260597bd480fSBaptiste Daroussin { 26064bf54857SBaptiste Daroussin return ucl_object_typed_new (UCL_NULL); 260797bd480fSBaptiste Daroussin } 260897bd480fSBaptiste Daroussin 260997bd480fSBaptiste Daroussin ucl_object_t * 26102e8ed2b8SBaptiste Daroussin ucl_object_typed_new (ucl_type_t type) 261197bd480fSBaptiste Daroussin { 26124bf54857SBaptiste Daroussin return ucl_object_new_full (type, 0); 26134bf54857SBaptiste Daroussin } 26144bf54857SBaptiste Daroussin 26154bf54857SBaptiste Daroussin ucl_object_t * 26164bf54857SBaptiste Daroussin ucl_object_new_full (ucl_type_t type, unsigned priority) 26174bf54857SBaptiste Daroussin { 261897bd480fSBaptiste Daroussin ucl_object_t *new; 26194bf54857SBaptiste Daroussin 26204bf54857SBaptiste Daroussin if (type != UCL_USERDATA) { 26214bf54857SBaptiste Daroussin new = UCL_ALLOC (sizeof (ucl_object_t)); 262297bd480fSBaptiste Daroussin if (new != NULL) { 262397bd480fSBaptiste Daroussin memset (new, 0, sizeof (ucl_object_t)); 262497bd480fSBaptiste Daroussin new->ref = 1; 262597bd480fSBaptiste Daroussin new->type = (type <= UCL_NULL ? type : UCL_NULL); 26264bf54857SBaptiste Daroussin new->next = NULL; 26274bf54857SBaptiste Daroussin new->prev = new; 26284bf54857SBaptiste Daroussin ucl_object_set_priority (new, priority); 26298e3b1ab2SBaptiste Daroussin 26308e3b1ab2SBaptiste Daroussin if (type == UCL_ARRAY) { 26318e3b1ab2SBaptiste Daroussin new->value.av = UCL_ALLOC (sizeof (ucl_array_t)); 26328e3b1ab2SBaptiste Daroussin if (new->value.av) { 26338e3b1ab2SBaptiste Daroussin memset (new->value.av, 0, sizeof (ucl_array_t)); 26348e3b1ab2SBaptiste Daroussin UCL_ARRAY_GET (vec, new); 26358e3b1ab2SBaptiste Daroussin 26368e3b1ab2SBaptiste Daroussin /* Preallocate some space for arrays */ 26378e3b1ab2SBaptiste Daroussin kv_resize (ucl_object_t *, *vec, 8); 26388e3b1ab2SBaptiste Daroussin } 26398e3b1ab2SBaptiste Daroussin } 264097bd480fSBaptiste Daroussin } 26414bf54857SBaptiste Daroussin } 26424bf54857SBaptiste Daroussin else { 2643d9f0ce31SBaptiste Daroussin new = ucl_object_new_userdata (NULL, NULL, NULL); 26444bf54857SBaptiste Daroussin ucl_object_set_priority (new, priority); 26454bf54857SBaptiste Daroussin } 26464bf54857SBaptiste Daroussin 264797bd480fSBaptiste Daroussin return new; 264897bd480fSBaptiste Daroussin } 264997bd480fSBaptiste Daroussin 26504bf54857SBaptiste Daroussin ucl_object_t* 2651d9f0ce31SBaptiste Daroussin ucl_object_new_userdata (ucl_userdata_dtor dtor, 2652d9f0ce31SBaptiste Daroussin ucl_userdata_emitter emitter, 2653d9f0ce31SBaptiste Daroussin void *ptr) 26544bf54857SBaptiste Daroussin { 26554bf54857SBaptiste Daroussin struct ucl_object_userdata *new; 26564bf54857SBaptiste Daroussin size_t nsize = sizeof (*new); 26574bf54857SBaptiste Daroussin 26584bf54857SBaptiste Daroussin new = UCL_ALLOC (nsize); 26594bf54857SBaptiste Daroussin if (new != NULL) { 26604bf54857SBaptiste Daroussin memset (new, 0, nsize); 26614bf54857SBaptiste Daroussin new->obj.ref = 1; 26624bf54857SBaptiste Daroussin new->obj.type = UCL_USERDATA; 26634bf54857SBaptiste Daroussin new->obj.next = NULL; 26644bf54857SBaptiste Daroussin new->obj.prev = (ucl_object_t *)new; 26654bf54857SBaptiste Daroussin new->dtor = dtor; 26664bf54857SBaptiste Daroussin new->emitter = emitter; 2667d9f0ce31SBaptiste Daroussin new->obj.value.ud = ptr; 26684bf54857SBaptiste Daroussin } 26694bf54857SBaptiste Daroussin 26704bf54857SBaptiste Daroussin return (ucl_object_t *)new; 26714bf54857SBaptiste Daroussin } 26724bf54857SBaptiste Daroussin 26732e8ed2b8SBaptiste Daroussin ucl_type_t 26742e8ed2b8SBaptiste Daroussin ucl_object_type (const ucl_object_t *obj) 26752e8ed2b8SBaptiste Daroussin { 267639ee7a7aSBaptiste Daroussin if (obj == NULL) { 267739ee7a7aSBaptiste Daroussin return UCL_NULL; 267839ee7a7aSBaptiste Daroussin } 267939ee7a7aSBaptiste Daroussin 26802e8ed2b8SBaptiste Daroussin return obj->type; 26812e8ed2b8SBaptiste Daroussin } 26822e8ed2b8SBaptiste Daroussin 268397bd480fSBaptiste Daroussin ucl_object_t* 268497bd480fSBaptiste Daroussin ucl_object_fromstring (const char *str) 268597bd480fSBaptiste Daroussin { 268697bd480fSBaptiste Daroussin return ucl_object_fromstring_common (str, 0, UCL_STRING_ESCAPE); 268797bd480fSBaptiste Daroussin } 268897bd480fSBaptiste Daroussin 268997bd480fSBaptiste Daroussin ucl_object_t * 269097bd480fSBaptiste Daroussin ucl_object_fromlstring (const char *str, size_t len) 269197bd480fSBaptiste Daroussin { 269297bd480fSBaptiste Daroussin return ucl_object_fromstring_common (str, len, UCL_STRING_ESCAPE); 269397bd480fSBaptiste Daroussin } 269497bd480fSBaptiste Daroussin 269597bd480fSBaptiste Daroussin ucl_object_t * 269697bd480fSBaptiste Daroussin ucl_object_fromint (int64_t iv) 269797bd480fSBaptiste Daroussin { 269897bd480fSBaptiste Daroussin ucl_object_t *obj; 269997bd480fSBaptiste Daroussin 270097bd480fSBaptiste Daroussin obj = ucl_object_new (); 270197bd480fSBaptiste Daroussin if (obj != NULL) { 270297bd480fSBaptiste Daroussin obj->type = UCL_INT; 270397bd480fSBaptiste Daroussin obj->value.iv = iv; 270497bd480fSBaptiste Daroussin } 270597bd480fSBaptiste Daroussin 270697bd480fSBaptiste Daroussin return obj; 270797bd480fSBaptiste Daroussin } 270897bd480fSBaptiste Daroussin 270997bd480fSBaptiste Daroussin ucl_object_t * 271097bd480fSBaptiste Daroussin ucl_object_fromdouble (double dv) 271197bd480fSBaptiste Daroussin { 271297bd480fSBaptiste Daroussin ucl_object_t *obj; 271397bd480fSBaptiste Daroussin 271497bd480fSBaptiste Daroussin obj = ucl_object_new (); 271597bd480fSBaptiste Daroussin if (obj != NULL) { 271697bd480fSBaptiste Daroussin obj->type = UCL_FLOAT; 271797bd480fSBaptiste Daroussin obj->value.dv = dv; 271897bd480fSBaptiste Daroussin } 271997bd480fSBaptiste Daroussin 272097bd480fSBaptiste Daroussin return obj; 272197bd480fSBaptiste Daroussin } 272297bd480fSBaptiste Daroussin 272397bd480fSBaptiste Daroussin ucl_object_t* 272497bd480fSBaptiste Daroussin ucl_object_frombool (bool bv) 272597bd480fSBaptiste Daroussin { 272697bd480fSBaptiste Daroussin ucl_object_t *obj; 272797bd480fSBaptiste Daroussin 272897bd480fSBaptiste Daroussin obj = ucl_object_new (); 272997bd480fSBaptiste Daroussin if (obj != NULL) { 273097bd480fSBaptiste Daroussin obj->type = UCL_BOOLEAN; 273197bd480fSBaptiste Daroussin obj->value.iv = bv; 273297bd480fSBaptiste Daroussin } 273397bd480fSBaptiste Daroussin 273497bd480fSBaptiste Daroussin return obj; 273597bd480fSBaptiste Daroussin } 273697bd480fSBaptiste Daroussin 2737b04a7a0bSBaptiste Daroussin bool 273897bd480fSBaptiste Daroussin ucl_array_append (ucl_object_t *top, ucl_object_t *elt) 273997bd480fSBaptiste Daroussin { 27408e3b1ab2SBaptiste Daroussin UCL_ARRAY_GET (vec, top); 274197bd480fSBaptiste Daroussin 2742b04a7a0bSBaptiste Daroussin if (elt == NULL || top == NULL) { 2743b04a7a0bSBaptiste Daroussin return false; 274497bd480fSBaptiste Daroussin } 274597bd480fSBaptiste Daroussin 27468e3b1ab2SBaptiste Daroussin if (vec == NULL) { 27478e3b1ab2SBaptiste Daroussin vec = UCL_ALLOC (sizeof (*vec)); 274839ee7a7aSBaptiste Daroussin 274939ee7a7aSBaptiste Daroussin if (vec == NULL) { 275039ee7a7aSBaptiste Daroussin return false; 275139ee7a7aSBaptiste Daroussin } 275239ee7a7aSBaptiste Daroussin 27538e3b1ab2SBaptiste Daroussin kv_init (*vec); 27548e3b1ab2SBaptiste Daroussin top->value.av = (void *)vec; 275597bd480fSBaptiste Daroussin } 27568e3b1ab2SBaptiste Daroussin 27578e3b1ab2SBaptiste Daroussin kv_push (ucl_object_t *, *vec, elt); 27588e3b1ab2SBaptiste Daroussin 275997bd480fSBaptiste Daroussin top->len ++; 2760b04a7a0bSBaptiste Daroussin 2761b04a7a0bSBaptiste Daroussin return true; 276297bd480fSBaptiste Daroussin } 276397bd480fSBaptiste Daroussin 2764b04a7a0bSBaptiste Daroussin bool 276597bd480fSBaptiste Daroussin ucl_array_prepend (ucl_object_t *top, ucl_object_t *elt) 276697bd480fSBaptiste Daroussin { 27678e3b1ab2SBaptiste Daroussin UCL_ARRAY_GET (vec, top); 276897bd480fSBaptiste Daroussin 2769b04a7a0bSBaptiste Daroussin if (elt == NULL || top == NULL) { 2770b04a7a0bSBaptiste Daroussin return false; 277197bd480fSBaptiste Daroussin } 277297bd480fSBaptiste Daroussin 27738e3b1ab2SBaptiste Daroussin if (vec == NULL) { 27748e3b1ab2SBaptiste Daroussin vec = UCL_ALLOC (sizeof (*vec)); 27758e3b1ab2SBaptiste Daroussin kv_init (*vec); 27768e3b1ab2SBaptiste Daroussin top->value.av = (void *)vec; 27778e3b1ab2SBaptiste Daroussin kv_push (ucl_object_t *, *vec, elt); 277897bd480fSBaptiste Daroussin } 277997bd480fSBaptiste Daroussin else { 27808e3b1ab2SBaptiste Daroussin /* Slow O(n) algorithm */ 27818e3b1ab2SBaptiste Daroussin kv_prepend (ucl_object_t *, *vec, elt); 278297bd480fSBaptiste Daroussin } 27838e3b1ab2SBaptiste Daroussin 278497bd480fSBaptiste Daroussin top->len ++; 278597bd480fSBaptiste Daroussin 2786b04a7a0bSBaptiste Daroussin return true; 278797bd480fSBaptiste Daroussin } 278897bd480fSBaptiste Daroussin 27894bf54857SBaptiste Daroussin bool 27904bf54857SBaptiste Daroussin ucl_array_merge (ucl_object_t *top, ucl_object_t *elt, bool copy) 27914bf54857SBaptiste Daroussin { 27928e3b1ab2SBaptiste Daroussin unsigned i; 279339ee7a7aSBaptiste Daroussin ucl_object_t *cp = NULL; 27948e3b1ab2SBaptiste Daroussin ucl_object_t **obj; 27954bf54857SBaptiste Daroussin 27964bf54857SBaptiste Daroussin if (elt == NULL || top == NULL || top->type != UCL_ARRAY || elt->type != UCL_ARRAY) { 27974bf54857SBaptiste Daroussin return false; 27984bf54857SBaptiste Daroussin } 27994bf54857SBaptiste Daroussin 280039ee7a7aSBaptiste Daroussin if (copy) { 280139ee7a7aSBaptiste Daroussin cp = ucl_object_copy (elt); 280239ee7a7aSBaptiste Daroussin } 280339ee7a7aSBaptiste Daroussin else { 280439ee7a7aSBaptiste Daroussin cp = ucl_object_ref (elt); 280539ee7a7aSBaptiste Daroussin } 280639ee7a7aSBaptiste Daroussin 280739ee7a7aSBaptiste Daroussin UCL_ARRAY_GET (v1, top); 280839ee7a7aSBaptiste Daroussin UCL_ARRAY_GET (v2, cp); 280939ee7a7aSBaptiste Daroussin 2810d9f0ce31SBaptiste Daroussin if (v1 && v2) { 28118e3b1ab2SBaptiste Daroussin kv_concat (ucl_object_t *, *v1, *v2); 28128e3b1ab2SBaptiste Daroussin 28138e3b1ab2SBaptiste Daroussin for (i = v2->n; i < v1->n; i ++) { 28148e3b1ab2SBaptiste Daroussin obj = &kv_A (*v1, i); 28158e3b1ab2SBaptiste Daroussin if (*obj == NULL) { 28168e3b1ab2SBaptiste Daroussin continue; 28178e3b1ab2SBaptiste Daroussin } 28188e3b1ab2SBaptiste Daroussin top->len ++; 28194bf54857SBaptiste Daroussin } 2820d9f0ce31SBaptiste Daroussin } 28214bf54857SBaptiste Daroussin 28224bf54857SBaptiste Daroussin return true; 28234bf54857SBaptiste Daroussin } 28244bf54857SBaptiste Daroussin 282597bd480fSBaptiste Daroussin ucl_object_t * 282697bd480fSBaptiste Daroussin ucl_array_delete (ucl_object_t *top, ucl_object_t *elt) 282797bd480fSBaptiste Daroussin { 28288e3b1ab2SBaptiste Daroussin UCL_ARRAY_GET (vec, top); 28298e3b1ab2SBaptiste Daroussin ucl_object_t *ret = NULL; 28308e3b1ab2SBaptiste Daroussin unsigned i; 283197bd480fSBaptiste Daroussin 283239ee7a7aSBaptiste Daroussin if (vec == NULL) { 283339ee7a7aSBaptiste Daroussin return NULL; 283439ee7a7aSBaptiste Daroussin } 283539ee7a7aSBaptiste Daroussin 28368e3b1ab2SBaptiste Daroussin for (i = 0; i < vec->n; i ++) { 28378e3b1ab2SBaptiste Daroussin if (kv_A (*vec, i) == elt) { 28388e3b1ab2SBaptiste Daroussin kv_del (ucl_object_t *, *vec, i); 28398e3b1ab2SBaptiste Daroussin ret = elt; 284097bd480fSBaptiste Daroussin top->len --; 28418e3b1ab2SBaptiste Daroussin break; 28428e3b1ab2SBaptiste Daroussin } 28438e3b1ab2SBaptiste Daroussin } 284497bd480fSBaptiste Daroussin 28458e3b1ab2SBaptiste Daroussin return ret; 284697bd480fSBaptiste Daroussin } 284797bd480fSBaptiste Daroussin 2848b04a7a0bSBaptiste Daroussin const ucl_object_t * 2849b04a7a0bSBaptiste Daroussin ucl_array_head (const ucl_object_t *top) 285097bd480fSBaptiste Daroussin { 28518e3b1ab2SBaptiste Daroussin UCL_ARRAY_GET (vec, top); 28528e3b1ab2SBaptiste Daroussin 285339ee7a7aSBaptiste Daroussin if (vec == NULL || top == NULL || top->type != UCL_ARRAY || 285439ee7a7aSBaptiste Daroussin top->value.av == NULL) { 285597bd480fSBaptiste Daroussin return NULL; 285697bd480fSBaptiste Daroussin } 28578e3b1ab2SBaptiste Daroussin 28588e3b1ab2SBaptiste Daroussin return (vec->n > 0 ? vec->a[0] : NULL); 285997bd480fSBaptiste Daroussin } 286097bd480fSBaptiste Daroussin 2861b04a7a0bSBaptiste Daroussin const ucl_object_t * 2862b04a7a0bSBaptiste Daroussin ucl_array_tail (const ucl_object_t *top) 286397bd480fSBaptiste Daroussin { 28648e3b1ab2SBaptiste Daroussin UCL_ARRAY_GET (vec, top); 28658e3b1ab2SBaptiste Daroussin 286697bd480fSBaptiste Daroussin if (top == NULL || top->type != UCL_ARRAY || top->value.av == NULL) { 286797bd480fSBaptiste Daroussin return NULL; 286897bd480fSBaptiste Daroussin } 28698e3b1ab2SBaptiste Daroussin 28708e3b1ab2SBaptiste Daroussin return (vec->n > 0 ? vec->a[vec->n - 1] : NULL); 287197bd480fSBaptiste Daroussin } 287297bd480fSBaptiste Daroussin 287397bd480fSBaptiste Daroussin ucl_object_t * 287497bd480fSBaptiste Daroussin ucl_array_pop_last (ucl_object_t *top) 287597bd480fSBaptiste Daroussin { 28768e3b1ab2SBaptiste Daroussin UCL_ARRAY_GET (vec, top); 28778e3b1ab2SBaptiste Daroussin ucl_object_t **obj, *ret = NULL; 28788e3b1ab2SBaptiste Daroussin 28798e3b1ab2SBaptiste Daroussin if (vec != NULL && vec->n > 0) { 28808e3b1ab2SBaptiste Daroussin obj = &kv_A (*vec, vec->n - 1); 28818e3b1ab2SBaptiste Daroussin ret = *obj; 28828e3b1ab2SBaptiste Daroussin kv_del (ucl_object_t *, *vec, vec->n - 1); 28838e3b1ab2SBaptiste Daroussin top->len --; 28848e3b1ab2SBaptiste Daroussin } 28858e3b1ab2SBaptiste Daroussin 28868e3b1ab2SBaptiste Daroussin return ret; 288797bd480fSBaptiste Daroussin } 288897bd480fSBaptiste Daroussin 288997bd480fSBaptiste Daroussin ucl_object_t * 289097bd480fSBaptiste Daroussin ucl_array_pop_first (ucl_object_t *top) 289197bd480fSBaptiste Daroussin { 28928e3b1ab2SBaptiste Daroussin UCL_ARRAY_GET (vec, top); 28938e3b1ab2SBaptiste Daroussin ucl_object_t **obj, *ret = NULL; 28948e3b1ab2SBaptiste Daroussin 28958e3b1ab2SBaptiste Daroussin if (vec != NULL && vec->n > 0) { 28968e3b1ab2SBaptiste Daroussin obj = &kv_A (*vec, 0); 28978e3b1ab2SBaptiste Daroussin ret = *obj; 28988e3b1ab2SBaptiste Daroussin kv_del (ucl_object_t *, *vec, 0); 28998e3b1ab2SBaptiste Daroussin top->len --; 29008e3b1ab2SBaptiste Daroussin } 29018e3b1ab2SBaptiste Daroussin 29028e3b1ab2SBaptiste Daroussin return ret; 290397bd480fSBaptiste Daroussin } 290497bd480fSBaptiste Daroussin 29052e8ed2b8SBaptiste Daroussin const ucl_object_t * 29062e8ed2b8SBaptiste Daroussin ucl_array_find_index (const ucl_object_t *top, unsigned int index) 29072e8ed2b8SBaptiste Daroussin { 29088e3b1ab2SBaptiste Daroussin UCL_ARRAY_GET (vec, top); 29092e8ed2b8SBaptiste Daroussin 29108e3b1ab2SBaptiste Daroussin if (vec != NULL && vec->n > 0 && index < vec->n) { 29118e3b1ab2SBaptiste Daroussin return kv_A (*vec, index); 29122e8ed2b8SBaptiste Daroussin } 29132e8ed2b8SBaptiste Daroussin 29142e8ed2b8SBaptiste Daroussin return NULL; 29152e8ed2b8SBaptiste Daroussin } 29162e8ed2b8SBaptiste Daroussin 291739ee7a7aSBaptiste Daroussin unsigned int 291839ee7a7aSBaptiste Daroussin ucl_array_index_of (ucl_object_t *top, ucl_object_t *elt) 291939ee7a7aSBaptiste Daroussin { 292039ee7a7aSBaptiste Daroussin UCL_ARRAY_GET (vec, top); 292139ee7a7aSBaptiste Daroussin unsigned i; 292239ee7a7aSBaptiste Daroussin 292339ee7a7aSBaptiste Daroussin if (vec == NULL) { 292439ee7a7aSBaptiste Daroussin return (unsigned int)(-1); 292539ee7a7aSBaptiste Daroussin } 292639ee7a7aSBaptiste Daroussin 292739ee7a7aSBaptiste Daroussin for (i = 0; i < vec->n; i ++) { 292839ee7a7aSBaptiste Daroussin if (kv_A (*vec, i) == elt) { 292939ee7a7aSBaptiste Daroussin return i; 293039ee7a7aSBaptiste Daroussin } 293139ee7a7aSBaptiste Daroussin } 293239ee7a7aSBaptiste Daroussin 293339ee7a7aSBaptiste Daroussin return (unsigned int)(-1); 293439ee7a7aSBaptiste Daroussin } 293539ee7a7aSBaptiste Daroussin 293697bd480fSBaptiste Daroussin ucl_object_t * 29374bf54857SBaptiste Daroussin ucl_array_replace_index (ucl_object_t *top, ucl_object_t *elt, 29384bf54857SBaptiste Daroussin unsigned int index) 29394bf54857SBaptiste Daroussin { 29408e3b1ab2SBaptiste Daroussin UCL_ARRAY_GET (vec, top); 29418e3b1ab2SBaptiste Daroussin ucl_object_t *ret = NULL; 29424bf54857SBaptiste Daroussin 29438e3b1ab2SBaptiste Daroussin if (vec != NULL && vec->n > 0 && index < vec->n) { 29448e3b1ab2SBaptiste Daroussin ret = kv_A (*vec, index); 29458e3b1ab2SBaptiste Daroussin kv_A (*vec, index) = elt; 29464bf54857SBaptiste Daroussin } 29474bf54857SBaptiste Daroussin 29488e3b1ab2SBaptiste Daroussin return ret; 29494bf54857SBaptiste Daroussin } 29504bf54857SBaptiste Daroussin 29514bf54857SBaptiste Daroussin ucl_object_t * 295297bd480fSBaptiste Daroussin ucl_elt_append (ucl_object_t *head, ucl_object_t *elt) 295397bd480fSBaptiste Daroussin { 295497bd480fSBaptiste Daroussin 295597bd480fSBaptiste Daroussin if (head == NULL) { 295697bd480fSBaptiste Daroussin elt->next = NULL; 295797bd480fSBaptiste Daroussin elt->prev = elt; 295897bd480fSBaptiste Daroussin head = elt; 295997bd480fSBaptiste Daroussin } 296097bd480fSBaptiste Daroussin else { 296197bd480fSBaptiste Daroussin elt->prev = head->prev; 296297bd480fSBaptiste Daroussin head->prev->next = elt; 296397bd480fSBaptiste Daroussin head->prev = elt; 296497bd480fSBaptiste Daroussin elt->next = NULL; 296597bd480fSBaptiste Daroussin } 296697bd480fSBaptiste Daroussin 296797bd480fSBaptiste Daroussin return head; 296897bd480fSBaptiste Daroussin } 296997bd480fSBaptiste Daroussin 297097bd480fSBaptiste Daroussin bool 2971b04a7a0bSBaptiste Daroussin ucl_object_todouble_safe (const ucl_object_t *obj, double *target) 297297bd480fSBaptiste Daroussin { 297397bd480fSBaptiste Daroussin if (obj == NULL || target == NULL) { 297497bd480fSBaptiste Daroussin return false; 297597bd480fSBaptiste Daroussin } 297697bd480fSBaptiste Daroussin switch (obj->type) { 297797bd480fSBaptiste Daroussin case UCL_INT: 297897bd480fSBaptiste Daroussin *target = obj->value.iv; /* Probaly could cause overflow */ 297997bd480fSBaptiste Daroussin break; 298097bd480fSBaptiste Daroussin case UCL_FLOAT: 298197bd480fSBaptiste Daroussin case UCL_TIME: 298297bd480fSBaptiste Daroussin *target = obj->value.dv; 298397bd480fSBaptiste Daroussin break; 298497bd480fSBaptiste Daroussin default: 298597bd480fSBaptiste Daroussin return false; 298697bd480fSBaptiste Daroussin } 298797bd480fSBaptiste Daroussin 298897bd480fSBaptiste Daroussin return true; 298997bd480fSBaptiste Daroussin } 299097bd480fSBaptiste Daroussin 299197bd480fSBaptiste Daroussin double 2992b04a7a0bSBaptiste Daroussin ucl_object_todouble (const ucl_object_t *obj) 299397bd480fSBaptiste Daroussin { 299497bd480fSBaptiste Daroussin double result = 0.; 299597bd480fSBaptiste Daroussin 299697bd480fSBaptiste Daroussin ucl_object_todouble_safe (obj, &result); 299797bd480fSBaptiste Daroussin return result; 299897bd480fSBaptiste Daroussin } 299997bd480fSBaptiste Daroussin 300097bd480fSBaptiste Daroussin bool 3001b04a7a0bSBaptiste Daroussin ucl_object_toint_safe (const ucl_object_t *obj, int64_t *target) 300297bd480fSBaptiste Daroussin { 300397bd480fSBaptiste Daroussin if (obj == NULL || target == NULL) { 300497bd480fSBaptiste Daroussin return false; 300597bd480fSBaptiste Daroussin } 300697bd480fSBaptiste Daroussin switch (obj->type) { 300797bd480fSBaptiste Daroussin case UCL_INT: 300897bd480fSBaptiste Daroussin *target = obj->value.iv; 300997bd480fSBaptiste Daroussin break; 301097bd480fSBaptiste Daroussin case UCL_FLOAT: 301197bd480fSBaptiste Daroussin case UCL_TIME: 301297bd480fSBaptiste Daroussin *target = obj->value.dv; /* Loosing of decimal points */ 301397bd480fSBaptiste Daroussin break; 301497bd480fSBaptiste Daroussin default: 301597bd480fSBaptiste Daroussin return false; 301697bd480fSBaptiste Daroussin } 301797bd480fSBaptiste Daroussin 301897bd480fSBaptiste Daroussin return true; 301997bd480fSBaptiste Daroussin } 302097bd480fSBaptiste Daroussin 302197bd480fSBaptiste Daroussin int64_t 3022b04a7a0bSBaptiste Daroussin ucl_object_toint (const ucl_object_t *obj) 302397bd480fSBaptiste Daroussin { 302497bd480fSBaptiste Daroussin int64_t result = 0; 302597bd480fSBaptiste Daroussin 302697bd480fSBaptiste Daroussin ucl_object_toint_safe (obj, &result); 302797bd480fSBaptiste Daroussin return result; 302897bd480fSBaptiste Daroussin } 302997bd480fSBaptiste Daroussin 303097bd480fSBaptiste Daroussin bool 3031b04a7a0bSBaptiste Daroussin ucl_object_toboolean_safe (const ucl_object_t *obj, bool *target) 303297bd480fSBaptiste Daroussin { 303397bd480fSBaptiste Daroussin if (obj == NULL || target == NULL) { 303497bd480fSBaptiste Daroussin return false; 303597bd480fSBaptiste Daroussin } 303697bd480fSBaptiste Daroussin switch (obj->type) { 303797bd480fSBaptiste Daroussin case UCL_BOOLEAN: 303897bd480fSBaptiste Daroussin *target = (obj->value.iv == true); 303997bd480fSBaptiste Daroussin break; 304097bd480fSBaptiste Daroussin default: 304197bd480fSBaptiste Daroussin return false; 304297bd480fSBaptiste Daroussin } 304397bd480fSBaptiste Daroussin 304497bd480fSBaptiste Daroussin return true; 304597bd480fSBaptiste Daroussin } 304697bd480fSBaptiste Daroussin 304797bd480fSBaptiste Daroussin bool 3048b04a7a0bSBaptiste Daroussin ucl_object_toboolean (const ucl_object_t *obj) 304997bd480fSBaptiste Daroussin { 305097bd480fSBaptiste Daroussin bool result = false; 305197bd480fSBaptiste Daroussin 305297bd480fSBaptiste Daroussin ucl_object_toboolean_safe (obj, &result); 305397bd480fSBaptiste Daroussin return result; 305497bd480fSBaptiste Daroussin } 305597bd480fSBaptiste Daroussin 305697bd480fSBaptiste Daroussin bool 3057b04a7a0bSBaptiste Daroussin ucl_object_tostring_safe (const ucl_object_t *obj, const char **target) 305897bd480fSBaptiste Daroussin { 305997bd480fSBaptiste Daroussin if (obj == NULL || target == NULL) { 306097bd480fSBaptiste Daroussin return false; 306197bd480fSBaptiste Daroussin } 306297bd480fSBaptiste Daroussin 306397bd480fSBaptiste Daroussin switch (obj->type) { 306497bd480fSBaptiste Daroussin case UCL_STRING: 306539ee7a7aSBaptiste Daroussin if (!(obj->flags & UCL_OBJECT_BINARY)) { 306697bd480fSBaptiste Daroussin *target = ucl_copy_value_trash (obj); 306739ee7a7aSBaptiste Daroussin } 306897bd480fSBaptiste Daroussin break; 306997bd480fSBaptiste Daroussin default: 307097bd480fSBaptiste Daroussin return false; 307197bd480fSBaptiste Daroussin } 307297bd480fSBaptiste Daroussin 307397bd480fSBaptiste Daroussin return true; 307497bd480fSBaptiste Daroussin } 307597bd480fSBaptiste Daroussin 307697bd480fSBaptiste Daroussin const char * 3077b04a7a0bSBaptiste Daroussin ucl_object_tostring (const ucl_object_t *obj) 307897bd480fSBaptiste Daroussin { 307997bd480fSBaptiste Daroussin const char *result = NULL; 308097bd480fSBaptiste Daroussin 308197bd480fSBaptiste Daroussin ucl_object_tostring_safe (obj, &result); 308297bd480fSBaptiste Daroussin return result; 308397bd480fSBaptiste Daroussin } 308497bd480fSBaptiste Daroussin 308597bd480fSBaptiste Daroussin const char * 3086b04a7a0bSBaptiste Daroussin ucl_object_tostring_forced (const ucl_object_t *obj) 308797bd480fSBaptiste Daroussin { 308839ee7a7aSBaptiste Daroussin /* TODO: For binary strings we might encode string here */ 308939ee7a7aSBaptiste Daroussin if (!(obj->flags & UCL_OBJECT_BINARY)) { 309097bd480fSBaptiste Daroussin return ucl_copy_value_trash (obj); 309197bd480fSBaptiste Daroussin } 309297bd480fSBaptiste Daroussin 309339ee7a7aSBaptiste Daroussin return NULL; 309439ee7a7aSBaptiste Daroussin } 309539ee7a7aSBaptiste Daroussin 309697bd480fSBaptiste Daroussin bool 3097b04a7a0bSBaptiste Daroussin ucl_object_tolstring_safe (const ucl_object_t *obj, const char **target, size_t *tlen) 309897bd480fSBaptiste Daroussin { 309997bd480fSBaptiste Daroussin if (obj == NULL || target == NULL) { 310097bd480fSBaptiste Daroussin return false; 310197bd480fSBaptiste Daroussin } 310297bd480fSBaptiste Daroussin switch (obj->type) { 310397bd480fSBaptiste Daroussin case UCL_STRING: 310497bd480fSBaptiste Daroussin *target = obj->value.sv; 310597bd480fSBaptiste Daroussin if (tlen != NULL) { 310697bd480fSBaptiste Daroussin *tlen = obj->len; 310797bd480fSBaptiste Daroussin } 310897bd480fSBaptiste Daroussin break; 310997bd480fSBaptiste Daroussin default: 311097bd480fSBaptiste Daroussin return false; 311197bd480fSBaptiste Daroussin } 311297bd480fSBaptiste Daroussin 311397bd480fSBaptiste Daroussin return true; 311497bd480fSBaptiste Daroussin } 311597bd480fSBaptiste Daroussin 311697bd480fSBaptiste Daroussin const char * 3117b04a7a0bSBaptiste Daroussin ucl_object_tolstring (const ucl_object_t *obj, size_t *tlen) 311897bd480fSBaptiste Daroussin { 311997bd480fSBaptiste Daroussin const char *result = NULL; 312097bd480fSBaptiste Daroussin 312197bd480fSBaptiste Daroussin ucl_object_tolstring_safe (obj, &result, tlen); 312297bd480fSBaptiste Daroussin return result; 312397bd480fSBaptiste Daroussin } 312497bd480fSBaptiste Daroussin 312597bd480fSBaptiste Daroussin const char * 3126b04a7a0bSBaptiste Daroussin ucl_object_key (const ucl_object_t *obj) 312797bd480fSBaptiste Daroussin { 312897bd480fSBaptiste Daroussin return ucl_copy_key_trash (obj); 312997bd480fSBaptiste Daroussin } 313097bd480fSBaptiste Daroussin 313197bd480fSBaptiste Daroussin const char * 3132b04a7a0bSBaptiste Daroussin ucl_object_keyl (const ucl_object_t *obj, size_t *len) 313397bd480fSBaptiste Daroussin { 313497bd480fSBaptiste Daroussin if (len == NULL || obj == NULL) { 313597bd480fSBaptiste Daroussin return NULL; 313697bd480fSBaptiste Daroussin } 313797bd480fSBaptiste Daroussin *len = obj->keylen; 313897bd480fSBaptiste Daroussin return obj->key; 313997bd480fSBaptiste Daroussin } 314097bd480fSBaptiste Daroussin 314197bd480fSBaptiste Daroussin ucl_object_t * 3142b04a7a0bSBaptiste Daroussin ucl_object_ref (const ucl_object_t *obj) 314397bd480fSBaptiste Daroussin { 3144b04a7a0bSBaptiste Daroussin ucl_object_t *res = NULL; 3145b04a7a0bSBaptiste Daroussin 314697bd480fSBaptiste Daroussin if (obj != NULL) { 31474bf54857SBaptiste Daroussin if (obj->flags & UCL_OBJECT_EPHEMERAL) { 31484bf54857SBaptiste Daroussin /* 31494bf54857SBaptiste Daroussin * Use deep copy for ephemeral objects, note that its refcount 31504bf54857SBaptiste Daroussin * is NOT increased, since ephemeral objects does not need refcount 31514bf54857SBaptiste Daroussin * at all 31524bf54857SBaptiste Daroussin */ 31534bf54857SBaptiste Daroussin res = ucl_object_copy (obj); 31544bf54857SBaptiste Daroussin } 31554bf54857SBaptiste Daroussin else { 3156b04a7a0bSBaptiste Daroussin res = __DECONST (ucl_object_t *, obj); 3157b04a7a0bSBaptiste Daroussin #ifdef HAVE_ATOMIC_BUILTINS 3158b04a7a0bSBaptiste Daroussin (void)__sync_add_and_fetch (&res->ref, 1); 3159b04a7a0bSBaptiste Daroussin #else 3160b04a7a0bSBaptiste Daroussin res->ref ++; 3161b04a7a0bSBaptiste Daroussin #endif 316297bd480fSBaptiste Daroussin } 31634bf54857SBaptiste Daroussin } 3164b04a7a0bSBaptiste Daroussin return res; 316597bd480fSBaptiste Daroussin } 316697bd480fSBaptiste Daroussin 31674bf54857SBaptiste Daroussin static ucl_object_t * 31684bf54857SBaptiste Daroussin ucl_object_copy_internal (const ucl_object_t *other, bool allow_array) 31694bf54857SBaptiste Daroussin { 31704bf54857SBaptiste Daroussin 31714bf54857SBaptiste Daroussin ucl_object_t *new; 31724bf54857SBaptiste Daroussin ucl_object_iter_t it = NULL; 31734bf54857SBaptiste Daroussin const ucl_object_t *cur; 31744bf54857SBaptiste Daroussin 31754bf54857SBaptiste Daroussin new = malloc (sizeof (*new)); 31764bf54857SBaptiste Daroussin 31774bf54857SBaptiste Daroussin if (new != NULL) { 31784bf54857SBaptiste Daroussin memcpy (new, other, sizeof (*new)); 31794bf54857SBaptiste Daroussin if (other->flags & UCL_OBJECT_EPHEMERAL) { 31804bf54857SBaptiste Daroussin /* Copied object is always non ephemeral */ 31814bf54857SBaptiste Daroussin new->flags &= ~UCL_OBJECT_EPHEMERAL; 31824bf54857SBaptiste Daroussin } 31834bf54857SBaptiste Daroussin new->ref = 1; 31844bf54857SBaptiste Daroussin /* Unlink from others */ 31854bf54857SBaptiste Daroussin new->next = NULL; 31864bf54857SBaptiste Daroussin new->prev = new; 31874bf54857SBaptiste Daroussin 31884bf54857SBaptiste Daroussin /* deep copy of values stored */ 31894bf54857SBaptiste Daroussin if (other->trash_stack[UCL_TRASH_KEY] != NULL) { 31904bf54857SBaptiste Daroussin new->trash_stack[UCL_TRASH_KEY] = 31914bf54857SBaptiste Daroussin strdup (other->trash_stack[UCL_TRASH_KEY]); 31924bf54857SBaptiste Daroussin if (other->key == (const char *)other->trash_stack[UCL_TRASH_KEY]) { 31934bf54857SBaptiste Daroussin new->key = new->trash_stack[UCL_TRASH_KEY]; 31944bf54857SBaptiste Daroussin } 31954bf54857SBaptiste Daroussin } 31964bf54857SBaptiste Daroussin if (other->trash_stack[UCL_TRASH_VALUE] != NULL) { 31974bf54857SBaptiste Daroussin new->trash_stack[UCL_TRASH_VALUE] = 31984bf54857SBaptiste Daroussin strdup (other->trash_stack[UCL_TRASH_VALUE]); 31994bf54857SBaptiste Daroussin if (new->type == UCL_STRING) { 32004bf54857SBaptiste Daroussin new->value.sv = new->trash_stack[UCL_TRASH_VALUE]; 32014bf54857SBaptiste Daroussin } 32024bf54857SBaptiste Daroussin } 32034bf54857SBaptiste Daroussin 32044bf54857SBaptiste Daroussin if (other->type == UCL_ARRAY || other->type == UCL_OBJECT) { 32054bf54857SBaptiste Daroussin /* reset old value */ 32064bf54857SBaptiste Daroussin memset (&new->value, 0, sizeof (new->value)); 32074bf54857SBaptiste Daroussin 3208d9f0ce31SBaptiste Daroussin while ((cur = ucl_object_iterate (other, &it, true)) != NULL) { 32094bf54857SBaptiste Daroussin if (other->type == UCL_ARRAY) { 32104bf54857SBaptiste Daroussin ucl_array_append (new, ucl_object_copy_internal (cur, false)); 32114bf54857SBaptiste Daroussin } 32124bf54857SBaptiste Daroussin else { 32134bf54857SBaptiste Daroussin ucl_object_t *cp = ucl_object_copy_internal (cur, true); 32144bf54857SBaptiste Daroussin if (cp != NULL) { 32154bf54857SBaptiste Daroussin ucl_object_insert_key (new, cp, cp->key, cp->keylen, 32164bf54857SBaptiste Daroussin false); 32174bf54857SBaptiste Daroussin } 32184bf54857SBaptiste Daroussin } 32194bf54857SBaptiste Daroussin } 32204bf54857SBaptiste Daroussin } 32214bf54857SBaptiste Daroussin else if (allow_array && other->next != NULL) { 32224bf54857SBaptiste Daroussin LL_FOREACH (other->next, cur) { 32234bf54857SBaptiste Daroussin ucl_object_t *cp = ucl_object_copy_internal (cur, false); 32244bf54857SBaptiste Daroussin if (cp != NULL) { 32254bf54857SBaptiste Daroussin DL_APPEND (new, cp); 32264bf54857SBaptiste Daroussin } 32274bf54857SBaptiste Daroussin } 32284bf54857SBaptiste Daroussin } 32294bf54857SBaptiste Daroussin } 32304bf54857SBaptiste Daroussin 32314bf54857SBaptiste Daroussin return new; 32324bf54857SBaptiste Daroussin } 32334bf54857SBaptiste Daroussin 32344bf54857SBaptiste Daroussin ucl_object_t * 32354bf54857SBaptiste Daroussin ucl_object_copy (const ucl_object_t *other) 32364bf54857SBaptiste Daroussin { 32374bf54857SBaptiste Daroussin return ucl_object_copy_internal (other, true); 32384bf54857SBaptiste Daroussin } 32394bf54857SBaptiste Daroussin 324097bd480fSBaptiste Daroussin void 324197bd480fSBaptiste Daroussin ucl_object_unref (ucl_object_t *obj) 324297bd480fSBaptiste Daroussin { 3243b04a7a0bSBaptiste Daroussin if (obj != NULL) { 3244b04a7a0bSBaptiste Daroussin #ifdef HAVE_ATOMIC_BUILTINS 3245b04a7a0bSBaptiste Daroussin unsigned int rc = __sync_sub_and_fetch (&obj->ref, 1); 3246b04a7a0bSBaptiste Daroussin if (rc == 0) { 3247b04a7a0bSBaptiste Daroussin #else 3248b04a7a0bSBaptiste Daroussin if (--obj->ref == 0) { 3249b04a7a0bSBaptiste Daroussin #endif 3250b04a7a0bSBaptiste Daroussin ucl_object_free_internal (obj, true, ucl_object_dtor_unref); 3251b04a7a0bSBaptiste Daroussin } 325297bd480fSBaptiste Daroussin } 325397bd480fSBaptiste Daroussin } 325497bd480fSBaptiste Daroussin 325597bd480fSBaptiste Daroussin int 3256b04a7a0bSBaptiste Daroussin ucl_object_compare (const ucl_object_t *o1, const ucl_object_t *o2) 325797bd480fSBaptiste Daroussin { 3258b04a7a0bSBaptiste Daroussin const ucl_object_t *it1, *it2; 325997bd480fSBaptiste Daroussin ucl_object_iter_t iter = NULL; 326097bd480fSBaptiste Daroussin int ret = 0; 326197bd480fSBaptiste Daroussin 326297bd480fSBaptiste Daroussin if (o1->type != o2->type) { 326397bd480fSBaptiste Daroussin return (o1->type) - (o2->type); 326497bd480fSBaptiste Daroussin } 326597bd480fSBaptiste Daroussin 326697bd480fSBaptiste Daroussin switch (o1->type) { 326797bd480fSBaptiste Daroussin case UCL_STRING: 32688e3b1ab2SBaptiste Daroussin if (o1->len == o2->len && o1->len > 0) { 326997bd480fSBaptiste Daroussin ret = strcmp (ucl_object_tostring(o1), ucl_object_tostring(o2)); 327097bd480fSBaptiste Daroussin } 327197bd480fSBaptiste Daroussin else { 327297bd480fSBaptiste Daroussin ret = o1->len - o2->len; 327397bd480fSBaptiste Daroussin } 327497bd480fSBaptiste Daroussin break; 327597bd480fSBaptiste Daroussin case UCL_FLOAT: 327697bd480fSBaptiste Daroussin case UCL_INT: 327797bd480fSBaptiste Daroussin case UCL_TIME: 327897bd480fSBaptiste Daroussin ret = ucl_object_todouble (o1) - ucl_object_todouble (o2); 327997bd480fSBaptiste Daroussin break; 328097bd480fSBaptiste Daroussin case UCL_BOOLEAN: 328197bd480fSBaptiste Daroussin ret = ucl_object_toboolean (o1) - ucl_object_toboolean (o2); 328297bd480fSBaptiste Daroussin break; 328397bd480fSBaptiste Daroussin case UCL_ARRAY: 32848e3b1ab2SBaptiste Daroussin if (o1->len == o2->len && o1->len > 0) { 32858e3b1ab2SBaptiste Daroussin UCL_ARRAY_GET (vec1, o1); 32868e3b1ab2SBaptiste Daroussin UCL_ARRAY_GET (vec2, o2); 32878e3b1ab2SBaptiste Daroussin unsigned i; 32888e3b1ab2SBaptiste Daroussin 328997bd480fSBaptiste Daroussin /* Compare all elements in both arrays */ 32908e3b1ab2SBaptiste Daroussin for (i = 0; i < vec1->n; i ++) { 32918e3b1ab2SBaptiste Daroussin it1 = kv_A (*vec1, i); 32928e3b1ab2SBaptiste Daroussin it2 = kv_A (*vec2, i); 32938e3b1ab2SBaptiste Daroussin 32948e3b1ab2SBaptiste Daroussin if (it1 == NULL && it2 != NULL) { 32958e3b1ab2SBaptiste Daroussin return -1; 32968e3b1ab2SBaptiste Daroussin } 32978e3b1ab2SBaptiste Daroussin else if (it2 == NULL && it1 != NULL) { 32988e3b1ab2SBaptiste Daroussin return 1; 32998e3b1ab2SBaptiste Daroussin } 33008e3b1ab2SBaptiste Daroussin else if (it1 != NULL && it2 != NULL) { 330197bd480fSBaptiste Daroussin ret = ucl_object_compare (it1, it2); 330297bd480fSBaptiste Daroussin if (ret != 0) { 330397bd480fSBaptiste Daroussin break; 330497bd480fSBaptiste Daroussin } 33058e3b1ab2SBaptiste Daroussin } 330697bd480fSBaptiste Daroussin } 330797bd480fSBaptiste Daroussin } 330897bd480fSBaptiste Daroussin else { 330997bd480fSBaptiste Daroussin ret = o1->len - o2->len; 331097bd480fSBaptiste Daroussin } 331197bd480fSBaptiste Daroussin break; 331297bd480fSBaptiste Daroussin case UCL_OBJECT: 33138e3b1ab2SBaptiste Daroussin if (o1->len == o2->len && o1->len > 0) { 3314d9f0ce31SBaptiste Daroussin while ((it1 = ucl_object_iterate (o1, &iter, true)) != NULL) { 3315d9f0ce31SBaptiste Daroussin it2 = ucl_object_lookup (o2, ucl_object_key (it1)); 331697bd480fSBaptiste Daroussin if (it2 == NULL) { 331797bd480fSBaptiste Daroussin ret = 1; 331897bd480fSBaptiste Daroussin break; 331997bd480fSBaptiste Daroussin } 332097bd480fSBaptiste Daroussin ret = ucl_object_compare (it1, it2); 332197bd480fSBaptiste Daroussin if (ret != 0) { 332297bd480fSBaptiste Daroussin break; 332397bd480fSBaptiste Daroussin } 332497bd480fSBaptiste Daroussin } 332597bd480fSBaptiste Daroussin } 332697bd480fSBaptiste Daroussin else { 332797bd480fSBaptiste Daroussin ret = o1->len - o2->len; 332897bd480fSBaptiste Daroussin } 332997bd480fSBaptiste Daroussin break; 333097bd480fSBaptiste Daroussin default: 333197bd480fSBaptiste Daroussin ret = 0; 333297bd480fSBaptiste Daroussin break; 333397bd480fSBaptiste Daroussin } 333497bd480fSBaptiste Daroussin 333597bd480fSBaptiste Daroussin return ret; 333697bd480fSBaptiste Daroussin } 333797bd480fSBaptiste Daroussin 3338d9f0ce31SBaptiste Daroussin int 3339d9f0ce31SBaptiste Daroussin ucl_object_compare_qsort (const ucl_object_t **o1, 3340d9f0ce31SBaptiste Daroussin const ucl_object_t **o2) 3341d9f0ce31SBaptiste Daroussin { 3342d9f0ce31SBaptiste Daroussin return ucl_object_compare (*o1, *o2); 3343d9f0ce31SBaptiste Daroussin } 3344d9f0ce31SBaptiste Daroussin 334597bd480fSBaptiste Daroussin void 334697bd480fSBaptiste Daroussin ucl_object_array_sort (ucl_object_t *ar, 334739ee7a7aSBaptiste Daroussin int (*cmp)(const ucl_object_t **o1, const ucl_object_t **o2)) 334897bd480fSBaptiste Daroussin { 33498e3b1ab2SBaptiste Daroussin UCL_ARRAY_GET (vec, ar); 33508e3b1ab2SBaptiste Daroussin 335197bd480fSBaptiste Daroussin if (cmp == NULL || ar == NULL || ar->type != UCL_ARRAY) { 335297bd480fSBaptiste Daroussin return; 335397bd480fSBaptiste Daroussin } 335497bd480fSBaptiste Daroussin 33558e3b1ab2SBaptiste Daroussin qsort (vec->a, vec->n, sizeof (ucl_object_t *), 33568e3b1ab2SBaptiste Daroussin (int (*)(const void *, const void *))cmp); 335797bd480fSBaptiste Daroussin } 33584bf54857SBaptiste Daroussin 33594bf54857SBaptiste Daroussin #define PRIOBITS 4 33604bf54857SBaptiste Daroussin 33614bf54857SBaptiste Daroussin unsigned int 33624bf54857SBaptiste Daroussin ucl_object_get_priority (const ucl_object_t *obj) 33634bf54857SBaptiste Daroussin { 33644bf54857SBaptiste Daroussin if (obj == NULL) { 33654bf54857SBaptiste Daroussin return 0; 33664bf54857SBaptiste Daroussin } 33674bf54857SBaptiste Daroussin 33684bf54857SBaptiste Daroussin return (obj->flags >> ((sizeof (obj->flags) * NBBY) - PRIOBITS)); 33694bf54857SBaptiste Daroussin } 33704bf54857SBaptiste Daroussin 33714bf54857SBaptiste Daroussin void 33724bf54857SBaptiste Daroussin ucl_object_set_priority (ucl_object_t *obj, 33734bf54857SBaptiste Daroussin unsigned int priority) 33744bf54857SBaptiste Daroussin { 33754bf54857SBaptiste Daroussin if (obj != NULL) { 33764bf54857SBaptiste Daroussin priority &= (0x1 << PRIOBITS) - 1; 337739ee7a7aSBaptiste Daroussin priority <<= ((sizeof (obj->flags) * NBBY) - PRIOBITS); 337839ee7a7aSBaptiste Daroussin priority |= obj->flags & ((1 << ((sizeof (obj->flags) * NBBY) - 337939ee7a7aSBaptiste Daroussin PRIOBITS)) - 1); 338039ee7a7aSBaptiste Daroussin obj->flags = priority; 33814bf54857SBaptiste Daroussin } 33824bf54857SBaptiste Daroussin } 3383d9f0ce31SBaptiste Daroussin 3384d9f0ce31SBaptiste Daroussin bool 3385d9f0ce31SBaptiste Daroussin ucl_object_string_to_type (const char *input, ucl_type_t *res) 3386d9f0ce31SBaptiste Daroussin { 3387d9f0ce31SBaptiste Daroussin if (strcasecmp (input, "object") == 0) { 3388d9f0ce31SBaptiste Daroussin *res = UCL_OBJECT; 3389d9f0ce31SBaptiste Daroussin } 3390d9f0ce31SBaptiste Daroussin else if (strcasecmp (input, "array") == 0) { 3391d9f0ce31SBaptiste Daroussin *res = UCL_ARRAY; 3392d9f0ce31SBaptiste Daroussin } 3393d9f0ce31SBaptiste Daroussin else if (strcasecmp (input, "integer") == 0) { 3394d9f0ce31SBaptiste Daroussin *res = UCL_INT; 3395d9f0ce31SBaptiste Daroussin } 3396d9f0ce31SBaptiste Daroussin else if (strcasecmp (input, "number") == 0) { 3397d9f0ce31SBaptiste Daroussin *res = UCL_FLOAT; 3398d9f0ce31SBaptiste Daroussin } 3399d9f0ce31SBaptiste Daroussin else if (strcasecmp (input, "string") == 0) { 3400d9f0ce31SBaptiste Daroussin *res = UCL_STRING; 3401d9f0ce31SBaptiste Daroussin } 3402d9f0ce31SBaptiste Daroussin else if (strcasecmp (input, "boolean") == 0) { 3403d9f0ce31SBaptiste Daroussin *res = UCL_BOOLEAN; 3404d9f0ce31SBaptiste Daroussin } 3405d9f0ce31SBaptiste Daroussin else if (strcasecmp (input, "null") == 0) { 3406d9f0ce31SBaptiste Daroussin *res = UCL_NULL; 3407d9f0ce31SBaptiste Daroussin } 3408d9f0ce31SBaptiste Daroussin else if (strcasecmp (input, "userdata") == 0) { 3409d9f0ce31SBaptiste Daroussin *res = UCL_USERDATA; 3410d9f0ce31SBaptiste Daroussin } 3411d9f0ce31SBaptiste Daroussin else { 3412d9f0ce31SBaptiste Daroussin return false; 3413d9f0ce31SBaptiste Daroussin } 3414d9f0ce31SBaptiste Daroussin 3415d9f0ce31SBaptiste Daroussin return true; 3416d9f0ce31SBaptiste Daroussin } 3417d9f0ce31SBaptiste Daroussin 3418d9f0ce31SBaptiste Daroussin const char * 3419d9f0ce31SBaptiste Daroussin ucl_object_type_to_string (ucl_type_t type) 3420d9f0ce31SBaptiste Daroussin { 3421d9f0ce31SBaptiste Daroussin const char *res = "unknown"; 3422d9f0ce31SBaptiste Daroussin 3423d9f0ce31SBaptiste Daroussin switch (type) { 3424d9f0ce31SBaptiste Daroussin case UCL_OBJECT: 3425d9f0ce31SBaptiste Daroussin res = "object"; 3426d9f0ce31SBaptiste Daroussin break; 3427d9f0ce31SBaptiste Daroussin case UCL_ARRAY: 3428d9f0ce31SBaptiste Daroussin res = "array"; 3429d9f0ce31SBaptiste Daroussin break; 3430d9f0ce31SBaptiste Daroussin case UCL_INT: 3431d9f0ce31SBaptiste Daroussin res = "integer"; 3432d9f0ce31SBaptiste Daroussin break; 3433d9f0ce31SBaptiste Daroussin case UCL_FLOAT: 3434d9f0ce31SBaptiste Daroussin case UCL_TIME: 3435d9f0ce31SBaptiste Daroussin res = "number"; 3436d9f0ce31SBaptiste Daroussin break; 3437d9f0ce31SBaptiste Daroussin case UCL_STRING: 3438d9f0ce31SBaptiste Daroussin res = "string"; 3439d9f0ce31SBaptiste Daroussin break; 3440d9f0ce31SBaptiste Daroussin case UCL_BOOLEAN: 3441d9f0ce31SBaptiste Daroussin res = "boolean"; 3442d9f0ce31SBaptiste Daroussin break; 3443d9f0ce31SBaptiste Daroussin case UCL_USERDATA: 3444d9f0ce31SBaptiste Daroussin res = "userdata"; 3445d9f0ce31SBaptiste Daroussin break; 3446d9f0ce31SBaptiste Daroussin case UCL_NULL: 3447d9f0ce31SBaptiste Daroussin res = "null"; 3448d9f0ce31SBaptiste Daroussin break; 3449d9f0ce31SBaptiste Daroussin } 3450d9f0ce31SBaptiste Daroussin 3451d9f0ce31SBaptiste Daroussin return res; 3452d9f0ce31SBaptiste Daroussin } 3453d9f0ce31SBaptiste Daroussin 3454d9f0ce31SBaptiste Daroussin const ucl_object_t * 3455d9f0ce31SBaptiste Daroussin ucl_parser_get_comments (struct ucl_parser *parser) 3456d9f0ce31SBaptiste Daroussin { 3457d9f0ce31SBaptiste Daroussin if (parser && parser->comments) { 3458d9f0ce31SBaptiste Daroussin return parser->comments; 3459d9f0ce31SBaptiste Daroussin } 3460d9f0ce31SBaptiste Daroussin 3461d9f0ce31SBaptiste Daroussin return NULL; 3462d9f0ce31SBaptiste Daroussin } 3463d9f0ce31SBaptiste Daroussin 3464d9f0ce31SBaptiste Daroussin const ucl_object_t * 3465d9f0ce31SBaptiste Daroussin ucl_comments_find (const ucl_object_t *comments, 3466d9f0ce31SBaptiste Daroussin const ucl_object_t *srch) 3467d9f0ce31SBaptiste Daroussin { 3468d9f0ce31SBaptiste Daroussin if (comments && srch) { 3469d9f0ce31SBaptiste Daroussin return ucl_object_lookup_len (comments, (const char *)&srch, 3470d9f0ce31SBaptiste Daroussin sizeof (void *)); 3471d9f0ce31SBaptiste Daroussin } 3472d9f0ce31SBaptiste Daroussin 3473d9f0ce31SBaptiste Daroussin return NULL; 3474d9f0ce31SBaptiste Daroussin } 3475d9f0ce31SBaptiste Daroussin 3476d9f0ce31SBaptiste Daroussin bool 3477d9f0ce31SBaptiste Daroussin ucl_comments_move (ucl_object_t *comments, 3478d9f0ce31SBaptiste Daroussin const ucl_object_t *from, const ucl_object_t *to) 3479d9f0ce31SBaptiste Daroussin { 3480d9f0ce31SBaptiste Daroussin const ucl_object_t *found; 3481d9f0ce31SBaptiste Daroussin ucl_object_t *obj; 3482d9f0ce31SBaptiste Daroussin 3483d9f0ce31SBaptiste Daroussin if (comments && from && to) { 3484d9f0ce31SBaptiste Daroussin found = ucl_object_lookup_len (comments, 3485d9f0ce31SBaptiste Daroussin (const char *)&from, sizeof (void *)); 3486d9f0ce31SBaptiste Daroussin 3487d9f0ce31SBaptiste Daroussin if (found) { 3488d9f0ce31SBaptiste Daroussin /* Replace key */ 3489d9f0ce31SBaptiste Daroussin obj = ucl_object_ref (found); 3490d9f0ce31SBaptiste Daroussin ucl_object_delete_keyl (comments, (const char *)&from, 3491d9f0ce31SBaptiste Daroussin sizeof (void *)); 3492d9f0ce31SBaptiste Daroussin ucl_object_insert_key (comments, obj, (const char *)&to, 3493d9f0ce31SBaptiste Daroussin sizeof (void *), true); 3494d9f0ce31SBaptiste Daroussin 3495d9f0ce31SBaptiste Daroussin return true; 3496d9f0ce31SBaptiste Daroussin } 3497d9f0ce31SBaptiste Daroussin } 3498d9f0ce31SBaptiste Daroussin 3499d9f0ce31SBaptiste Daroussin return false; 3500d9f0ce31SBaptiste Daroussin } 3501d9f0ce31SBaptiste Daroussin 3502d9f0ce31SBaptiste Daroussin void 3503d9f0ce31SBaptiste Daroussin ucl_comments_add (ucl_object_t *comments, const ucl_object_t *obj, 3504d9f0ce31SBaptiste Daroussin const char *comment) 3505d9f0ce31SBaptiste Daroussin { 3506d9f0ce31SBaptiste Daroussin if (comments && obj && comment) { 3507d9f0ce31SBaptiste Daroussin ucl_object_insert_key (comments, ucl_object_fromstring (comment), 3508d9f0ce31SBaptiste Daroussin (const char *)&obj, sizeof (void *), true); 3509d9f0ce31SBaptiste Daroussin } 3510d9f0ce31SBaptiste Daroussin } 3511