2015-02-21 19:11:12 +01:00
|
|
|
/* Copyright (c) 2013, Vsevolod Stakhov
|
2015-07-28 17:57:15 +02:00
|
|
|
* Copyright (c) 2015 Allan Jude <allanjude@freebsd.org>
|
2015-02-21 19:11:12 +01:00
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions are met:
|
|
|
|
* * Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY
|
|
|
|
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
|
|
* DISCLAIMED. IN NO EVENT SHALL AUTHOR BE LIABLE FOR ANY
|
|
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "ucl.h"
|
|
|
|
#include "ucl_internal.h"
|
|
|
|
#include "ucl_chartable.h"
|
|
|
|
#include "kvec.h"
|
2018-03-21 14:08:45 +01:00
|
|
|
#include <limits.h>
|
2015-07-28 17:57:15 +02:00
|
|
|
#include <stdarg.h>
|
2016-02-22 18:16:14 +01:00
|
|
|
#include <stdio.h> /* for snprintf */
|
2015-02-21 19:11:12 +01:00
|
|
|
|
|
|
|
#ifndef _WIN32
|
|
|
|
#include <glob.h>
|
2018-03-21 14:08:45 +01:00
|
|
|
#include <sys/param.h>
|
|
|
|
#else
|
|
|
|
#ifndef NBBY
|
|
|
|
#define NBBY 8
|
|
|
|
#endif
|
2015-02-21 19:11:12 +01:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef HAVE_LIBGEN_H
|
2018-03-21 14:08:45 +01:00
|
|
|
#ifndef _WIN32
|
|
|
|
# include <libgen.h> /* For dirname */
|
|
|
|
#endif
|
2015-02-21 19:11:12 +01:00
|
|
|
#endif
|
|
|
|
|
|
|
|
typedef kvec_t(ucl_object_t *) ucl_array_t;
|
|
|
|
|
|
|
|
#define UCL_ARRAY_GET(ar, obj) ucl_array_t *ar = \
|
|
|
|
(ucl_array_t *)((obj) != NULL ? (obj)->value.av : NULL)
|
|
|
|
|
|
|
|
#ifdef HAVE_OPENSSL
|
|
|
|
#include <openssl/err.h>
|
|
|
|
#include <openssl/sha.h>
|
|
|
|
#include <openssl/rsa.h>
|
|
|
|
#include <openssl/ssl.h>
|
|
|
|
#include <openssl/evp.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CURL_FOUND
|
2016-02-22 18:16:14 +01:00
|
|
|
/* Seems to be broken */
|
|
|
|
#define CURL_DISABLE_TYPECHECK 1
|
2015-02-21 19:11:12 +01:00
|
|
|
#include <curl/curl.h>
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_FETCH_H
|
|
|
|
#include <fetch.h>
|
|
|
|
#endif
|
|
|
|
|
2018-03-21 14:08:45 +01:00
|
|
|
#if defined(_MSC_VER)
|
2015-02-21 19:11:12 +01:00
|
|
|
#include <windows.h>
|
2018-03-21 14:08:45 +01:00
|
|
|
#include <io.h>
|
|
|
|
#include <direct.h>
|
2015-02-21 19:11:12 +01:00
|
|
|
|
|
|
|
#ifndef PROT_READ
|
|
|
|
#define PROT_READ 1
|
|
|
|
#endif
|
|
|
|
#ifndef PROT_WRITE
|
|
|
|
#define PROT_WRITE 2
|
|
|
|
#endif
|
|
|
|
#ifndef PROT_READWRITE
|
|
|
|
#define PROT_READWRITE 3
|
|
|
|
#endif
|
|
|
|
#ifndef MAP_SHARED
|
|
|
|
#define MAP_SHARED 1
|
|
|
|
#endif
|
|
|
|
#ifndef MAP_PRIVATE
|
|
|
|
#define MAP_PRIVATE 2
|
|
|
|
#endif
|
|
|
|
#ifndef MAP_FAILED
|
|
|
|
#define MAP_FAILED ((void *) -1)
|
|
|
|
#endif
|
|
|
|
|
2018-03-21 14:08:45 +01:00
|
|
|
#define getcwd _getcwd
|
|
|
|
#define open _open
|
|
|
|
#define close _close
|
2015-02-21 19:11:12 +01:00
|
|
|
|
|
|
|
static void *ucl_mmap(char *addr, size_t length, int prot, int access, int fd, off_t offset)
|
|
|
|
{
|
|
|
|
void *map = NULL;
|
|
|
|
HANDLE handle = INVALID_HANDLE_VALUE;
|
|
|
|
|
|
|
|
switch (prot) {
|
|
|
|
default:
|
|
|
|
case PROT_READ:
|
|
|
|
{
|
|
|
|
handle = CreateFileMapping((HANDLE) _get_osfhandle(fd), 0, PAGE_READONLY, 0, length, 0);
|
|
|
|
if (!handle) break;
|
|
|
|
map = (void *) MapViewOfFile(handle, FILE_MAP_READ, 0, 0, length);
|
|
|
|
CloseHandle(handle);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case PROT_WRITE:
|
|
|
|
{
|
|
|
|
handle = CreateFileMapping((HANDLE) _get_osfhandle(fd), 0, PAGE_READWRITE, 0, length, 0);
|
|
|
|
if (!handle) break;
|
|
|
|
map = (void *) MapViewOfFile(handle, FILE_MAP_WRITE, 0, 0, length);
|
|
|
|
CloseHandle(handle);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case PROT_READWRITE:
|
|
|
|
{
|
|
|
|
handle = CreateFileMapping((HANDLE) _get_osfhandle(fd), 0, PAGE_READWRITE, 0, length, 0);
|
|
|
|
if (!handle) break;
|
|
|
|
map = (void *) MapViewOfFile(handle, FILE_MAP_ALL_ACCESS, 0, 0, length);
|
|
|
|
CloseHandle(handle);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (map == (void *) NULL) {
|
|
|
|
return (void *) MAP_FAILED;
|
|
|
|
}
|
|
|
|
return (void *) ((char *) map + offset);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ucl_munmap(void *map,size_t length)
|
|
|
|
{
|
|
|
|
if (!UnmapViewOfFile(map)) {
|
|
|
|
return(-1);
|
|
|
|
}
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
2018-03-21 14:08:45 +01:00
|
|
|
static char* ucl_realpath(const char *path, char *resolved_path)
|
|
|
|
{
|
|
|
|
char *p;
|
|
|
|
char tmp[MAX_PATH + 1];
|
|
|
|
strncpy(tmp, path, sizeof(tmp)-1);
|
|
|
|
p = tmp;
|
|
|
|
while(*p) {
|
|
|
|
if (*p == '/') *p = '\\';
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
return _fullpath(resolved_path, tmp, MAX_PATH);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
char *dirname(char *path)
|
|
|
|
{
|
|
|
|
static char path_buffer[_MAX_PATH];
|
|
|
|
char drive[_MAX_DRIVE];
|
|
|
|
char dir[_MAX_DIR];
|
|
|
|
char fname[_MAX_FNAME];
|
|
|
|
char ext[_MAX_EXT];
|
|
|
|
|
|
|
|
_splitpath (path, drive, dir, fname, ext);
|
|
|
|
_makepath(path_buffer, drive, dir, NULL, NULL);
|
|
|
|
|
|
|
|
return path_buffer;
|
|
|
|
}
|
|
|
|
|
|
|
|
char *basename(char *path)
|
|
|
|
{
|
|
|
|
static char path_buffer[_MAX_PATH];
|
|
|
|
char drive[_MAX_DRIVE];
|
|
|
|
char dir[_MAX_DIR];
|
|
|
|
char fname[_MAX_FNAME];
|
|
|
|
char ext[_MAX_EXT];
|
|
|
|
|
|
|
|
_splitpath(path, drive, dir, fname, ext);
|
|
|
|
_makepath(path_buffer, NULL, NULL, fname, ext);
|
|
|
|
|
|
|
|
return path_buffer;
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
#else
|
|
|
|
#define ucl_mmap mmap
|
|
|
|
#define ucl_munmap munmap
|
|
|
|
#define ucl_realpath realpath
|
|
|
|
#endif
|
|
|
|
|
|
|
|
typedef void (*ucl_object_dtor) (ucl_object_t *obj);
|
|
|
|
static void ucl_object_free_internal (ucl_object_t *obj, bool allow_rec,
|
|
|
|
ucl_object_dtor dtor);
|
|
|
|
static void ucl_object_dtor_unref (ucl_object_t *obj);
|
|
|
|
|
|
|
|
static void
|
|
|
|
ucl_object_dtor_free (ucl_object_t *obj)
|
|
|
|
{
|
|
|
|
if (obj->trash_stack[UCL_TRASH_KEY] != NULL) {
|
|
|
|
UCL_FREE (obj->hh.keylen, obj->trash_stack[UCL_TRASH_KEY]);
|
|
|
|
}
|
|
|
|
if (obj->trash_stack[UCL_TRASH_VALUE] != NULL) {
|
|
|
|
UCL_FREE (obj->len, obj->trash_stack[UCL_TRASH_VALUE]);
|
|
|
|
}
|
|
|
|
/* Do not free ephemeral objects */
|
|
|
|
if ((obj->flags & UCL_OBJECT_EPHEMERAL) == 0) {
|
|
|
|
if (obj->type != UCL_USERDATA) {
|
|
|
|
UCL_FREE (sizeof (ucl_object_t), obj);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
struct ucl_object_userdata *ud = (struct ucl_object_userdata *)obj;
|
|
|
|
if (ud->dtor) {
|
|
|
|
ud->dtor (obj->value.ud);
|
|
|
|
}
|
|
|
|
UCL_FREE (sizeof (*ud), obj);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is a helper function that performs exactly the same as
|
|
|
|
* `ucl_object_unref` but it doesn't iterate over elements allowing
|
|
|
|
* to use it for individual elements of arrays and multiple values
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
ucl_object_dtor_unref_single (ucl_object_t *obj)
|
|
|
|
{
|
|
|
|
if (obj != NULL) {
|
|
|
|
#ifdef HAVE_ATOMIC_BUILTINS
|
|
|
|
unsigned int rc = __sync_sub_and_fetch (&obj->ref, 1);
|
|
|
|
if (rc == 0) {
|
|
|
|
#else
|
|
|
|
if (--obj->ref == 0) {
|
|
|
|
#endif
|
|
|
|
ucl_object_free_internal (obj, false, ucl_object_dtor_unref);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
ucl_object_dtor_unref (ucl_object_t *obj)
|
|
|
|
{
|
|
|
|
if (obj->ref == 0) {
|
|
|
|
ucl_object_dtor_free (obj);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* This may cause dtor unref being called one more time */
|
|
|
|
ucl_object_dtor_unref_single (obj);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
ucl_object_free_internal (ucl_object_t *obj, bool allow_rec, ucl_object_dtor dtor)
|
|
|
|
{
|
|
|
|
ucl_object_t *tmp, *sub;
|
|
|
|
|
|
|
|
while (obj != NULL) {
|
|
|
|
if (obj->type == UCL_ARRAY) {
|
|
|
|
UCL_ARRAY_GET (vec, obj);
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
if (vec != NULL) {
|
|
|
|
for (i = 0; i < vec->n; i ++) {
|
|
|
|
sub = kv_A (*vec, i);
|
|
|
|
if (sub != NULL) {
|
|
|
|
tmp = sub;
|
|
|
|
while (sub) {
|
|
|
|
tmp = sub->next;
|
|
|
|
dtor (sub);
|
|
|
|
sub = tmp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
kv_destroy (*vec);
|
|
|
|
UCL_FREE (sizeof (*vec), vec);
|
|
|
|
}
|
2015-04-23 19:28:34 +02:00
|
|
|
obj->value.av = NULL;
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
else if (obj->type == UCL_OBJECT) {
|
|
|
|
if (obj->value.ov != NULL) {
|
2016-02-08 19:26:58 +01:00
|
|
|
ucl_hash_destroy (obj->value.ov, (ucl_hash_free_func)dtor);
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
2015-04-23 19:28:34 +02:00
|
|
|
obj->value.ov = NULL;
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
tmp = obj->next;
|
|
|
|
dtor (obj);
|
|
|
|
obj = tmp;
|
|
|
|
|
|
|
|
if (!allow_rec) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ucl_object_free (ucl_object_t *obj)
|
|
|
|
{
|
|
|
|
ucl_object_free_internal (obj, true, ucl_object_dtor_free);
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t
|
|
|
|
ucl_unescape_json_string (char *str, size_t len)
|
|
|
|
{
|
|
|
|
char *t = str, *h = str;
|
|
|
|
int i, uval;
|
|
|
|
|
|
|
|
if (len <= 1) {
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
/* t is target (tortoise), h is source (hare) */
|
|
|
|
|
|
|
|
while (len) {
|
|
|
|
if (*h == '\\') {
|
|
|
|
h ++;
|
2015-05-17 17:10:29 +02:00
|
|
|
|
|
|
|
if (len == 1) {
|
|
|
|
/*
|
|
|
|
* If \ is last, then do not try to go further
|
|
|
|
* Issue: #74
|
|
|
|
*/
|
|
|
|
len --;
|
|
|
|
*t++ = '\\';
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2015-02-21 19:11:12 +01:00
|
|
|
switch (*h) {
|
|
|
|
case 'n':
|
|
|
|
*t++ = '\n';
|
|
|
|
break;
|
|
|
|
case 'r':
|
|
|
|
*t++ = '\r';
|
|
|
|
break;
|
|
|
|
case 'b':
|
|
|
|
*t++ = '\b';
|
|
|
|
break;
|
|
|
|
case 't':
|
|
|
|
*t++ = '\t';
|
|
|
|
break;
|
|
|
|
case 'f':
|
|
|
|
*t++ = '\f';
|
|
|
|
break;
|
|
|
|
case '\\':
|
|
|
|
*t++ = '\\';
|
|
|
|
break;
|
|
|
|
case '"':
|
|
|
|
*t++ = '"';
|
|
|
|
break;
|
|
|
|
case 'u':
|
|
|
|
/* Unicode escape */
|
|
|
|
uval = 0;
|
2016-02-14 14:34:42 +01:00
|
|
|
h ++; /* u character */
|
|
|
|
len --;
|
|
|
|
|
2015-02-21 19:11:12 +01:00
|
|
|
if (len > 3) {
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
uval <<= 4;
|
|
|
|
if (isdigit (h[i])) {
|
|
|
|
uval += h[i] - '0';
|
|
|
|
}
|
|
|
|
else if (h[i] >= 'a' && h[i] <= 'f') {
|
|
|
|
uval += h[i] - 'a' + 10;
|
|
|
|
}
|
|
|
|
else if (h[i] >= 'A' && h[i] <= 'F') {
|
|
|
|
uval += h[i] - 'A' + 10;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2016-02-14 14:34:42 +01:00
|
|
|
|
2015-02-21 19:11:12 +01:00
|
|
|
/* Encode */
|
|
|
|
if(uval < 0x80) {
|
|
|
|
t[0] = (char)uval;
|
|
|
|
t ++;
|
|
|
|
}
|
|
|
|
else if(uval < 0x800) {
|
|
|
|
t[0] = 0xC0 + ((uval & 0x7C0) >> 6);
|
|
|
|
t[1] = 0x80 + ((uval & 0x03F));
|
|
|
|
t += 2;
|
|
|
|
}
|
|
|
|
else if(uval < 0x10000) {
|
|
|
|
t[0] = 0xE0 + ((uval & 0xF000) >> 12);
|
|
|
|
t[1] = 0x80 + ((uval & 0x0FC0) >> 6);
|
|
|
|
t[2] = 0x80 + ((uval & 0x003F));
|
|
|
|
t += 3;
|
|
|
|
}
|
2016-02-14 14:34:42 +01:00
|
|
|
#if 0
|
|
|
|
/* It's not actually supported now */
|
2015-02-21 19:11:12 +01:00
|
|
|
else if(uval <= 0x10FFFF) {
|
|
|
|
t[0] = 0xF0 + ((uval & 0x1C0000) >> 18);
|
|
|
|
t[1] = 0x80 + ((uval & 0x03F000) >> 12);
|
|
|
|
t[2] = 0x80 + ((uval & 0x000FC0) >> 6);
|
|
|
|
t[3] = 0x80 + ((uval & 0x00003F));
|
|
|
|
t += 4;
|
|
|
|
}
|
2016-02-14 14:34:42 +01:00
|
|
|
#endif
|
2015-02-21 19:11:12 +01:00
|
|
|
else {
|
|
|
|
*t++ = '?';
|
|
|
|
}
|
2016-02-14 14:34:42 +01:00
|
|
|
|
|
|
|
/* Consume 4 characters of source */
|
|
|
|
h += 4;
|
|
|
|
len -= 4;
|
|
|
|
|
|
|
|
if (len > 0) {
|
|
|
|
len --; /* for '\' character */
|
|
|
|
}
|
|
|
|
continue;
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
*t++ = 'u';
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
*t++ = *h;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
h ++;
|
|
|
|
len --;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
*t++ = *h++;
|
|
|
|
}
|
2015-05-17 17:10:29 +02:00
|
|
|
|
|
|
|
if (len > 0) {
|
|
|
|
len --;
|
|
|
|
}
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
*t = '\0';
|
|
|
|
|
|
|
|
return (t - str);
|
|
|
|
}
|
|
|
|
|
2018-03-21 16:01:31 +01:00
|
|
|
size_t
|
|
|
|
ucl_unescape_squoted_string (char *str, size_t len)
|
|
|
|
{
|
|
|
|
char *t = str, *h = str;
|
|
|
|
|
|
|
|
if (len <= 1) {
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* t is target (tortoise), h is source (hare) */
|
|
|
|
|
|
|
|
while (len) {
|
|
|
|
if (*h == '\\') {
|
|
|
|
h ++;
|
|
|
|
|
|
|
|
if (len == 1) {
|
|
|
|
/*
|
|
|
|
* If \ is last, then do not try to go further
|
|
|
|
* Issue: #74
|
|
|
|
*/
|
|
|
|
len --;
|
|
|
|
*t++ = '\\';
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (*h) {
|
|
|
|
case '\'':
|
|
|
|
*t++ = '\'';
|
|
|
|
break;
|
|
|
|
case '\n':
|
|
|
|
/* Ignore \<newline> style stuff */
|
|
|
|
break;
|
|
|
|
case '\r':
|
|
|
|
/* Ignore \r and the following \n if needed */
|
|
|
|
if (len > 1 && h[1] == '\n') {
|
|
|
|
h ++;
|
|
|
|
len --;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* Ignore \ */
|
|
|
|
*t++ = '\\';
|
|
|
|
*t++ = *h;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
h ++;
|
|
|
|
len --;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
*t++ = *h++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (len > 0) {
|
|
|
|
len --;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
*t = '\0';
|
|
|
|
|
|
|
|
return (t - str);
|
|
|
|
}
|
|
|
|
|
2015-02-21 19:11:12 +01:00
|
|
|
char *
|
|
|
|
ucl_copy_key_trash (const ucl_object_t *obj)
|
|
|
|
{
|
|
|
|
ucl_object_t *deconst;
|
|
|
|
|
|
|
|
if (obj == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if (obj->trash_stack[UCL_TRASH_KEY] == NULL && obj->key != NULL) {
|
|
|
|
deconst = __DECONST (ucl_object_t *, obj);
|
|
|
|
deconst->trash_stack[UCL_TRASH_KEY] = malloc (obj->keylen + 1);
|
|
|
|
if (deconst->trash_stack[UCL_TRASH_KEY] != NULL) {
|
|
|
|
memcpy (deconst->trash_stack[UCL_TRASH_KEY], obj->key, obj->keylen);
|
|
|
|
deconst->trash_stack[UCL_TRASH_KEY][obj->keylen] = '\0';
|
|
|
|
}
|
|
|
|
deconst->key = obj->trash_stack[UCL_TRASH_KEY];
|
|
|
|
deconst->flags |= UCL_OBJECT_ALLOCATED_KEY;
|
|
|
|
}
|
|
|
|
|
|
|
|
return obj->trash_stack[UCL_TRASH_KEY];
|
|
|
|
}
|
|
|
|
|
2018-05-05 15:58:37 +02:00
|
|
|
void
|
|
|
|
ucl_chunk_free (struct ucl_chunk *chunk)
|
|
|
|
{
|
|
|
|
if (chunk) {
|
2019-03-26 16:57:43 +01:00
|
|
|
struct ucl_parser_special_handler_chain *chain, *tmp;
|
|
|
|
|
|
|
|
LL_FOREACH_SAFE (chunk->special_handlers, chain, tmp) {
|
|
|
|
if (chain->special_handler->free_function) {
|
|
|
|
chain->special_handler->free_function (
|
|
|
|
chain->begin,
|
|
|
|
chain->len,
|
|
|
|
chain->special_handler->user_data);
|
2018-05-05 15:58:37 +02:00
|
|
|
} else {
|
2019-03-26 16:57:43 +01:00
|
|
|
UCL_FREE (chain->len, chain->begin);
|
2018-05-05 15:58:37 +02:00
|
|
|
}
|
2019-03-26 16:57:43 +01:00
|
|
|
|
|
|
|
UCL_FREE (sizeof (*chain), chain);
|
2018-05-05 15:58:37 +02:00
|
|
|
}
|
|
|
|
|
2019-03-26 16:57:43 +01:00
|
|
|
chunk->special_handlers = NULL;
|
|
|
|
|
2018-10-05 21:01:28 +02:00
|
|
|
if (chunk->fname) {
|
|
|
|
free (chunk->fname);
|
|
|
|
}
|
|
|
|
|
2018-05-05 15:58:37 +02:00
|
|
|
UCL_FREE (sizeof (*chunk), chunk);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-21 19:11:12 +01:00
|
|
|
char *
|
|
|
|
ucl_copy_value_trash (const ucl_object_t *obj)
|
|
|
|
{
|
|
|
|
ucl_object_t *deconst;
|
|
|
|
|
|
|
|
if (obj == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if (obj->trash_stack[UCL_TRASH_VALUE] == NULL) {
|
|
|
|
deconst = __DECONST (ucl_object_t *, obj);
|
|
|
|
if (obj->type == UCL_STRING) {
|
|
|
|
|
|
|
|
/* Special case for strings */
|
2015-10-13 18:05:19 +02:00
|
|
|
if (obj->flags & UCL_OBJECT_BINARY) {
|
|
|
|
deconst->trash_stack[UCL_TRASH_VALUE] = malloc (obj->len);
|
|
|
|
if (deconst->trash_stack[UCL_TRASH_VALUE] != NULL) {
|
|
|
|
memcpy (deconst->trash_stack[UCL_TRASH_VALUE],
|
|
|
|
obj->value.sv,
|
|
|
|
obj->len);
|
|
|
|
deconst->value.sv = obj->trash_stack[UCL_TRASH_VALUE];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
deconst->trash_stack[UCL_TRASH_VALUE] = malloc (obj->len + 1);
|
|
|
|
if (deconst->trash_stack[UCL_TRASH_VALUE] != NULL) {
|
|
|
|
memcpy (deconst->trash_stack[UCL_TRASH_VALUE],
|
|
|
|
obj->value.sv,
|
|
|
|
obj->len);
|
|
|
|
deconst->trash_stack[UCL_TRASH_VALUE][obj->len] = '\0';
|
|
|
|
deconst->value.sv = obj->trash_stack[UCL_TRASH_VALUE];
|
|
|
|
}
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* Just emit value in json notation */
|
|
|
|
deconst->trash_stack[UCL_TRASH_VALUE] = ucl_object_emit_single_json (obj);
|
|
|
|
deconst->len = strlen (obj->trash_stack[UCL_TRASH_VALUE]);
|
|
|
|
}
|
|
|
|
deconst->flags |= UCL_OBJECT_ALLOCATED_VALUE;
|
|
|
|
}
|
2015-12-27 16:12:28 +01:00
|
|
|
|
2015-02-21 19:11:12 +01:00
|
|
|
return obj->trash_stack[UCL_TRASH_VALUE];
|
|
|
|
}
|
|
|
|
|
2015-07-28 17:57:15 +02:00
|
|
|
ucl_object_t*
|
2015-02-21 19:11:12 +01:00
|
|
|
ucl_parser_get_object (struct ucl_parser *parser)
|
|
|
|
{
|
|
|
|
if (parser->state != UCL_STATE_ERROR && parser->top_obj != NULL) {
|
|
|
|
return ucl_object_ref (parser->top_obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-07-28 17:57:15 +02:00
|
|
|
void
|
2015-02-21 19:11:12 +01:00
|
|
|
ucl_parser_free (struct ucl_parser *parser)
|
|
|
|
{
|
|
|
|
struct ucl_stack *stack, *stmp;
|
|
|
|
struct ucl_macro *macro, *mtmp;
|
|
|
|
struct ucl_chunk *chunk, *ctmp;
|
|
|
|
struct ucl_pubkey *key, *ktmp;
|
|
|
|
struct ucl_variable *var, *vtmp;
|
2015-04-28 15:39:25 +02:00
|
|
|
ucl_object_t *tr, *trtmp;
|
2015-02-21 19:11:12 +01:00
|
|
|
|
|
|
|
if (parser == NULL) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (parser->top_obj != NULL) {
|
|
|
|
ucl_object_unref (parser->top_obj);
|
|
|
|
}
|
|
|
|
|
2015-07-28 17:57:15 +02:00
|
|
|
if (parser->includepaths != NULL) {
|
|
|
|
ucl_object_unref (parser->includepaths);
|
|
|
|
}
|
|
|
|
|
2015-02-21 19:11:12 +01:00
|
|
|
LL_FOREACH_SAFE (parser->stack, stack, stmp) {
|
|
|
|
free (stack);
|
|
|
|
}
|
|
|
|
HASH_ITER (hh, parser->macroes, macro, mtmp) {
|
|
|
|
free (macro->name);
|
|
|
|
HASH_DEL (parser->macroes, macro);
|
|
|
|
UCL_FREE (sizeof (struct ucl_macro), macro);
|
|
|
|
}
|
|
|
|
LL_FOREACH_SAFE (parser->chunks, chunk, ctmp) {
|
2018-05-05 15:58:37 +02:00
|
|
|
ucl_chunk_free (chunk);
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
LL_FOREACH_SAFE (parser->keys, key, ktmp) {
|
|
|
|
UCL_FREE (sizeof (struct ucl_pubkey), key);
|
|
|
|
}
|
|
|
|
LL_FOREACH_SAFE (parser->variables, var, vtmp) {
|
|
|
|
free (var->value);
|
|
|
|
free (var->var);
|
|
|
|
UCL_FREE (sizeof (struct ucl_variable), var);
|
|
|
|
}
|
2015-04-28 15:39:25 +02:00
|
|
|
LL_FOREACH_SAFE (parser->trash_objs, tr, trtmp) {
|
2015-05-17 17:10:29 +02:00
|
|
|
ucl_object_free_internal (tr, false, ucl_object_dtor_free);
|
2015-04-28 15:39:25 +02:00
|
|
|
}
|
2015-02-21 19:11:12 +01:00
|
|
|
|
|
|
|
if (parser->err != NULL) {
|
|
|
|
utstring_free (parser->err);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (parser->cur_file) {
|
|
|
|
free (parser->cur_file);
|
|
|
|
}
|
|
|
|
|
2016-02-08 19:26:58 +01:00
|
|
|
if (parser->comments) {
|
|
|
|
ucl_object_unref (parser->comments);
|
|
|
|
}
|
|
|
|
|
2015-02-21 19:11:12 +01:00
|
|
|
UCL_FREE (sizeof (struct ucl_parser), parser);
|
|
|
|
}
|
|
|
|
|
2015-07-28 17:57:15 +02:00
|
|
|
const char *
|
2015-02-21 19:11:12 +01:00
|
|
|
ucl_parser_get_error(struct ucl_parser *parser)
|
|
|
|
{
|
|
|
|
if (parser == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-07-28 17:57:15 +02:00
|
|
|
if (parser->err == NULL) {
|
2015-02-21 19:11:12 +01:00
|
|
|
return NULL;
|
2015-07-28 17:57:15 +02:00
|
|
|
}
|
2015-02-21 19:11:12 +01:00
|
|
|
|
2015-05-17 17:10:29 +02:00
|
|
|
return utstring_body (parser->err);
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
|
2015-07-28 17:57:15 +02:00
|
|
|
int
|
|
|
|
ucl_parser_get_error_code(struct ucl_parser *parser)
|
|
|
|
{
|
|
|
|
if (parser == NULL) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return parser->err_code;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned
|
|
|
|
ucl_parser_get_column(struct ucl_parser *parser)
|
|
|
|
{
|
|
|
|
if (parser == NULL || parser->chunks == NULL) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return parser->chunks->column;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned
|
|
|
|
ucl_parser_get_linenum(struct ucl_parser *parser)
|
|
|
|
{
|
|
|
|
if (parser == NULL || parser->chunks == NULL) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return parser->chunks->line;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2015-02-21 19:11:12 +01:00
|
|
|
ucl_parser_clear_error(struct ucl_parser *parser)
|
|
|
|
{
|
|
|
|
if (parser != NULL && parser->err != NULL) {
|
|
|
|
utstring_free(parser->err);
|
|
|
|
parser->err = NULL;
|
2015-07-28 17:57:15 +02:00
|
|
|
parser->err_code = 0;
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-07-28 17:57:15 +02:00
|
|
|
bool
|
2015-02-21 19:11:12 +01:00
|
|
|
ucl_pubkey_add (struct ucl_parser *parser, const unsigned char *key, size_t len)
|
|
|
|
{
|
|
|
|
#ifndef HAVE_OPENSSL
|
|
|
|
ucl_create_err (&parser->err, "cannot check signatures without openssl");
|
|
|
|
return false;
|
|
|
|
#else
|
|
|
|
# if (OPENSSL_VERSION_NUMBER < 0x10000000L)
|
|
|
|
ucl_create_err (&parser->err, "cannot check signatures, openssl version is unsupported");
|
|
|
|
return EXIT_FAILURE;
|
|
|
|
# else
|
|
|
|
struct ucl_pubkey *nkey;
|
|
|
|
BIO *mem;
|
|
|
|
|
|
|
|
mem = BIO_new_mem_buf ((void *)key, len);
|
|
|
|
nkey = UCL_ALLOC (sizeof (struct ucl_pubkey));
|
|
|
|
if (nkey == NULL) {
|
|
|
|
ucl_create_err (&parser->err, "cannot allocate memory for key");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
nkey->key = PEM_read_bio_PUBKEY (mem, &nkey->key, NULL, NULL);
|
|
|
|
BIO_free (mem);
|
|
|
|
if (nkey->key == NULL) {
|
|
|
|
UCL_FREE (sizeof (struct ucl_pubkey), nkey);
|
|
|
|
ucl_create_err (&parser->err, "%s",
|
|
|
|
ERR_error_string (ERR_get_error (), NULL));
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
LL_PREPEND (parser->keys, nkey);
|
|
|
|
# endif
|
|
|
|
#endif
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2018-05-05 15:58:37 +02:00
|
|
|
void ucl_parser_add_special_handler (struct ucl_parser *parser,
|
|
|
|
struct ucl_parser_special_handler *handler)
|
|
|
|
{
|
|
|
|
LL_APPEND (parser->special_handlers, handler);
|
|
|
|
}
|
|
|
|
|
2015-02-21 19:11:12 +01:00
|
|
|
#ifdef CURL_FOUND
|
|
|
|
struct ucl_curl_cbdata {
|
|
|
|
unsigned char *buf;
|
|
|
|
size_t buflen;
|
|
|
|
};
|
|
|
|
|
|
|
|
static size_t
|
|
|
|
ucl_curl_write_callback (void* contents, size_t size, size_t nmemb, void* ud)
|
|
|
|
{
|
|
|
|
struct ucl_curl_cbdata *cbdata = ud;
|
|
|
|
size_t realsize = size * nmemb;
|
|
|
|
|
|
|
|
cbdata->buf = realloc (cbdata->buf, cbdata->buflen + realsize + 1);
|
|
|
|
if (cbdata->buf == NULL) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
memcpy (&(cbdata->buf[cbdata->buflen]), contents, realsize);
|
|
|
|
cbdata->buflen += realsize;
|
|
|
|
cbdata->buf[cbdata->buflen] = 0;
|
|
|
|
|
|
|
|
return realsize;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Fetch a url and save results to the memory buffer
|
|
|
|
* @param url url to fetch
|
|
|
|
* @param len length of url
|
|
|
|
* @param buf target buffer
|
|
|
|
* @param buflen target length
|
|
|
|
* @return
|
|
|
|
*/
|
2015-12-27 16:12:28 +01:00
|
|
|
bool
|
2015-02-21 19:11:12 +01:00
|
|
|
ucl_fetch_url (const unsigned char *url, unsigned char **buf, size_t *buflen,
|
|
|
|
UT_string **err, bool must_exist)
|
|
|
|
{
|
|
|
|
|
|
|
|
#ifdef HAVE_FETCH_H
|
|
|
|
struct url *fetch_url;
|
|
|
|
struct url_stat us;
|
|
|
|
FILE *in;
|
|
|
|
|
|
|
|
fetch_url = fetchParseURL (url);
|
|
|
|
if (fetch_url == NULL) {
|
|
|
|
ucl_create_err (err, "invalid URL %s: %s",
|
|
|
|
url, strerror (errno));
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if ((in = fetchXGet (fetch_url, &us, "")) == NULL) {
|
|
|
|
if (!must_exist) {
|
|
|
|
ucl_create_err (err, "cannot fetch URL %s: %s",
|
|
|
|
url, strerror (errno));
|
|
|
|
}
|
|
|
|
fetchFreeURL (fetch_url);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
*buflen = us.size;
|
|
|
|
*buf = malloc (*buflen);
|
|
|
|
if (*buf == NULL) {
|
|
|
|
ucl_create_err (err, "cannot allocate buffer for URL %s: %s",
|
|
|
|
url, strerror (errno));
|
|
|
|
fclose (in);
|
|
|
|
fetchFreeURL (fetch_url);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (fread (*buf, *buflen, 1, in) != 1) {
|
|
|
|
ucl_create_err (err, "cannot read URL %s: %s",
|
|
|
|
url, strerror (errno));
|
|
|
|
fclose (in);
|
|
|
|
fetchFreeURL (fetch_url);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
fetchFreeURL (fetch_url);
|
|
|
|
return true;
|
|
|
|
#elif defined(CURL_FOUND)
|
|
|
|
CURL *curl;
|
|
|
|
int r;
|
|
|
|
struct ucl_curl_cbdata cbdata;
|
|
|
|
|
|
|
|
curl = curl_easy_init ();
|
|
|
|
if (curl == NULL) {
|
|
|
|
ucl_create_err (err, "CURL interface is broken");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if ((r = curl_easy_setopt (curl, CURLOPT_URL, url)) != CURLE_OK) {
|
|
|
|
ucl_create_err (err, "invalid URL %s: %s",
|
|
|
|
url, curl_easy_strerror (r));
|
|
|
|
curl_easy_cleanup (curl);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
curl_easy_setopt (curl, CURLOPT_WRITEFUNCTION, ucl_curl_write_callback);
|
2015-12-27 16:12:28 +01:00
|
|
|
cbdata.buf = NULL;
|
|
|
|
cbdata.buflen = 0;
|
2015-02-21 19:11:12 +01:00
|
|
|
curl_easy_setopt (curl, CURLOPT_WRITEDATA, &cbdata);
|
|
|
|
|
|
|
|
if ((r = curl_easy_perform (curl)) != CURLE_OK) {
|
|
|
|
if (!must_exist) {
|
|
|
|
ucl_create_err (err, "error fetching URL %s: %s",
|
|
|
|
url, curl_easy_strerror (r));
|
|
|
|
}
|
|
|
|
curl_easy_cleanup (curl);
|
|
|
|
if (cbdata.buf) {
|
|
|
|
free (cbdata.buf);
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
*buf = cbdata.buf;
|
|
|
|
*buflen = cbdata.buflen;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
#else
|
|
|
|
ucl_create_err (err, "URL support is disabled");
|
|
|
|
return false;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Fetch a file and save results to the memory buffer
|
|
|
|
* @param filename filename to fetch
|
|
|
|
* @param len length of filename
|
|
|
|
* @param buf target buffer
|
|
|
|
* @param buflen target length
|
|
|
|
* @return
|
|
|
|
*/
|
2015-12-27 16:12:28 +01:00
|
|
|
bool
|
2015-02-21 19:11:12 +01:00
|
|
|
ucl_fetch_file (const unsigned char *filename, unsigned char **buf, size_t *buflen,
|
|
|
|
UT_string **err, bool must_exist)
|
|
|
|
{
|
|
|
|
int fd;
|
|
|
|
struct stat st;
|
2021-10-17 13:47:06 +02:00
|
|
|
if ((fd = open (filename, O_RDONLY)) == -1) {
|
|
|
|
ucl_create_err (err, "cannot open file %s: %s",
|
|
|
|
filename, strerror (errno));
|
|
|
|
return false;
|
|
|
|
}
|
2015-02-21 19:11:12 +01:00
|
|
|
|
2021-10-17 13:47:06 +02:00
|
|
|
if (fstat (fd, &st) == -1) {
|
2018-02-12 21:49:33 +01:00
|
|
|
if (must_exist || errno == EPERM) {
|
2015-02-21 19:11:12 +01:00
|
|
|
ucl_create_err (err, "cannot stat file %s: %s",
|
|
|
|
filename, strerror (errno));
|
|
|
|
}
|
2021-10-17 13:47:06 +02:00
|
|
|
close (fd);
|
|
|
|
|
2015-02-21 19:11:12 +01:00
|
|
|
return false;
|
|
|
|
}
|
2018-02-12 21:49:33 +01:00
|
|
|
if (!S_ISREG (st.st_mode)) {
|
|
|
|
if (must_exist) {
|
|
|
|
ucl_create_err (err, "file %s is not a regular file", filename);
|
|
|
|
}
|
2021-10-17 13:47:06 +02:00
|
|
|
close (fd);
|
2018-02-12 21:49:33 +01:00
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
2021-10-17 13:47:06 +02:00
|
|
|
|
2015-02-21 19:11:12 +01:00
|
|
|
if (st.st_size == 0) {
|
|
|
|
/* Do not map empty files */
|
2015-12-27 16:12:28 +01:00
|
|
|
*buf = NULL;
|
2015-02-21 19:11:12 +01:00
|
|
|
*buflen = 0;
|
|
|
|
}
|
|
|
|
else {
|
2021-10-17 13:47:06 +02:00
|
|
|
if ((*buf = ucl_mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
|
|
|
|
close(fd);
|
|
|
|
ucl_create_err(err, "cannot mmap file %s: %s",
|
|
|
|
filename, strerror(errno));
|
2016-02-22 18:16:14 +01:00
|
|
|
*buf = NULL;
|
|
|
|
|
2015-02-21 19:11:12 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
*buflen = st.st_size;
|
|
|
|
}
|
|
|
|
|
2021-10-17 13:47:06 +02:00
|
|
|
close (fd);
|
|
|
|
|
2015-02-21 19:11:12 +01:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#if (defined(HAVE_OPENSSL) && OPENSSL_VERSION_NUMBER >= 0x10000000L)
|
|
|
|
static inline bool
|
|
|
|
ucl_sig_check (const unsigned char *data, size_t datalen,
|
|
|
|
const unsigned char *sig, size_t siglen, struct ucl_parser *parser)
|
|
|
|
{
|
|
|
|
struct ucl_pubkey *key;
|
|
|
|
char dig[EVP_MAX_MD_SIZE];
|
|
|
|
unsigned int diglen;
|
|
|
|
EVP_PKEY_CTX *key_ctx;
|
|
|
|
EVP_MD_CTX *sign_ctx = NULL;
|
|
|
|
|
|
|
|
sign_ctx = EVP_MD_CTX_create ();
|
|
|
|
|
|
|
|
LL_FOREACH (parser->keys, key) {
|
|
|
|
key_ctx = EVP_PKEY_CTX_new (key->key, NULL);
|
|
|
|
if (key_ctx != NULL) {
|
|
|
|
if (EVP_PKEY_verify_init (key_ctx) <= 0) {
|
|
|
|
EVP_PKEY_CTX_free (key_ctx);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (EVP_PKEY_CTX_set_rsa_padding (key_ctx, RSA_PKCS1_PADDING) <= 0) {
|
|
|
|
EVP_PKEY_CTX_free (key_ctx);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (EVP_PKEY_CTX_set_signature_md (key_ctx, EVP_sha256 ()) <= 0) {
|
|
|
|
EVP_PKEY_CTX_free (key_ctx);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
EVP_DigestInit (sign_ctx, EVP_sha256 ());
|
|
|
|
EVP_DigestUpdate (sign_ctx, data, datalen);
|
|
|
|
EVP_DigestFinal (sign_ctx, dig, &diglen);
|
|
|
|
|
|
|
|
if (EVP_PKEY_verify (key_ctx, sig, siglen, dig, diglen) == 1) {
|
|
|
|
EVP_MD_CTX_destroy (sign_ctx);
|
|
|
|
EVP_PKEY_CTX_free (key_ctx);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
EVP_PKEY_CTX_free (key_ctx);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
EVP_MD_CTX_destroy (sign_ctx);
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2015-10-13 18:05:19 +02:00
|
|
|
struct ucl_include_params {
|
|
|
|
bool check_signature;
|
|
|
|
bool must_exist;
|
|
|
|
bool use_glob;
|
|
|
|
bool use_prefix;
|
|
|
|
bool soft_fail;
|
|
|
|
bool allow_glob;
|
|
|
|
unsigned priority;
|
|
|
|
enum ucl_duplicate_strategy strat;
|
|
|
|
enum ucl_parse_type parse_type;
|
|
|
|
const char *prefix;
|
|
|
|
const char *target;
|
|
|
|
};
|
|
|
|
|
2015-02-21 19:11:12 +01:00
|
|
|
/**
|
|
|
|
* Include an url to configuration
|
|
|
|
* @param data
|
|
|
|
* @param len
|
|
|
|
* @param parser
|
|
|
|
* @param err
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
static bool
|
|
|
|
ucl_include_url (const unsigned char *data, size_t len,
|
2015-10-13 18:05:19 +02:00
|
|
|
struct ucl_parser *parser,
|
|
|
|
struct ucl_include_params *params)
|
2015-02-21 19:11:12 +01:00
|
|
|
{
|
|
|
|
|
|
|
|
bool res;
|
|
|
|
unsigned char *buf = NULL;
|
|
|
|
size_t buflen = 0;
|
|
|
|
struct ucl_chunk *chunk;
|
|
|
|
char urlbuf[PATH_MAX];
|
|
|
|
int prev_state;
|
|
|
|
|
|
|
|
snprintf (urlbuf, sizeof (urlbuf), "%.*s", (int)len, data);
|
|
|
|
|
2015-10-13 18:05:19 +02:00
|
|
|
if (!ucl_fetch_url (urlbuf, &buf, &buflen, &parser->err, params->must_exist)) {
|
2015-12-27 16:12:28 +01:00
|
|
|
return !params->must_exist;
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
|
2015-10-13 18:05:19 +02:00
|
|
|
if (params->check_signature) {
|
2015-02-21 19:11:12 +01:00
|
|
|
#if (defined(HAVE_OPENSSL) && OPENSSL_VERSION_NUMBER >= 0x10000000L)
|
|
|
|
unsigned char *sigbuf = NULL;
|
|
|
|
size_t siglen = 0;
|
|
|
|
/* We need to check signature first */
|
|
|
|
snprintf (urlbuf, sizeof (urlbuf), "%.*s.sig", (int)len, data);
|
|
|
|
if (!ucl_fetch_url (urlbuf, &sigbuf, &siglen, &parser->err, true)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (!ucl_sig_check (buf, buflen, sigbuf, siglen, parser)) {
|
|
|
|
ucl_create_err (&parser->err, "cannot verify url %s: %s",
|
|
|
|
urlbuf,
|
|
|
|
ERR_error_string (ERR_get_error (), NULL));
|
|
|
|
if (siglen > 0) {
|
|
|
|
ucl_munmap (sigbuf, siglen);
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (siglen > 0) {
|
|
|
|
ucl_munmap (sigbuf, siglen);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
prev_state = parser->state;
|
|
|
|
parser->state = UCL_STATE_INIT;
|
|
|
|
|
2015-10-13 18:05:19 +02:00
|
|
|
res = ucl_parser_add_chunk_full (parser, buf, buflen, params->priority,
|
|
|
|
params->strat, params->parse_type);
|
2015-02-21 19:11:12 +01:00
|
|
|
if (res == true) {
|
|
|
|
/* Remove chunk from the stack */
|
|
|
|
chunk = parser->chunks;
|
|
|
|
if (chunk != NULL) {
|
|
|
|
parser->chunks = chunk->next;
|
2018-05-05 15:58:37 +02:00
|
|
|
ucl_chunk_free (chunk);
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
parser->state = prev_state;
|
|
|
|
free (buf);
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Include a single file to the parser
|
|
|
|
* @param data
|
|
|
|
* @param len
|
|
|
|
* @param parser
|
|
|
|
* @param check_signature
|
|
|
|
* @param must_exist
|
|
|
|
* @param allow_glob
|
|
|
|
* @param priority
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
static bool
|
|
|
|
ucl_include_file_single (const unsigned char *data, size_t len,
|
2015-10-13 18:05:19 +02:00
|
|
|
struct ucl_parser *parser, struct ucl_include_params *params)
|
2015-02-21 19:11:12 +01:00
|
|
|
{
|
|
|
|
bool res;
|
|
|
|
struct ucl_chunk *chunk;
|
|
|
|
unsigned char *buf = NULL;
|
2015-07-28 17:57:15 +02:00
|
|
|
char *old_curfile, *ext;
|
|
|
|
size_t buflen = 0;
|
2015-02-21 19:11:12 +01:00
|
|
|
char filebuf[PATH_MAX], realbuf[PATH_MAX];
|
|
|
|
int prev_state;
|
|
|
|
struct ucl_variable *cur_var, *tmp_var, *old_curdir = NULL,
|
|
|
|
*old_filename = NULL;
|
2015-07-28 17:57:15 +02:00
|
|
|
ucl_object_t *nest_obj = NULL, *old_obj = NULL, *new_obj = NULL;
|
|
|
|
ucl_hash_t *container = NULL;
|
|
|
|
struct ucl_stack *st = NULL;
|
2015-02-21 19:11:12 +01:00
|
|
|
|
|
|
|
snprintf (filebuf, sizeof (filebuf), "%.*s", (int)len, data);
|
|
|
|
if (ucl_realpath (filebuf, realbuf) == NULL) {
|
2015-10-13 18:05:19 +02:00
|
|
|
if (params->soft_fail) {
|
2015-07-28 17:57:15 +02:00
|
|
|
return false;
|
|
|
|
}
|
2018-02-12 21:49:33 +01:00
|
|
|
if (!params->must_exist && errno != EPERM) {
|
2015-02-21 19:11:12 +01:00
|
|
|
return true;
|
|
|
|
}
|
2018-02-12 21:49:33 +01:00
|
|
|
|
2015-02-21 19:11:12 +01:00
|
|
|
ucl_create_err (&parser->err, "cannot open file %s: %s",
|
|
|
|
filebuf,
|
|
|
|
strerror (errno));
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (parser->cur_file && strcmp (realbuf, parser->cur_file) == 0) {
|
|
|
|
/* We are likely including the file itself */
|
2015-10-13 18:05:19 +02:00
|
|
|
if (params->soft_fail) {
|
2015-07-28 17:57:15 +02:00
|
|
|
return false;
|
|
|
|
}
|
2015-10-13 18:05:19 +02:00
|
|
|
|
2015-02-21 19:11:12 +01:00
|
|
|
ucl_create_err (&parser->err, "trying to include the file %s from itself",
|
|
|
|
realbuf);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-10-13 18:05:19 +02:00
|
|
|
if (!ucl_fetch_file (realbuf, &buf, &buflen, &parser->err, params->must_exist)) {
|
|
|
|
if (params->soft_fail) {
|
2015-07-28 17:57:15 +02:00
|
|
|
return false;
|
|
|
|
}
|
2016-04-18 19:30:08 +02:00
|
|
|
|
2018-02-12 21:49:33 +01:00
|
|
|
if (params->must_exist || parser->err != NULL) {
|
|
|
|
/* The case of fatal errors */
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
|
2015-10-13 18:05:19 +02:00
|
|
|
if (params->check_signature) {
|
2015-02-21 19:11:12 +01:00
|
|
|
#if (defined(HAVE_OPENSSL) && OPENSSL_VERSION_NUMBER >= 0x10000000L)
|
|
|
|
unsigned char *sigbuf = NULL;
|
|
|
|
size_t siglen = 0;
|
|
|
|
/* We need to check signature first */
|
|
|
|
snprintf (filebuf, sizeof (filebuf), "%s.sig", realbuf);
|
|
|
|
if (!ucl_fetch_file (filebuf, &sigbuf, &siglen, &parser->err, true)) {
|
2021-10-17 13:47:06 +02:00
|
|
|
if (buf) {
|
|
|
|
ucl_munmap (buf, buflen);
|
|
|
|
}
|
|
|
|
|
2015-02-21 19:11:12 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (!ucl_sig_check (buf, buflen, sigbuf, siglen, parser)) {
|
|
|
|
ucl_create_err (&parser->err, "cannot verify file %s: %s",
|
|
|
|
filebuf,
|
|
|
|
ERR_error_string (ERR_get_error (), NULL));
|
2016-02-22 18:16:14 +01:00
|
|
|
if (sigbuf) {
|
2015-02-21 19:11:12 +01:00
|
|
|
ucl_munmap (sigbuf, siglen);
|
|
|
|
}
|
2021-10-17 13:47:06 +02:00
|
|
|
if (buf) {
|
|
|
|
ucl_munmap (buf, buflen);
|
|
|
|
}
|
|
|
|
|
2015-02-21 19:11:12 +01:00
|
|
|
return false;
|
|
|
|
}
|
2021-10-17 13:47:06 +02:00
|
|
|
|
2016-02-22 18:16:14 +01:00
|
|
|
if (sigbuf) {
|
2015-02-21 19:11:12 +01:00
|
|
|
ucl_munmap (sigbuf, siglen);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
old_curfile = parser->cur_file;
|
2018-12-13 15:06:13 +01:00
|
|
|
parser->cur_file = NULL;
|
2015-02-21 19:11:12 +01:00
|
|
|
|
|
|
|
/* Store old file vars */
|
|
|
|
DL_FOREACH_SAFE (parser->variables, cur_var, tmp_var) {
|
|
|
|
if (strcmp (cur_var->var, "CURDIR") == 0) {
|
|
|
|
old_curdir = cur_var;
|
|
|
|
DL_DELETE (parser->variables, cur_var);
|
|
|
|
}
|
|
|
|
else if (strcmp (cur_var->var, "FILENAME") == 0) {
|
|
|
|
old_filename = cur_var;
|
|
|
|
DL_DELETE (parser->variables, cur_var);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ucl_parser_set_filevars (parser, realbuf, false);
|
|
|
|
|
|
|
|
prev_state = parser->state;
|
|
|
|
parser->state = UCL_STATE_INIT;
|
|
|
|
|
2015-10-13 18:05:19 +02:00
|
|
|
if (params->use_prefix && params->prefix == NULL) {
|
2015-07-28 17:57:15 +02:00
|
|
|
/* Auto generate a key name based on the included filename */
|
2015-10-13 18:05:19 +02:00
|
|
|
params->prefix = basename (realbuf);
|
|
|
|
ext = strrchr (params->prefix, '.');
|
2015-07-28 17:57:15 +02:00
|
|
|
if (ext != NULL && (strcmp (ext, ".conf") == 0 || strcmp (ext, ".ucl") == 0)) {
|
|
|
|
/* Strip off .conf or .ucl */
|
|
|
|
*ext = '\0';
|
|
|
|
}
|
|
|
|
}
|
2015-10-13 18:05:19 +02:00
|
|
|
if (params->prefix != NULL) {
|
2015-07-28 17:57:15 +02:00
|
|
|
/* This is a prefixed include */
|
|
|
|
container = parser->stack->obj->value.ov;
|
|
|
|
|
2015-10-13 18:05:19 +02:00
|
|
|
old_obj = __DECONST (ucl_object_t *, ucl_hash_search (container,
|
|
|
|
params->prefix, strlen (params->prefix)));
|
2015-07-28 17:57:15 +02:00
|
|
|
|
2018-03-21 14:08:45 +01:00
|
|
|
if (strcasecmp (params->target, "array") == 0) {
|
|
|
|
if (old_obj == NULL) {
|
|
|
|
/* Create an array with key: prefix */
|
|
|
|
old_obj = ucl_object_new_full (UCL_ARRAY, params->priority);
|
|
|
|
old_obj->key = params->prefix;
|
|
|
|
old_obj->keylen = strlen (params->prefix);
|
|
|
|
ucl_copy_key_trash (old_obj);
|
|
|
|
old_obj->prev = old_obj;
|
|
|
|
old_obj->next = NULL;
|
2015-07-28 17:57:15 +02:00
|
|
|
|
2018-03-21 14:08:45 +01:00
|
|
|
container = ucl_hash_insert_object (container, old_obj,
|
|
|
|
parser->flags & UCL_PARSER_KEY_LOWERCASE);
|
|
|
|
parser->stack->obj->len++;
|
2015-07-28 17:57:15 +02:00
|
|
|
|
2018-03-21 14:08:45 +01:00
|
|
|
nest_obj = ucl_object_new_full (UCL_OBJECT, params->priority);
|
|
|
|
nest_obj->prev = nest_obj;
|
|
|
|
nest_obj->next = NULL;
|
2015-07-28 17:57:15 +02:00
|
|
|
|
2018-03-21 14:08:45 +01:00
|
|
|
ucl_array_append (old_obj, nest_obj);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (ucl_object_type (old_obj) == UCL_ARRAY) {
|
|
|
|
/* Append to the existing array */
|
|
|
|
nest_obj = ucl_object_new_full (UCL_OBJECT,
|
|
|
|
params->priority);
|
|
|
|
if (nest_obj == NULL) {
|
|
|
|
ucl_create_err (&parser->err,
|
|
|
|
"cannot allocate memory for an object");
|
|
|
|
if (buf) {
|
|
|
|
ucl_munmap (buf, buflen);
|
|
|
|
}
|
2016-02-08 19:26:58 +01:00
|
|
|
|
2018-03-21 14:08:45 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
nest_obj->prev = nest_obj;
|
|
|
|
nest_obj->next = NULL;
|
|
|
|
|
|
|
|
ucl_array_append (old_obj, nest_obj);
|
2016-02-08 19:26:58 +01:00
|
|
|
}
|
2018-03-21 14:08:45 +01:00
|
|
|
else {
|
|
|
|
/* Convert the object to an array */
|
|
|
|
new_obj = ucl_object_typed_new (UCL_ARRAY);
|
|
|
|
if (new_obj == NULL) {
|
|
|
|
ucl_create_err (&parser->err,
|
|
|
|
"cannot allocate memory for an object");
|
|
|
|
if (buf) {
|
|
|
|
ucl_munmap (buf, buflen);
|
|
|
|
}
|
2016-02-08 19:26:58 +01:00
|
|
|
|
2018-03-21 14:08:45 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
new_obj->key = old_obj->key;
|
|
|
|
new_obj->keylen = old_obj->keylen;
|
|
|
|
new_obj->flags |= UCL_OBJECT_MULTIVALUE;
|
|
|
|
new_obj->prev = new_obj;
|
|
|
|
new_obj->next = NULL;
|
|
|
|
|
|
|
|
nest_obj = ucl_object_new_full (UCL_OBJECT,
|
|
|
|
params->priority);
|
|
|
|
if (nest_obj == NULL) {
|
|
|
|
ucl_create_err (&parser->err,
|
|
|
|
"cannot allocate memory for an object");
|
|
|
|
if (buf) {
|
|
|
|
ucl_munmap (buf, buflen);
|
|
|
|
}
|
2016-02-08 19:26:58 +01:00
|
|
|
|
2021-10-17 13:47:06 +02:00
|
|
|
ucl_object_unref (new_obj);
|
|
|
|
|
2018-03-21 14:08:45 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
nest_obj->prev = nest_obj;
|
|
|
|
nest_obj->next = NULL;
|
2015-07-28 17:57:15 +02:00
|
|
|
|
2018-03-21 14:08:45 +01:00
|
|
|
ucl_array_append (new_obj, old_obj);
|
|
|
|
ucl_array_append (new_obj, nest_obj);
|
|
|
|
ucl_hash_replace (container, old_obj, new_obj);
|
|
|
|
}
|
|
|
|
}
|
2015-07-28 17:57:15 +02:00
|
|
|
}
|
2018-03-21 14:08:45 +01:00
|
|
|
else {
|
|
|
|
/* Case of object */
|
|
|
|
if (old_obj == NULL) {
|
|
|
|
/* Create an object with key: prefix */
|
2015-10-13 18:05:19 +02:00
|
|
|
nest_obj = ucl_object_new_full (UCL_OBJECT, params->priority);
|
2018-03-21 14:08:45 +01:00
|
|
|
|
2016-02-08 19:26:58 +01:00
|
|
|
if (nest_obj == NULL) {
|
|
|
|
ucl_create_err (&parser->err, "cannot allocate memory for an object");
|
2016-02-22 18:16:14 +01:00
|
|
|
if (buf) {
|
2016-02-08 19:26:58 +01:00
|
|
|
ucl_munmap (buf, buflen);
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
2018-03-21 14:08:45 +01:00
|
|
|
|
|
|
|
nest_obj->key = params->prefix;
|
|
|
|
nest_obj->keylen = strlen (params->prefix);
|
|
|
|
ucl_copy_key_trash(nest_obj);
|
2015-07-28 17:57:15 +02:00
|
|
|
nest_obj->prev = nest_obj;
|
|
|
|
nest_obj->next = NULL;
|
|
|
|
|
2018-03-21 14:08:45 +01:00
|
|
|
container = ucl_hash_insert_object (container, nest_obj,
|
|
|
|
parser->flags & UCL_PARSER_KEY_LOWERCASE);
|
|
|
|
parser->stack->obj->len ++;
|
2015-07-28 17:57:15 +02:00
|
|
|
}
|
|
|
|
else {
|
2018-03-21 14:08:45 +01:00
|
|
|
if (ucl_object_type (old_obj) == UCL_OBJECT) {
|
|
|
|
/* Append to existing Object*/
|
|
|
|
nest_obj = old_obj;
|
2016-02-08 19:26:58 +01:00
|
|
|
}
|
2018-03-21 14:08:45 +01:00
|
|
|
else {
|
|
|
|
/* The key is not an object */
|
|
|
|
ucl_create_err (&parser->err,
|
|
|
|
"Conflicting type for key: %s, asked %s, has %s",
|
|
|
|
params->prefix, params->target,
|
|
|
|
ucl_object_type_to_string (ucl_object_type (old_obj)));
|
2016-02-22 18:16:14 +01:00
|
|
|
if (buf) {
|
2016-02-08 19:26:58 +01:00
|
|
|
ucl_munmap (buf, buflen);
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
2015-07-28 17:57:15 +02:00
|
|
|
}
|
|
|
|
}
|
2016-02-08 19:26:58 +01:00
|
|
|
|
2015-07-28 17:57:15 +02:00
|
|
|
|
2018-03-21 14:08:45 +01:00
|
|
|
/* Put all of the content of the include inside that object */
|
2015-07-28 17:57:15 +02:00
|
|
|
parser->stack->obj->value.ov = container;
|
|
|
|
|
2016-02-22 18:16:14 +01:00
|
|
|
st = UCL_ALLOC (sizeof (struct ucl_stack));
|
|
|
|
if (st == NULL) {
|
|
|
|
ucl_create_err (&parser->err, "cannot allocate memory for an object");
|
|
|
|
ucl_object_unref (nest_obj);
|
2016-02-08 19:26:58 +01:00
|
|
|
|
2016-02-22 18:16:14 +01:00
|
|
|
if (buf) {
|
|
|
|
ucl_munmap (buf, buflen);
|
2015-07-28 17:57:15 +02:00
|
|
|
}
|
2016-02-22 18:16:14 +01:00
|
|
|
|
|
|
|
return false;
|
2015-07-28 17:57:15 +02:00
|
|
|
}
|
2016-02-22 18:16:14 +01:00
|
|
|
st->obj = nest_obj;
|
2018-10-05 21:01:28 +02:00
|
|
|
st->e.params.level = parser->stack->e.params.level;
|
|
|
|
st->e.params.flags = parser->stack->e.params.flags;
|
|
|
|
st->e.params.line = parser->stack->e.params.line;
|
|
|
|
st->chunk = parser->chunks;
|
2016-02-22 18:16:14 +01:00
|
|
|
LL_PREPEND (parser->stack, st);
|
|
|
|
parser->cur_obj = nest_obj;
|
2015-07-28 17:57:15 +02:00
|
|
|
}
|
|
|
|
|
2015-10-13 18:05:19 +02:00
|
|
|
res = ucl_parser_add_chunk_full (parser, buf, buflen, params->priority,
|
|
|
|
params->strat, params->parse_type);
|
2016-04-18 19:30:08 +02:00
|
|
|
|
2018-11-12 17:37:25 +01:00
|
|
|
if (res) {
|
|
|
|
/* Stop nesting the include, take 1 level off the stack */
|
|
|
|
if (params->prefix != NULL && nest_obj != NULL) {
|
|
|
|
parser->stack = st->next;
|
|
|
|
UCL_FREE (sizeof (struct ucl_stack), st);
|
2016-04-18 19:30:08 +02:00
|
|
|
}
|
2015-07-28 17:57:15 +02:00
|
|
|
|
2018-11-12 17:37:25 +01:00
|
|
|
/* Remove chunk from the stack */
|
|
|
|
chunk = parser->chunks;
|
|
|
|
if (chunk != NULL) {
|
|
|
|
parser->chunks = chunk->next;
|
|
|
|
ucl_chunk_free (chunk);
|
|
|
|
parser->recursion--;
|
|
|
|
}
|
2015-02-21 19:11:12 +01:00
|
|
|
|
2018-11-12 17:37:25 +01:00
|
|
|
/* Restore old file vars */
|
|
|
|
if (parser->cur_file) {
|
|
|
|
free (parser->cur_file);
|
|
|
|
}
|
2015-03-11 12:57:17 +01:00
|
|
|
|
2018-11-12 17:37:25 +01:00
|
|
|
parser->cur_file = old_curfile;
|
|
|
|
DL_FOREACH_SAFE (parser->variables, cur_var, tmp_var) {
|
|
|
|
if (strcmp (cur_var->var, "CURDIR") == 0 && old_curdir) {
|
|
|
|
DL_DELETE (parser->variables, cur_var);
|
|
|
|
free (cur_var->var);
|
|
|
|
free (cur_var->value);
|
|
|
|
UCL_FREE (sizeof (struct ucl_variable), cur_var);
|
|
|
|
} else if (strcmp (cur_var->var, "FILENAME") == 0 && old_filename) {
|
|
|
|
DL_DELETE (parser->variables, cur_var);
|
|
|
|
free (cur_var->var);
|
|
|
|
free (cur_var->value);
|
|
|
|
UCL_FREE (sizeof (struct ucl_variable), cur_var);
|
|
|
|
}
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
2018-11-12 17:37:25 +01:00
|
|
|
if (old_filename) {
|
|
|
|
DL_APPEND (parser->variables, old_filename);
|
|
|
|
}
|
|
|
|
if (old_curdir) {
|
|
|
|
DL_APPEND (parser->variables, old_curdir);
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
|
2018-11-12 17:37:25 +01:00
|
|
|
parser->state = prev_state;
|
|
|
|
}
|
2015-02-21 19:11:12 +01:00
|
|
|
|
|
|
|
if (buflen > 0) {
|
|
|
|
ucl_munmap (buf, buflen);
|
|
|
|
}
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Include a file to configuration
|
|
|
|
* @param data
|
|
|
|
* @param len
|
|
|
|
* @param parser
|
|
|
|
* @param err
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
static bool
|
|
|
|
ucl_include_file (const unsigned char *data, size_t len,
|
2019-03-08 19:22:57 +01:00
|
|
|
struct ucl_parser *parser,
|
|
|
|
struct ucl_include_params *params,
|
|
|
|
const ucl_object_t *args)
|
2015-02-21 19:11:12 +01:00
|
|
|
{
|
|
|
|
const unsigned char *p = data, *end = data + len;
|
|
|
|
bool need_glob = false;
|
|
|
|
int cnt = 0;
|
|
|
|
char glob_pattern[PATH_MAX];
|
|
|
|
size_t i;
|
|
|
|
|
|
|
|
#ifndef _WIN32
|
2015-10-13 18:05:19 +02:00
|
|
|
if (!params->allow_glob) {
|
|
|
|
return ucl_include_file_single (data, len, parser, params);
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* Check for special symbols in a filename */
|
|
|
|
while (p != end) {
|
|
|
|
if (*p == '*' || *p == '?') {
|
|
|
|
need_glob = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
p ++;
|
|
|
|
}
|
|
|
|
if (need_glob) {
|
|
|
|
glob_t globbuf;
|
|
|
|
memset (&globbuf, 0, sizeof (globbuf));
|
2015-07-28 17:57:15 +02:00
|
|
|
ucl_strlcpy (glob_pattern, (const char *)data,
|
|
|
|
(len + 1 < sizeof (glob_pattern) ? len + 1 : sizeof (glob_pattern)));
|
2015-02-21 19:11:12 +01:00
|
|
|
if (glob (glob_pattern, 0, NULL, &globbuf) != 0) {
|
2015-10-13 18:05:19 +02:00
|
|
|
return (!params->must_exist || false);
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
for (i = 0; i < globbuf.gl_pathc; i ++) {
|
2019-03-08 19:22:57 +01:00
|
|
|
|
|
|
|
if (parser->include_trace_func) {
|
|
|
|
const ucl_object_t *parent = NULL;
|
|
|
|
|
|
|
|
if (parser->stack) {
|
|
|
|
parent = parser->stack->obj;
|
|
|
|
}
|
|
|
|
|
|
|
|
parser->include_trace_func (parser, parent, NULL,
|
|
|
|
globbuf.gl_pathv[i],
|
|
|
|
strlen (globbuf.gl_pathv[i]),
|
|
|
|
parser->include_trace_ud);
|
|
|
|
}
|
|
|
|
|
2015-02-21 19:11:12 +01:00
|
|
|
if (!ucl_include_file_single ((unsigned char *)globbuf.gl_pathv[i],
|
2015-10-13 18:05:19 +02:00
|
|
|
strlen (globbuf.gl_pathv[i]), parser, params)) {
|
|
|
|
if (params->soft_fail) {
|
2015-07-28 17:57:15 +02:00
|
|
|
continue;
|
|
|
|
}
|
2015-02-21 19:11:12 +01:00
|
|
|
globfree (&globbuf);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
cnt ++;
|
|
|
|
}
|
|
|
|
globfree (&globbuf);
|
|
|
|
|
2015-10-13 18:05:19 +02:00
|
|
|
if (cnt == 0 && params->must_exist) {
|
2015-02-21 19:11:12 +01:00
|
|
|
ucl_create_err (&parser->err, "cannot match any files for pattern %s",
|
|
|
|
glob_pattern);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
2015-10-13 18:05:19 +02:00
|
|
|
return ucl_include_file_single (data, len, parser, params);
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
/* Win32 compilers do not support globbing. Therefore, for Win32,
|
|
|
|
treat allow_glob/need_glob as a NOOP and just return */
|
2015-10-13 18:05:19 +02:00
|
|
|
return ucl_include_file_single (data, len, parser, params);
|
2015-02-21 19:11:12 +01:00
|
|
|
#endif
|
2015-12-27 16:12:28 +01:00
|
|
|
|
2015-02-21 19:11:12 +01:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Common function to handle .*include* macros
|
|
|
|
* @param data
|
|
|
|
* @param len
|
|
|
|
* @param args
|
|
|
|
* @param parser
|
|
|
|
* @param default_try
|
|
|
|
* @param default_sign
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
static bool
|
|
|
|
ucl_include_common (const unsigned char *data, size_t len,
|
|
|
|
const ucl_object_t *args, struct ucl_parser *parser,
|
|
|
|
bool default_try,
|
|
|
|
bool default_sign)
|
|
|
|
{
|
2015-12-27 16:12:28 +01:00
|
|
|
bool allow_url = false, search = false;
|
2015-10-13 18:05:19 +02:00
|
|
|
const char *duplicate;
|
2015-02-21 19:11:12 +01:00
|
|
|
const ucl_object_t *param;
|
2015-07-28 17:57:15 +02:00
|
|
|
ucl_object_iter_t it = NULL, ip = NULL;
|
|
|
|
char ipath[PATH_MAX];
|
2015-10-13 18:05:19 +02:00
|
|
|
struct ucl_include_params params;
|
2015-02-21 19:11:12 +01:00
|
|
|
|
|
|
|
/* Default values */
|
2015-10-13 18:05:19 +02:00
|
|
|
params.soft_fail = default_try;
|
|
|
|
params.allow_glob = false;
|
|
|
|
params.check_signature = default_sign;
|
|
|
|
params.use_prefix = false;
|
|
|
|
params.target = "object";
|
|
|
|
params.prefix = NULL;
|
|
|
|
params.priority = 0;
|
|
|
|
params.parse_type = UCL_PARSE_UCL;
|
|
|
|
params.strat = UCL_DUPLICATE_APPEND;
|
|
|
|
params.must_exist = !default_try;
|
|
|
|
|
2019-03-07 16:29:14 +01:00
|
|
|
if (parser->include_trace_func) {
|
|
|
|
const ucl_object_t *parent = NULL;
|
|
|
|
|
|
|
|
if (parser->stack) {
|
|
|
|
parent = parser->stack->obj;
|
|
|
|
}
|
|
|
|
|
|
|
|
parser->include_trace_func (parser, parent, args,
|
|
|
|
data, len, parser->include_trace_ud);
|
|
|
|
}
|
|
|
|
|
2015-02-21 19:11:12 +01:00
|
|
|
/* Process arguments */
|
|
|
|
if (args != NULL && args->type == UCL_OBJECT) {
|
2016-02-16 10:59:52 +01:00
|
|
|
while ((param = ucl_object_iterate (args, &it, true)) != NULL) {
|
2015-02-21 19:11:12 +01:00
|
|
|
if (param->type == UCL_BOOLEAN) {
|
2015-07-28 17:57:15 +02:00
|
|
|
if (strncmp (param->key, "try", param->keylen) == 0) {
|
2015-10-13 18:05:19 +02:00
|
|
|
params.must_exist = !ucl_object_toboolean (param);
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
2015-07-28 17:57:15 +02:00
|
|
|
else if (strncmp (param->key, "sign", param->keylen) == 0) {
|
2015-10-13 18:05:19 +02:00
|
|
|
params.check_signature = ucl_object_toboolean (param);
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
2015-07-28 17:57:15 +02:00
|
|
|
else if (strncmp (param->key, "glob", param->keylen) == 0) {
|
2015-10-13 18:05:19 +02:00
|
|
|
params.allow_glob = ucl_object_toboolean (param);
|
2015-07-28 17:57:15 +02:00
|
|
|
}
|
|
|
|
else if (strncmp (param->key, "url", param->keylen) == 0) {
|
|
|
|
allow_url = ucl_object_toboolean (param);
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
2015-07-28 17:57:15 +02:00
|
|
|
else if (strncmp (param->key, "prefix", param->keylen) == 0) {
|
2015-10-13 18:05:19 +02:00
|
|
|
params.use_prefix = ucl_object_toboolean (param);
|
2015-07-28 17:57:15 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (param->type == UCL_STRING) {
|
|
|
|
if (strncmp (param->key, "key", param->keylen) == 0) {
|
2015-10-13 18:05:19 +02:00
|
|
|
params.prefix = ucl_object_tostring (param);
|
2015-07-28 17:57:15 +02:00
|
|
|
}
|
|
|
|
else if (strncmp (param->key, "target", param->keylen) == 0) {
|
2015-10-13 18:05:19 +02:00
|
|
|
params.target = ucl_object_tostring (param);
|
|
|
|
}
|
|
|
|
else if (strncmp (param->key, "duplicate", param->keylen) == 0) {
|
|
|
|
duplicate = ucl_object_tostring (param);
|
|
|
|
|
|
|
|
if (strcmp (duplicate, "append") == 0) {
|
|
|
|
params.strat = UCL_DUPLICATE_APPEND;
|
|
|
|
}
|
|
|
|
else if (strcmp (duplicate, "merge") == 0) {
|
|
|
|
params.strat = UCL_DUPLICATE_MERGE;
|
|
|
|
}
|
|
|
|
else if (strcmp (duplicate, "rewrite") == 0) {
|
|
|
|
params.strat = UCL_DUPLICATE_REWRITE;
|
|
|
|
}
|
|
|
|
else if (strcmp (duplicate, "error") == 0) {
|
|
|
|
params.strat = UCL_DUPLICATE_ERROR;
|
|
|
|
}
|
2015-07-28 17:57:15 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (param->type == UCL_ARRAY) {
|
|
|
|
if (strncmp (param->key, "path", param->keylen) == 0) {
|
|
|
|
ucl_set_include_path (parser, __DECONST(ucl_object_t *, param));
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (param->type == UCL_INT) {
|
2015-07-28 17:57:15 +02:00
|
|
|
if (strncmp (param->key, "priority", param->keylen) == 0) {
|
2015-10-13 18:05:19 +02:00
|
|
|
params.priority = ucl_object_toint (param);
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-07-28 17:57:15 +02:00
|
|
|
if (parser->includepaths == NULL) {
|
|
|
|
if (allow_url && ucl_strnstr (data, "://", len) != NULL) {
|
|
|
|
/* Globbing is not used for URL's */
|
2015-10-13 18:05:19 +02:00
|
|
|
return ucl_include_url (data, len, parser, ¶ms);
|
2015-07-28 17:57:15 +02:00
|
|
|
}
|
|
|
|
else if (data != NULL) {
|
|
|
|
/* Try to load a file */
|
2019-03-08 19:22:57 +01:00
|
|
|
return ucl_include_file (data, len, parser, ¶ms, args);
|
2015-07-28 17:57:15 +02:00
|
|
|
}
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
2015-07-28 17:57:15 +02:00
|
|
|
else {
|
|
|
|
if (allow_url && ucl_strnstr (data, "://", len) != NULL) {
|
|
|
|
/* Globbing is not used for URL's */
|
2015-10-13 18:05:19 +02:00
|
|
|
return ucl_include_url (data, len, parser, ¶ms);
|
2015-07-28 17:57:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
ip = ucl_object_iterate_new (parser->includepaths);
|
|
|
|
while ((param = ucl_object_iterate_safe (ip, true)) != NULL) {
|
|
|
|
if (ucl_object_type(param) == UCL_STRING) {
|
|
|
|
snprintf (ipath, sizeof (ipath), "%s/%.*s", ucl_object_tostring(param),
|
|
|
|
(int)len, data);
|
2015-10-13 18:05:19 +02:00
|
|
|
if ((search = ucl_include_file (ipath, strlen (ipath),
|
2019-03-08 19:22:57 +01:00
|
|
|
parser, ¶ms, args))) {
|
2015-10-13 18:05:19 +02:00
|
|
|
if (!params.allow_glob) {
|
2015-07-28 17:57:15 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ucl_object_iterate_free (ip);
|
|
|
|
if (search == true) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
ucl_create_err (&parser->err,
|
|
|
|
"cannot find file: %.*s in search path",
|
|
|
|
(int)len, data);
|
|
|
|
return false;
|
|
|
|
}
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Handle include macro
|
|
|
|
* @param data include data
|
|
|
|
* @param len length of data
|
2015-07-28 17:57:15 +02:00
|
|
|
* @param args UCL object representing arguments to the macro
|
2015-02-21 19:11:12 +01:00
|
|
|
* @param ud user data
|
|
|
|
* @return
|
|
|
|
*/
|
2015-07-28 17:57:15 +02:00
|
|
|
bool
|
2015-02-21 19:11:12 +01:00
|
|
|
ucl_include_handler (const unsigned char *data, size_t len,
|
|
|
|
const ucl_object_t *args, void* ud)
|
|
|
|
{
|
|
|
|
struct ucl_parser *parser = ud;
|
|
|
|
|
|
|
|
return ucl_include_common (data, len, args, parser, false, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Handle includes macro
|
|
|
|
* @param data include data
|
|
|
|
* @param len length of data
|
2015-07-28 17:57:15 +02:00
|
|
|
* @param args UCL object representing arguments to the macro
|
2015-02-21 19:11:12 +01:00
|
|
|
* @param ud user data
|
|
|
|
* @return
|
|
|
|
*/
|
2015-07-28 17:57:15 +02:00
|
|
|
bool
|
2015-02-21 19:11:12 +01:00
|
|
|
ucl_includes_handler (const unsigned char *data, size_t len,
|
|
|
|
const ucl_object_t *args, void* ud)
|
|
|
|
{
|
|
|
|
struct ucl_parser *parser = ud;
|
|
|
|
|
|
|
|
return ucl_include_common (data, len, args, parser, false, true);
|
|
|
|
}
|
|
|
|
|
2015-07-28 17:57:15 +02:00
|
|
|
/**
|
|
|
|
* Handle tryinclude macro
|
|
|
|
* @param data include data
|
|
|
|
* @param len length of data
|
|
|
|
* @param args UCL object representing arguments to the macro
|
|
|
|
* @param ud user data
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
bool
|
2015-02-21 19:11:12 +01:00
|
|
|
ucl_try_include_handler (const unsigned char *data, size_t len,
|
|
|
|
const ucl_object_t *args, void* ud)
|
|
|
|
{
|
|
|
|
struct ucl_parser *parser = ud;
|
|
|
|
|
|
|
|
return ucl_include_common (data, len, args, parser, true, false);
|
|
|
|
}
|
|
|
|
|
2015-07-28 17:57:15 +02:00
|
|
|
/**
|
|
|
|
* Handle priority macro
|
|
|
|
* @param data include data
|
|
|
|
* @param len length of data
|
|
|
|
* @param args UCL object representing arguments to the macro
|
|
|
|
* @param ud user data
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
bool
|
|
|
|
ucl_priority_handler (const unsigned char *data, size_t len,
|
|
|
|
const ucl_object_t *args, void* ud)
|
|
|
|
{
|
|
|
|
struct ucl_parser *parser = ud;
|
|
|
|
unsigned priority = 255;
|
|
|
|
const ucl_object_t *param;
|
|
|
|
bool found = false;
|
|
|
|
char *value = NULL, *leftover = NULL;
|
|
|
|
ucl_object_iter_t it = NULL;
|
|
|
|
|
|
|
|
if (parser == NULL) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Process arguments */
|
|
|
|
if (args != NULL && args->type == UCL_OBJECT) {
|
2016-02-16 10:59:52 +01:00
|
|
|
while ((param = ucl_object_iterate (args, &it, true)) != NULL) {
|
2015-07-28 17:57:15 +02:00
|
|
|
if (param->type == UCL_INT) {
|
|
|
|
if (strncmp (param->key, "priority", param->keylen) == 0) {
|
|
|
|
priority = ucl_object_toint (param);
|
|
|
|
found = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (len > 0) {
|
|
|
|
value = malloc(len + 1);
|
|
|
|
ucl_strlcpy(value, (const char *)data, len + 1);
|
|
|
|
priority = strtol(value, &leftover, 10);
|
|
|
|
if (*leftover != '\0') {
|
|
|
|
ucl_create_err (&parser->err, "Invalid priority value in macro: %s",
|
|
|
|
value);
|
|
|
|
free(value);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
free(value);
|
|
|
|
found = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (found == true) {
|
|
|
|
parser->chunks->priority = priority;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
ucl_create_err (&parser->err, "Unable to parse priority macro");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Handle load macro
|
|
|
|
* @param data include data
|
|
|
|
* @param len length of data
|
|
|
|
* @param args UCL object representing arguments to the macro
|
|
|
|
* @param ud user data
|
|
|
|
* @return
|
|
|
|
*/
|
|
|
|
bool
|
|
|
|
ucl_load_handler (const unsigned char *data, size_t len,
|
|
|
|
const ucl_object_t *args, void* ud)
|
|
|
|
{
|
|
|
|
struct ucl_parser *parser = ud;
|
|
|
|
const ucl_object_t *param;
|
|
|
|
ucl_object_t *obj, *old_obj;
|
|
|
|
ucl_object_iter_t it = NULL;
|
|
|
|
bool try_load, multiline, test;
|
|
|
|
const char *target, *prefix;
|
|
|
|
char *load_file, *tmp;
|
|
|
|
unsigned char *buf;
|
|
|
|
size_t buflen;
|
|
|
|
unsigned priority;
|
|
|
|
int64_t iv;
|
2016-02-14 14:34:42 +01:00
|
|
|
ucl_object_t *container = NULL;
|
2015-07-28 17:57:15 +02:00
|
|
|
enum ucl_string_flags flags;
|
|
|
|
|
|
|
|
/* Default values */
|
|
|
|
try_load = false;
|
|
|
|
multiline = false;
|
|
|
|
test = false;
|
|
|
|
target = "string";
|
|
|
|
prefix = NULL;
|
|
|
|
load_file = NULL;
|
|
|
|
buf = NULL;
|
|
|
|
buflen = 0;
|
|
|
|
priority = 0;
|
|
|
|
obj = NULL;
|
|
|
|
old_obj = NULL;
|
|
|
|
flags = 0;
|
|
|
|
|
|
|
|
if (parser == NULL) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Process arguments */
|
|
|
|
if (args != NULL && args->type == UCL_OBJECT) {
|
2016-02-16 10:59:52 +01:00
|
|
|
while ((param = ucl_object_iterate (args, &it, true)) != NULL) {
|
2015-07-28 17:57:15 +02:00
|
|
|
if (param->type == UCL_BOOLEAN) {
|
|
|
|
if (strncmp (param->key, "try", param->keylen) == 0) {
|
|
|
|
try_load = ucl_object_toboolean (param);
|
|
|
|
}
|
|
|
|
else if (strncmp (param->key, "multiline", param->keylen) == 0) {
|
|
|
|
multiline = ucl_object_toboolean (param);
|
|
|
|
}
|
|
|
|
else if (strncmp (param->key, "escape", param->keylen) == 0) {
|
|
|
|
test = ucl_object_toboolean (param);
|
|
|
|
if (test) {
|
|
|
|
flags |= UCL_STRING_ESCAPE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (strncmp (param->key, "trim", param->keylen) == 0) {
|
|
|
|
test = ucl_object_toboolean (param);
|
|
|
|
if (test) {
|
|
|
|
flags |= UCL_STRING_TRIM;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (param->type == UCL_STRING) {
|
|
|
|
if (strncmp (param->key, "key", param->keylen) == 0) {
|
|
|
|
prefix = ucl_object_tostring (param);
|
|
|
|
}
|
|
|
|
else if (strncmp (param->key, "target", param->keylen) == 0) {
|
|
|
|
target = ucl_object_tostring (param);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (param->type == UCL_INT) {
|
|
|
|
if (strncmp (param->key, "priority", param->keylen) == 0) {
|
|
|
|
priority = ucl_object_toint (param);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-02-14 14:34:42 +01:00
|
|
|
if (prefix == NULL || strlen (prefix) == 0) {
|
2015-07-28 17:57:15 +02:00
|
|
|
ucl_create_err (&parser->err, "No Key specified in load macro");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (len > 0) {
|
2016-02-22 18:16:14 +01:00
|
|
|
load_file = malloc (len + 1);
|
2016-02-14 14:34:42 +01:00
|
|
|
if (!load_file) {
|
|
|
|
ucl_create_err (&parser->err, "cannot allocate memory for suffix");
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2016-02-22 18:16:14 +01:00
|
|
|
snprintf (load_file, len + 1, "%.*s", (int)len, data);
|
|
|
|
|
2016-02-14 14:34:42 +01:00
|
|
|
if (!ucl_fetch_file (load_file, &buf, &buflen, &parser->err,
|
|
|
|
!try_load)) {
|
|
|
|
free (load_file);
|
|
|
|
|
2015-07-28 17:57:15 +02:00
|
|
|
return (try_load || false);
|
|
|
|
}
|
|
|
|
|
2016-02-14 14:34:42 +01:00
|
|
|
free (load_file);
|
|
|
|
container = parser->stack->obj;
|
2016-02-16 10:59:52 +01:00
|
|
|
old_obj = __DECONST (ucl_object_t *, ucl_object_lookup (container,
|
2016-02-14 14:34:42 +01:00
|
|
|
prefix));
|
|
|
|
|
2015-07-28 17:57:15 +02:00
|
|
|
if (old_obj != NULL) {
|
|
|
|
ucl_create_err (&parser->err, "Key %s already exists", prefix);
|
2016-02-22 18:16:14 +01:00
|
|
|
if (buf) {
|
2016-02-08 19:26:58 +01:00
|
|
|
ucl_munmap (buf, buflen);
|
|
|
|
}
|
|
|
|
|
2015-07-28 17:57:15 +02:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (strcasecmp (target, "string") == 0) {
|
|
|
|
obj = ucl_object_fromstring_common (buf, buflen, flags);
|
|
|
|
ucl_copy_value_trash (obj);
|
|
|
|
if (multiline) {
|
|
|
|
obj->flags |= UCL_OBJECT_MULTILINE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (strcasecmp (target, "int") == 0) {
|
2016-02-22 18:16:14 +01:00
|
|
|
tmp = malloc (buflen + 1);
|
|
|
|
|
|
|
|
if (tmp == NULL) {
|
|
|
|
ucl_create_err (&parser->err, "Memory allocation failed");
|
|
|
|
if (buf) {
|
|
|
|
ucl_munmap (buf, buflen);
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
snprintf (tmp, buflen + 1, "%.*s", (int)buflen, buf);
|
|
|
|
iv = strtoll (tmp, NULL, 10);
|
2016-02-14 14:34:42 +01:00
|
|
|
obj = ucl_object_fromint (iv);
|
2016-02-22 18:16:14 +01:00
|
|
|
free (tmp);
|
2015-07-28 17:57:15 +02:00
|
|
|
}
|
|
|
|
|
2016-02-22 18:16:14 +01:00
|
|
|
if (buf) {
|
2015-07-28 17:57:15 +02:00
|
|
|
ucl_munmap (buf, buflen);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (obj != NULL) {
|
|
|
|
obj->key = prefix;
|
|
|
|
obj->keylen = strlen (prefix);
|
2016-02-14 14:34:42 +01:00
|
|
|
ucl_copy_key_trash (obj);
|
2015-07-28 17:57:15 +02:00
|
|
|
obj->prev = obj;
|
|
|
|
obj->next = NULL;
|
|
|
|
ucl_object_set_priority (obj, priority);
|
2016-02-14 14:34:42 +01:00
|
|
|
ucl_object_insert_key (container, obj, obj->key, obj->keylen, false);
|
2015-07-28 17:57:15 +02:00
|
|
|
}
|
2016-02-08 19:26:58 +01:00
|
|
|
|
2015-07-28 17:57:15 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
ucl_create_err (&parser->err, "Unable to parse load macro");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-08-18 14:17:16 +02:00
|
|
|
bool
|
|
|
|
ucl_inherit_handler (const unsigned char *data, size_t len,
|
|
|
|
const ucl_object_t *args, const ucl_object_t *ctx, void* ud)
|
|
|
|
{
|
|
|
|
const ucl_object_t *parent, *cur;
|
|
|
|
ucl_object_t *target, *copy;
|
|
|
|
ucl_object_iter_t it = NULL;
|
|
|
|
bool replace = false;
|
|
|
|
struct ucl_parser *parser = ud;
|
|
|
|
|
2016-02-16 10:59:52 +01:00
|
|
|
parent = ucl_object_lookup_len (ctx, data, len);
|
2015-08-18 14:17:16 +02:00
|
|
|
|
|
|
|
/* Some sanity checks */
|
|
|
|
if (parent == NULL || ucl_object_type (parent) != UCL_OBJECT) {
|
2022-01-06 15:05:35 +01:00
|
|
|
ucl_create_err (&parser->err, "Unable to find inherited object %.*s",
|
2015-08-18 14:17:16 +02:00
|
|
|
(int)len, data);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (parser->stack == NULL || parser->stack->obj == NULL ||
|
|
|
|
ucl_object_type (parser->stack->obj) != UCL_OBJECT) {
|
|
|
|
ucl_create_err (&parser->err, "Invalid inherit context");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
target = parser->stack->obj;
|
|
|
|
|
2016-02-16 10:59:52 +01:00
|
|
|
if (args && (cur = ucl_object_lookup (args, "replace")) != NULL) {
|
2015-08-18 14:17:16 +02:00
|
|
|
replace = ucl_object_toboolean (cur);
|
|
|
|
}
|
|
|
|
|
2016-02-16 10:59:52 +01:00
|
|
|
while ((cur = ucl_object_iterate (parent, &it, true))) {
|
2015-08-18 14:17:16 +02:00
|
|
|
/* We do not replace existing keys */
|
2016-02-16 10:59:52 +01:00
|
|
|
if (!replace && ucl_object_lookup_len (target, cur->key, cur->keylen)) {
|
2015-08-18 14:17:16 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
copy = ucl_object_copy (cur);
|
|
|
|
|
|
|
|
if (!replace) {
|
|
|
|
copy->flags |= UCL_OBJECT_INHERITED;
|
|
|
|
}
|
|
|
|
|
|
|
|
ucl_object_insert_key (target, copy, copy->key,
|
|
|
|
copy->keylen, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-07-28 17:57:15 +02:00
|
|
|
bool
|
2015-02-21 19:11:12 +01:00
|
|
|
ucl_parser_set_filevars (struct ucl_parser *parser, const char *filename, bool need_expand)
|
|
|
|
{
|
|
|
|
char realbuf[PATH_MAX], *curdir;
|
|
|
|
|
|
|
|
if (filename != NULL) {
|
|
|
|
if (need_expand) {
|
|
|
|
if (ucl_realpath (filename, realbuf) == NULL) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
ucl_strlcpy (realbuf, filename, sizeof (realbuf));
|
|
|
|
}
|
|
|
|
|
2018-12-13 15:06:13 +01:00
|
|
|
if (parser->cur_file) {
|
|
|
|
free (parser->cur_file);
|
|
|
|
}
|
|
|
|
|
|
|
|
parser->cur_file = strdup (realbuf);
|
|
|
|
|
2015-02-21 19:11:12 +01:00
|
|
|
/* Define variables */
|
|
|
|
ucl_parser_register_variable (parser, "FILENAME", realbuf);
|
|
|
|
curdir = dirname (realbuf);
|
|
|
|
ucl_parser_register_variable (parser, "CURDIR", curdir);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* Set everything from the current dir */
|
|
|
|
curdir = getcwd (realbuf, sizeof (realbuf));
|
|
|
|
ucl_parser_register_variable (parser, "FILENAME", "undef");
|
|
|
|
ucl_parser_register_variable (parser, "CURDIR", curdir);
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-07-28 17:57:15 +02:00
|
|
|
bool
|
2018-03-21 14:08:45 +01:00
|
|
|
ucl_parser_add_file_full (struct ucl_parser *parser, const char *filename,
|
|
|
|
unsigned priority, enum ucl_duplicate_strategy strat,
|
|
|
|
enum ucl_parse_type parse_type)
|
2015-02-21 19:11:12 +01:00
|
|
|
{
|
|
|
|
unsigned char *buf;
|
|
|
|
size_t len;
|
|
|
|
bool ret;
|
|
|
|
char realbuf[PATH_MAX];
|
|
|
|
|
|
|
|
if (ucl_realpath (filename, realbuf) == NULL) {
|
|
|
|
ucl_create_err (&parser->err, "cannot open file %s: %s",
|
|
|
|
filename,
|
|
|
|
strerror (errno));
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ucl_fetch_file (realbuf, &buf, &len, &parser->err, true)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
ucl_parser_set_filevars (parser, realbuf, false);
|
2018-03-21 14:08:45 +01:00
|
|
|
ret = ucl_parser_add_chunk_full (parser, buf, len, priority, strat,
|
|
|
|
parse_type);
|
2015-02-21 19:11:12 +01:00
|
|
|
|
|
|
|
if (len > 0) {
|
|
|
|
ucl_munmap (buf, len);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2018-03-21 14:08:45 +01:00
|
|
|
bool
|
|
|
|
ucl_parser_add_file_priority (struct ucl_parser *parser, const char *filename,
|
|
|
|
unsigned priority)
|
|
|
|
{
|
|
|
|
if (parser == NULL) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ucl_parser_add_file_full(parser, filename, priority,
|
|
|
|
UCL_DUPLICATE_APPEND, UCL_PARSE_UCL);
|
|
|
|
}
|
|
|
|
|
2015-07-28 17:57:15 +02:00
|
|
|
bool
|
|
|
|
ucl_parser_add_file (struct ucl_parser *parser, const char *filename)
|
|
|
|
{
|
|
|
|
if (parser == NULL) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2018-03-21 14:08:45 +01:00
|
|
|
return ucl_parser_add_file_full(parser, filename,
|
|
|
|
parser->default_priority, UCL_DUPLICATE_APPEND,
|
|
|
|
UCL_PARSE_UCL);
|
2015-07-28 17:57:15 +02:00
|
|
|
}
|
|
|
|
|
2018-03-21 14:08:45 +01:00
|
|
|
|
2015-07-28 17:57:15 +02:00
|
|
|
bool
|
2018-03-21 14:08:45 +01:00
|
|
|
ucl_parser_add_fd_full (struct ucl_parser *parser, int fd,
|
|
|
|
unsigned priority, enum ucl_duplicate_strategy strat,
|
|
|
|
enum ucl_parse_type parse_type)
|
2015-02-21 19:11:12 +01:00
|
|
|
{
|
|
|
|
unsigned char *buf;
|
|
|
|
size_t len;
|
|
|
|
bool ret;
|
|
|
|
struct stat st;
|
|
|
|
|
|
|
|
if (fstat (fd, &st) == -1) {
|
|
|
|
ucl_create_err (&parser->err, "cannot stat fd %d: %s",
|
|
|
|
fd, strerror (errno));
|
|
|
|
return false;
|
|
|
|
}
|
2018-03-21 14:08:45 +01:00
|
|
|
if (st.st_size == 0) {
|
|
|
|
return true;
|
|
|
|
}
|
2015-02-21 19:11:12 +01:00
|
|
|
if ((buf = ucl_mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
|
|
|
|
ucl_create_err (&parser->err, "cannot mmap fd %d: %s",
|
|
|
|
fd, strerror (errno));
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (parser->cur_file) {
|
|
|
|
free (parser->cur_file);
|
|
|
|
}
|
|
|
|
parser->cur_file = NULL;
|
|
|
|
len = st.st_size;
|
2018-03-21 14:08:45 +01:00
|
|
|
ret = ucl_parser_add_chunk_full (parser, buf, len, priority, strat,
|
|
|
|
parse_type);
|
2015-02-21 19:11:12 +01:00
|
|
|
|
|
|
|
if (len > 0) {
|
|
|
|
ucl_munmap (buf, len);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2018-03-21 14:08:45 +01:00
|
|
|
bool
|
|
|
|
ucl_parser_add_fd_priority (struct ucl_parser *parser, int fd,
|
|
|
|
unsigned priority)
|
|
|
|
{
|
|
|
|
if (parser == NULL) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ucl_parser_add_fd_full(parser, fd, parser->default_priority,
|
|
|
|
UCL_DUPLICATE_APPEND, UCL_PARSE_UCL);
|
|
|
|
}
|
|
|
|
|
2015-07-28 17:57:15 +02:00
|
|
|
bool
|
|
|
|
ucl_parser_add_fd (struct ucl_parser *parser, int fd)
|
|
|
|
{
|
|
|
|
if (parser == NULL) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ucl_parser_add_fd_priority(parser, fd, parser->default_priority);
|
|
|
|
}
|
|
|
|
|
2015-02-21 19:11:12 +01:00
|
|
|
size_t
|
|
|
|
ucl_strlcpy (char *dst, const char *src, size_t siz)
|
|
|
|
{
|
|
|
|
char *d = dst;
|
|
|
|
const char *s = src;
|
|
|
|
size_t n = siz;
|
|
|
|
|
|
|
|
/* Copy as many bytes as will fit */
|
|
|
|
if (n != 0) {
|
|
|
|
while (--n != 0) {
|
|
|
|
if ((*d++ = *s++) == '\0') {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (n == 0 && siz != 0) {
|
|
|
|
*d = '\0';
|
|
|
|
}
|
|
|
|
|
|
|
|
return (s - src - 1); /* count does not include NUL */
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t
|
|
|
|
ucl_strlcpy_unsafe (char *dst, const char *src, size_t siz)
|
|
|
|
{
|
|
|
|
memcpy (dst, src, siz - 1);
|
|
|
|
dst[siz - 1] = '\0';
|
|
|
|
|
|
|
|
return siz - 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t
|
|
|
|
ucl_strlcpy_tolower (char *dst, const char *src, size_t siz)
|
|
|
|
{
|
|
|
|
char *d = dst;
|
|
|
|
const char *s = src;
|
|
|
|
size_t n = siz;
|
|
|
|
|
|
|
|
/* Copy as many bytes as will fit */
|
|
|
|
if (n != 0) {
|
|
|
|
while (--n != 0) {
|
|
|
|
if ((*d++ = tolower (*s++)) == '\0') {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (n == 0 && siz != 0) {
|
|
|
|
*d = '\0';
|
|
|
|
}
|
|
|
|
|
|
|
|
return (s - src); /* count does not include NUL */
|
|
|
|
}
|
|
|
|
|
2015-07-28 17:57:15 +02:00
|
|
|
/*
|
|
|
|
* Find the first occurrence of find in s
|
|
|
|
*/
|
|
|
|
char *
|
|
|
|
ucl_strnstr (const char *s, const char *find, int len)
|
|
|
|
{
|
|
|
|
char c, sc;
|
|
|
|
int mlen;
|
|
|
|
|
|
|
|
if ((c = *find++) != 0) {
|
|
|
|
mlen = strlen (find);
|
|
|
|
do {
|
|
|
|
do {
|
2022-01-06 15:05:35 +01:00
|
|
|
if ((sc = *s++) == 0 || len-- < mlen)
|
2015-07-28 17:57:15 +02:00
|
|
|
return (NULL);
|
|
|
|
} while (sc != c);
|
|
|
|
} while (strncmp (s, find, mlen) != 0);
|
|
|
|
s--;
|
|
|
|
}
|
|
|
|
return ((char *)s);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Find the first occurrence of find in s, ignore case.
|
|
|
|
*/
|
|
|
|
char *
|
|
|
|
ucl_strncasestr (const char *s, const char *find, int len)
|
|
|
|
{
|
|
|
|
char c, sc;
|
|
|
|
int mlen;
|
|
|
|
|
|
|
|
if ((c = *find++) != 0) {
|
|
|
|
c = tolower (c);
|
|
|
|
mlen = strlen (find);
|
|
|
|
do {
|
|
|
|
do {
|
|
|
|
if ((sc = *s++) == 0 || len-- == 0)
|
|
|
|
return (NULL);
|
|
|
|
} while (tolower (sc) != c);
|
|
|
|
} while (strncasecmp (s, find, mlen) != 0);
|
|
|
|
s--;
|
|
|
|
}
|
|
|
|
return ((char *)s);
|
|
|
|
}
|
|
|
|
|
2015-02-21 19:11:12 +01:00
|
|
|
ucl_object_t *
|
|
|
|
ucl_object_fromstring_common (const char *str, size_t len, enum ucl_string_flags flags)
|
|
|
|
{
|
|
|
|
ucl_object_t *obj;
|
|
|
|
const char *start, *end, *p, *pos;
|
|
|
|
char *dst, *d;
|
|
|
|
size_t escaped_len;
|
|
|
|
|
|
|
|
if (str == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
obj = ucl_object_new ();
|
|
|
|
if (obj) {
|
|
|
|
if (len == 0) {
|
|
|
|
len = strlen (str);
|
|
|
|
}
|
|
|
|
if (flags & UCL_STRING_TRIM) {
|
|
|
|
/* Skip leading spaces */
|
|
|
|
for (start = str; (size_t)(start - str) < len; start ++) {
|
|
|
|
if (!ucl_test_character (*start, UCL_CHARACTER_WHITESPACE_UNSAFE)) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* Skip trailing spaces */
|
|
|
|
for (end = str + len - 1; end > start; end --) {
|
|
|
|
if (!ucl_test_character (*end, UCL_CHARACTER_WHITESPACE_UNSAFE)) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
end ++;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
start = str;
|
|
|
|
end = str + len;
|
|
|
|
}
|
|
|
|
|
|
|
|
obj->type = UCL_STRING;
|
|
|
|
if (flags & UCL_STRING_ESCAPE) {
|
|
|
|
for (p = start, escaped_len = 0; p < end; p ++, escaped_len ++) {
|
2018-05-10 16:41:49 +02:00
|
|
|
if (ucl_test_character (*p, UCL_CHARACTER_JSON_UNSAFE | UCL_CHARACTER_WHITESPACE_UNSAFE)) {
|
|
|
|
switch (*p) {
|
|
|
|
case '\v':
|
2020-01-13 14:16:13 +01:00
|
|
|
case '\0':
|
2018-05-10 16:41:49 +02:00
|
|
|
escaped_len += 5;
|
|
|
|
break;
|
|
|
|
case ' ':
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
escaped_len ++;
|
|
|
|
break;
|
|
|
|
}
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
dst = malloc (escaped_len + 1);
|
|
|
|
if (dst != NULL) {
|
|
|
|
for (p = start, d = dst; p < end; p ++, d ++) {
|
2018-05-10 16:41:49 +02:00
|
|
|
if (ucl_test_character (*p, UCL_CHARACTER_JSON_UNSAFE | UCL_CHARACTER_WHITESPACE_UNSAFE)) {
|
2015-02-21 19:11:12 +01:00
|
|
|
switch (*p) {
|
|
|
|
case '\n':
|
|
|
|
*d++ = '\\';
|
|
|
|
*d = 'n';
|
|
|
|
break;
|
|
|
|
case '\r':
|
|
|
|
*d++ = '\\';
|
|
|
|
*d = 'r';
|
|
|
|
break;
|
|
|
|
case '\b':
|
|
|
|
*d++ = '\\';
|
|
|
|
*d = 'b';
|
|
|
|
break;
|
|
|
|
case '\t':
|
|
|
|
*d++ = '\\';
|
|
|
|
*d = 't';
|
|
|
|
break;
|
|
|
|
case '\f':
|
|
|
|
*d++ = '\\';
|
|
|
|
*d = 'f';
|
|
|
|
break;
|
2020-01-13 14:16:13 +01:00
|
|
|
case '\0':
|
|
|
|
*d++ = '\\';
|
|
|
|
*d++ = 'u';
|
|
|
|
*d++ = '0';
|
|
|
|
*d++ = '0';
|
|
|
|
*d++ = '0';
|
|
|
|
*d = '0';
|
|
|
|
break;
|
2018-05-10 16:41:49 +02:00
|
|
|
case '\v':
|
|
|
|
*d++ = '\\';
|
|
|
|
*d++ = 'u';
|
|
|
|
*d++ = '0';
|
|
|
|
*d++ = '0';
|
|
|
|
*d++ = '0';
|
|
|
|
*d = 'B';
|
|
|
|
break;
|
2015-02-21 19:11:12 +01:00
|
|
|
case '\\':
|
|
|
|
*d++ = '\\';
|
|
|
|
*d = '\\';
|
|
|
|
break;
|
2018-05-10 16:41:49 +02:00
|
|
|
case ' ':
|
|
|
|
*d = ' ';
|
|
|
|
break;
|
2015-02-21 19:11:12 +01:00
|
|
|
case '"':
|
|
|
|
*d++ = '\\';
|
|
|
|
*d = '"';
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
*d = *p;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
*d = '\0';
|
|
|
|
obj->value.sv = dst;
|
|
|
|
obj->trash_stack[UCL_TRASH_VALUE] = dst;
|
|
|
|
obj->len = escaped_len;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
dst = malloc (end - start + 1);
|
|
|
|
if (dst != NULL) {
|
|
|
|
ucl_strlcpy_unsafe (dst, start, end - start + 1);
|
|
|
|
obj->value.sv = dst;
|
|
|
|
obj->trash_stack[UCL_TRASH_VALUE] = dst;
|
|
|
|
obj->len = end - start;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if ((flags & UCL_STRING_PARSE) && dst != NULL) {
|
|
|
|
/* Parse what we have */
|
|
|
|
if (flags & UCL_STRING_PARSE_BOOLEAN) {
|
|
|
|
if (!ucl_maybe_parse_boolean (obj, dst, obj->len) && (flags & UCL_STRING_PARSE_NUMBER)) {
|
|
|
|
ucl_maybe_parse_number (obj, dst, dst + obj->len, &pos,
|
|
|
|
flags & UCL_STRING_PARSE_DOUBLE,
|
|
|
|
flags & UCL_STRING_PARSE_BYTES,
|
|
|
|
flags & UCL_STRING_PARSE_TIME);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
ucl_maybe_parse_number (obj, dst, dst + obj->len, &pos,
|
|
|
|
flags & UCL_STRING_PARSE_DOUBLE,
|
|
|
|
flags & UCL_STRING_PARSE_BYTES,
|
|
|
|
flags & UCL_STRING_PARSE_TIME);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
ucl_object_insert_key_common (ucl_object_t *top, ucl_object_t *elt,
|
|
|
|
const char *key, size_t keylen, bool copy_key, bool merge, bool replace)
|
|
|
|
{
|
|
|
|
ucl_object_t *found, *tmp;
|
|
|
|
const ucl_object_t *cur;
|
|
|
|
ucl_object_iter_t it = NULL;
|
|
|
|
const char *p;
|
|
|
|
int ret = true;
|
|
|
|
|
|
|
|
if (elt == NULL || key == NULL) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (top == NULL) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (top->type != UCL_OBJECT) {
|
|
|
|
/* It is possible to convert NULL type to an object */
|
|
|
|
if (top->type == UCL_NULL) {
|
|
|
|
top->type = UCL_OBJECT;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* Refuse converting of other object types */
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (top->value.ov == NULL) {
|
|
|
|
top->value.ov = ucl_hash_create (false);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (keylen == 0) {
|
|
|
|
keylen = strlen (key);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (p = key; p < key + keylen; p ++) {
|
|
|
|
if (ucl_test_character (*p, UCL_CHARACTER_UCL_UNSAFE)) {
|
|
|
|
elt->flags |= UCL_OBJECT_NEED_KEY_ESCAPE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* workaround for some use cases */
|
|
|
|
if (elt->trash_stack[UCL_TRASH_KEY] != NULL &&
|
|
|
|
key != (const char *)elt->trash_stack[UCL_TRASH_KEY]) {
|
|
|
|
/* Remove copied key */
|
|
|
|
free (elt->trash_stack[UCL_TRASH_KEY]);
|
|
|
|
elt->trash_stack[UCL_TRASH_KEY] = NULL;
|
|
|
|
elt->flags &= ~UCL_OBJECT_ALLOCATED_KEY;
|
|
|
|
}
|
|
|
|
|
|
|
|
elt->key = key;
|
|
|
|
elt->keylen = keylen;
|
|
|
|
|
|
|
|
if (copy_key) {
|
|
|
|
ucl_copy_key_trash (elt);
|
|
|
|
}
|
|
|
|
|
|
|
|
found = __DECONST (ucl_object_t *, ucl_hash_search_obj (top->value.ov, elt));
|
|
|
|
|
|
|
|
if (found == NULL) {
|
|
|
|
top->value.ov = ucl_hash_insert_object (top->value.ov, elt, false);
|
|
|
|
top->len ++;
|
|
|
|
if (replace) {
|
|
|
|
ret = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if (replace) {
|
|
|
|
ucl_hash_replace (top->value.ov, found, elt);
|
|
|
|
ucl_object_unref (found);
|
|
|
|
}
|
|
|
|
else if (merge) {
|
|
|
|
if (found->type != UCL_OBJECT && elt->type == UCL_OBJECT) {
|
|
|
|
/* Insert old elt to new one */
|
|
|
|
ucl_object_insert_key_common (elt, found, found->key,
|
|
|
|
found->keylen, copy_key, false, false);
|
|
|
|
ucl_hash_delete (top->value.ov, found);
|
|
|
|
top->value.ov = ucl_hash_insert_object (top->value.ov, elt, false);
|
|
|
|
}
|
|
|
|
else if (found->type == UCL_OBJECT && elt->type != UCL_OBJECT) {
|
|
|
|
/* Insert new to old */
|
|
|
|
ucl_object_insert_key_common (found, elt, elt->key,
|
|
|
|
elt->keylen, copy_key, false, false);
|
|
|
|
}
|
|
|
|
else if (found->type == UCL_OBJECT && elt->type == UCL_OBJECT) {
|
|
|
|
/* Mix two hashes */
|
2016-02-16 10:59:52 +01:00
|
|
|
while ((cur = ucl_object_iterate (elt, &it, true)) != NULL) {
|
2015-02-21 19:11:12 +01:00
|
|
|
tmp = ucl_object_ref (cur);
|
|
|
|
ucl_object_insert_key_common (found, tmp, cur->key,
|
2017-06-02 15:41:51 +02:00
|
|
|
cur->keylen, copy_key, true, false);
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
ucl_object_unref (elt);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* Just make a list of scalars */
|
2018-06-15 14:21:06 +02:00
|
|
|
DL_CONCAT (found, elt);
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
2018-06-15 14:21:06 +02:00
|
|
|
DL_CONCAT (found, elt);
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
ucl_object_delete_keyl (ucl_object_t *top, const char *key, size_t keylen)
|
|
|
|
{
|
|
|
|
ucl_object_t *found;
|
|
|
|
|
|
|
|
if (top == NULL || key == NULL) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2016-02-16 10:59:52 +01:00
|
|
|
found = __DECONST (ucl_object_t *, ucl_object_lookup_len (top, key, keylen));
|
2015-02-21 19:11:12 +01:00
|
|
|
|
|
|
|
if (found == NULL) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
ucl_hash_delete (top->value.ov, found);
|
|
|
|
ucl_object_unref (found);
|
|
|
|
top->len --;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
ucl_object_delete_key (ucl_object_t *top, const char *key)
|
|
|
|
{
|
2015-07-28 17:57:15 +02:00
|
|
|
return ucl_object_delete_keyl (top, key, strlen (key));
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
ucl_object_t*
|
|
|
|
ucl_object_pop_keyl (ucl_object_t *top, const char *key, size_t keylen)
|
|
|
|
{
|
|
|
|
const ucl_object_t *found;
|
|
|
|
|
|
|
|
if (top == NULL || key == NULL) {
|
|
|
|
return false;
|
|
|
|
}
|
2016-02-16 10:59:52 +01:00
|
|
|
found = ucl_object_lookup_len (top, key, keylen);
|
2015-02-21 19:11:12 +01:00
|
|
|
|
|
|
|
if (found == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
ucl_hash_delete (top->value.ov, found);
|
|
|
|
top->len --;
|
|
|
|
|
|
|
|
return __DECONST (ucl_object_t *, found);
|
|
|
|
}
|
|
|
|
|
|
|
|
ucl_object_t*
|
|
|
|
ucl_object_pop_key (ucl_object_t *top, const char *key)
|
|
|
|
{
|
2015-07-28 17:57:15 +02:00
|
|
|
return ucl_object_pop_keyl (top, key, strlen (key));
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
ucl_object_insert_key (ucl_object_t *top, ucl_object_t *elt,
|
|
|
|
const char *key, size_t keylen, bool copy_key)
|
|
|
|
{
|
|
|
|
return ucl_object_insert_key_common (top, elt, key, keylen, copy_key, false, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
ucl_object_insert_key_merged (ucl_object_t *top, ucl_object_t *elt,
|
|
|
|
const char *key, size_t keylen, bool copy_key)
|
|
|
|
{
|
|
|
|
return ucl_object_insert_key_common (top, elt, key, keylen, copy_key, true, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
ucl_object_replace_key (ucl_object_t *top, ucl_object_t *elt,
|
|
|
|
const char *key, size_t keylen, bool copy_key)
|
|
|
|
{
|
|
|
|
return ucl_object_insert_key_common (top, elt, key, keylen, copy_key, false, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
ucl_object_merge (ucl_object_t *top, ucl_object_t *elt, bool copy)
|
|
|
|
{
|
|
|
|
ucl_object_t *cur = NULL, *cp = NULL, *found = NULL;
|
|
|
|
ucl_object_iter_t iter = NULL;
|
|
|
|
|
2017-06-02 15:41:51 +02:00
|
|
|
if (top == NULL || elt == NULL) {
|
2015-02-21 19:11:12 +01:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2017-06-02 15:41:51 +02:00
|
|
|
if (top->type == UCL_ARRAY) {
|
|
|
|
if (elt->type == UCL_ARRAY) {
|
|
|
|
/* Merge two arrays */
|
|
|
|
return ucl_array_merge (top, elt, copy);
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
else {
|
2017-06-02 15:41:51 +02:00
|
|
|
if (copy) {
|
|
|
|
ucl_array_append (top, ucl_object_copy (elt));
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
ucl_array_append (top, ucl_object_ref (elt));
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
2017-06-02 15:41:51 +02:00
|
|
|
}
|
|
|
|
else if (top->type == UCL_OBJECT) {
|
|
|
|
if (elt->type == UCL_OBJECT) {
|
|
|
|
/* Mix two hashes */
|
|
|
|
while ((cur = (ucl_object_t *) ucl_hash_iterate (elt->value.ov,
|
|
|
|
&iter))) {
|
|
|
|
|
|
|
|
if (copy) {
|
|
|
|
cp = ucl_object_copy (cur);
|
|
|
|
} else {
|
|
|
|
cp = ucl_object_ref (cur);
|
|
|
|
}
|
|
|
|
|
|
|
|
found = __DECONST(ucl_object_t *,
|
|
|
|
ucl_hash_search (top->value.ov, cp->key, cp->keylen));
|
|
|
|
|
|
|
|
if (found == NULL) {
|
|
|
|
/* The key does not exist */
|
|
|
|
top->value.ov = ucl_hash_insert_object (top->value.ov, cp,
|
|
|
|
false);
|
|
|
|
top->len++;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* The key already exists, merge it recursively */
|
|
|
|
if (found->type == UCL_OBJECT || found->type == UCL_ARRAY) {
|
|
|
|
if (!ucl_object_merge (found, cp, copy)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
ucl_hash_replace (top->value.ov, found, cp);
|
|
|
|
ucl_object_unref (found);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
else {
|
2017-06-02 15:41:51 +02:00
|
|
|
if (copy) {
|
|
|
|
cp = ucl_object_copy (elt);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
cp = ucl_object_ref (elt);
|
|
|
|
}
|
|
|
|
|
|
|
|
found = __DECONST(ucl_object_t *,
|
|
|
|
ucl_hash_search (top->value.ov, cp->key, cp->keylen));
|
|
|
|
|
|
|
|
if (found == NULL) {
|
|
|
|
/* The key does not exist */
|
|
|
|
top->value.ov = ucl_hash_insert_object (top->value.ov, cp,
|
|
|
|
false);
|
|
|
|
top->len++;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* The key already exists, merge it recursively */
|
|
|
|
if (found->type == UCL_OBJECT || found->type == UCL_ARRAY) {
|
|
|
|
if (!ucl_object_merge (found, cp, copy)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
ucl_hash_replace (top->value.ov, found, cp);
|
|
|
|
ucl_object_unref (found);
|
|
|
|
}
|
|
|
|
}
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
}
|
2017-06-02 15:41:51 +02:00
|
|
|
else {
|
|
|
|
/* Cannot merge trivial objects */
|
|
|
|
return false;
|
|
|
|
}
|
2015-02-21 19:11:12 +01:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
const ucl_object_t *
|
2016-02-16 10:59:52 +01:00
|
|
|
ucl_object_lookup_len (const ucl_object_t *obj, const char *key, size_t klen)
|
2015-02-21 19:11:12 +01:00
|
|
|
{
|
|
|
|
const ucl_object_t *ret;
|
|
|
|
ucl_object_t srch;
|
|
|
|
|
|
|
|
if (obj == NULL || obj->type != UCL_OBJECT || key == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
srch.key = key;
|
|
|
|
srch.keylen = klen;
|
|
|
|
ret = ucl_hash_search_obj (obj->value.ov, &srch);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
const ucl_object_t *
|
2016-02-16 10:59:52 +01:00
|
|
|
ucl_object_lookup (const ucl_object_t *obj, const char *key)
|
2015-02-21 19:11:12 +01:00
|
|
|
{
|
2015-07-28 17:57:15 +02:00
|
|
|
if (key == NULL) {
|
2015-02-21 19:11:12 +01:00
|
|
|
return NULL;
|
2015-07-28 17:57:15 +02:00
|
|
|
}
|
2015-02-21 19:11:12 +01:00
|
|
|
|
2016-02-16 10:59:52 +01:00
|
|
|
return ucl_object_lookup_len (obj, key, strlen (key));
|
2015-07-28 17:57:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
const ucl_object_t*
|
2016-02-16 10:59:52 +01:00
|
|
|
ucl_object_lookup_any (const ucl_object_t *obj,
|
2015-07-28 17:57:15 +02:00
|
|
|
const char *key, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
const ucl_object_t *ret = NULL;
|
|
|
|
const char *nk = NULL;
|
|
|
|
|
|
|
|
if (obj == NULL || key == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2016-02-16 10:59:52 +01:00
|
|
|
ret = ucl_object_lookup_len (obj, key, strlen (key));
|
2015-07-28 17:57:15 +02:00
|
|
|
|
|
|
|
if (ret == NULL) {
|
|
|
|
va_start (ap, key);
|
|
|
|
|
|
|
|
while (ret == NULL) {
|
|
|
|
nk = va_arg (ap, const char *);
|
|
|
|
|
|
|
|
if (nk == NULL) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
else {
|
2016-02-16 10:59:52 +01:00
|
|
|
ret = ucl_object_lookup_len (obj, nk, strlen (nk));
|
2015-07-28 17:57:15 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
va_end (ap);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
const ucl_object_t*
|
2019-04-25 13:13:09 +02:00
|
|
|
ucl_object_iterate_with_error (const ucl_object_t *obj, ucl_object_iter_t *iter, bool expand_values,
|
|
|
|
int *ep)
|
2015-02-21 19:11:12 +01:00
|
|
|
{
|
|
|
|
const ucl_object_t *elt = NULL;
|
|
|
|
|
|
|
|
if (obj == NULL || iter == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (expand_values) {
|
|
|
|
switch (obj->type) {
|
|
|
|
case UCL_OBJECT:
|
2019-04-25 13:13:09 +02:00
|
|
|
return (const ucl_object_t*)ucl_hash_iterate2 (obj->value.ov, iter, ep);
|
2015-02-21 19:11:12 +01:00
|
|
|
break;
|
|
|
|
case UCL_ARRAY: {
|
|
|
|
unsigned int idx;
|
|
|
|
UCL_ARRAY_GET (vec, obj);
|
|
|
|
idx = (unsigned int)(uintptr_t)(*iter);
|
|
|
|
|
|
|
|
if (vec != NULL) {
|
|
|
|
while (idx < kv_size (*vec)) {
|
|
|
|
if ((elt = kv_A (*vec, idx)) != NULL) {
|
|
|
|
idx ++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
idx ++;
|
|
|
|
}
|
|
|
|
*iter = (void *)(uintptr_t)idx;
|
|
|
|
}
|
|
|
|
|
|
|
|
return elt;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
/* Go to linear iteration */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* Treat everything as a linear list */
|
|
|
|
elt = *iter;
|
|
|
|
if (elt == NULL) {
|
|
|
|
elt = obj;
|
|
|
|
}
|
|
|
|
else if (elt == obj) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
*iter = __DECONST (void *, elt->next ? elt->next : obj);
|
|
|
|
return elt;
|
|
|
|
|
|
|
|
/* Not reached */
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2017-03-08 16:54:46 +01:00
|
|
|
enum ucl_safe_iter_flags {
|
|
|
|
UCL_ITERATE_FLAG_UNDEFINED = 0,
|
|
|
|
UCL_ITERATE_FLAG_INSIDE_ARRAY,
|
|
|
|
UCL_ITERATE_FLAG_INSIDE_OBJECT,
|
|
|
|
UCL_ITERATE_FLAG_IMPLICIT,
|
2019-04-25 13:13:09 +02:00
|
|
|
UCL_ITERATE_FLAG_EXCEPTION
|
2017-03-08 16:54:46 +01:00
|
|
|
};
|
|
|
|
|
2019-06-26 19:37:14 +02:00
|
|
|
static const char safe_iter_magic[4] = {'u', 'i', 't', 'e'};
|
2015-02-21 19:11:12 +01:00
|
|
|
struct ucl_object_safe_iter {
|
|
|
|
char magic[4]; /* safety check */
|
2017-03-08 16:54:46 +01:00
|
|
|
uint32_t flags;
|
2015-02-21 19:11:12 +01:00
|
|
|
const ucl_object_t *impl_it; /* implicit object iteration */
|
|
|
|
ucl_object_iter_t expl_it; /* explicit iteration */
|
|
|
|
};
|
|
|
|
|
|
|
|
#define UCL_SAFE_ITER(ptr) (struct ucl_object_safe_iter *)(ptr)
|
|
|
|
#define UCL_SAFE_ITER_CHECK(it) do { \
|
|
|
|
assert (it != NULL); \
|
|
|
|
assert (memcmp (it->magic, safe_iter_magic, sizeof (it->magic)) == 0); \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
ucl_object_iter_t
|
|
|
|
ucl_object_iterate_new (const ucl_object_t *obj)
|
|
|
|
{
|
|
|
|
struct ucl_object_safe_iter *it;
|
|
|
|
|
|
|
|
it = UCL_ALLOC (sizeof (*it));
|
|
|
|
if (it != NULL) {
|
|
|
|
memcpy (it->magic, safe_iter_magic, sizeof (it->magic));
|
2017-03-08 16:54:46 +01:00
|
|
|
it->flags = UCL_ITERATE_FLAG_UNDEFINED;
|
2015-02-21 19:11:12 +01:00
|
|
|
it->expl_it = NULL;
|
|
|
|
it->impl_it = obj;
|
|
|
|
}
|
|
|
|
|
|
|
|
return (ucl_object_iter_t)it;
|
|
|
|
}
|
|
|
|
|
2019-04-25 13:13:09 +02:00
|
|
|
bool
|
|
|
|
ucl_object_iter_chk_excpn(ucl_object_iter_t *it)
|
|
|
|
{
|
|
|
|
struct ucl_object_safe_iter *rit = UCL_SAFE_ITER (it);
|
|
|
|
|
|
|
|
UCL_SAFE_ITER_CHECK (rit);
|
|
|
|
|
|
|
|
return (rit->flags == UCL_ITERATE_FLAG_EXCEPTION);
|
|
|
|
}
|
2015-02-21 19:11:12 +01:00
|
|
|
|
|
|
|
ucl_object_iter_t
|
|
|
|
ucl_object_iterate_reset (ucl_object_iter_t it, const ucl_object_t *obj)
|
|
|
|
{
|
|
|
|
struct ucl_object_safe_iter *rit = UCL_SAFE_ITER (it);
|
|
|
|
|
|
|
|
UCL_SAFE_ITER_CHECK (rit);
|
|
|
|
|
2017-01-17 20:19:34 +01:00
|
|
|
if (rit->expl_it != NULL) {
|
2017-03-08 16:54:46 +01:00
|
|
|
if (rit->flags == UCL_ITERATE_FLAG_INSIDE_OBJECT) {
|
|
|
|
UCL_FREE (sizeof (*rit->expl_it), rit->expl_it);
|
|
|
|
}
|
2017-01-17 20:19:34 +01:00
|
|
|
}
|
|
|
|
|
2015-02-21 19:11:12 +01:00
|
|
|
rit->impl_it = obj;
|
|
|
|
rit->expl_it = NULL;
|
2017-03-08 16:54:46 +01:00
|
|
|
rit->flags = UCL_ITERATE_FLAG_UNDEFINED;
|
2015-02-21 19:11:12 +01:00
|
|
|
|
|
|
|
return it;
|
|
|
|
}
|
|
|
|
|
|
|
|
const ucl_object_t*
|
|
|
|
ucl_object_iterate_safe (ucl_object_iter_t it, bool expand_values)
|
2017-01-10 13:35:55 +01:00
|
|
|
{
|
|
|
|
return ucl_object_iterate_full (it, expand_values ? UCL_ITERATE_BOTH :
|
|
|
|
UCL_ITERATE_IMPLICIT);
|
|
|
|
}
|
|
|
|
|
|
|
|
const ucl_object_t*
|
|
|
|
ucl_object_iterate_full (ucl_object_iter_t it, enum ucl_iterate_type type)
|
2015-02-21 19:11:12 +01:00
|
|
|
{
|
|
|
|
struct ucl_object_safe_iter *rit = UCL_SAFE_ITER (it);
|
|
|
|
const ucl_object_t *ret = NULL;
|
2019-04-25 13:13:09 +02:00
|
|
|
int ern;
|
2015-02-21 19:11:12 +01:00
|
|
|
|
|
|
|
UCL_SAFE_ITER_CHECK (rit);
|
|
|
|
|
|
|
|
if (rit->impl_it == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2017-03-08 16:54:46 +01:00
|
|
|
if (rit->impl_it->type == UCL_OBJECT) {
|
|
|
|
rit->flags = UCL_ITERATE_FLAG_INSIDE_OBJECT;
|
2019-04-25 13:13:09 +02:00
|
|
|
ret = ucl_object_iterate_with_error (rit->impl_it, &rit->expl_it, true, &ern);
|
|
|
|
|
|
|
|
if (ret == NULL && ern != 0) {
|
|
|
|
rit->flags = UCL_ITERATE_FLAG_EXCEPTION;
|
|
|
|
return NULL;
|
|
|
|
}
|
2017-03-08 16:54:46 +01:00
|
|
|
|
|
|
|
if (ret == NULL && (type & UCL_ITERATE_IMPLICIT)) {
|
|
|
|
/* Need to switch to another implicit object in chain */
|
|
|
|
rit->impl_it = rit->impl_it->next;
|
|
|
|
rit->expl_it = NULL;
|
|
|
|
|
|
|
|
return ucl_object_iterate_safe (it, type);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (rit->impl_it->type == UCL_ARRAY) {
|
|
|
|
rit->flags = UCL_ITERATE_FLAG_INSIDE_ARRAY;
|
2016-02-16 10:59:52 +01:00
|
|
|
ret = ucl_object_iterate (rit->impl_it, &rit->expl_it, true);
|
2015-02-21 19:11:12 +01:00
|
|
|
|
2017-01-10 13:35:55 +01:00
|
|
|
if (ret == NULL && (type & UCL_ITERATE_IMPLICIT)) {
|
2015-02-21 19:11:12 +01:00
|
|
|
/* Need to switch to another implicit object in chain */
|
|
|
|
rit->impl_it = rit->impl_it->next;
|
|
|
|
rit->expl_it = NULL;
|
2017-01-17 20:19:34 +01:00
|
|
|
|
2017-01-10 13:35:55 +01:00
|
|
|
return ucl_object_iterate_safe (it, type);
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* Just iterate over the implicit array */
|
2017-03-08 16:54:46 +01:00
|
|
|
rit->flags = UCL_ITERATE_FLAG_IMPLICIT;
|
2015-02-21 19:11:12 +01:00
|
|
|
ret = rit->impl_it;
|
|
|
|
rit->impl_it = rit->impl_it->next;
|
2017-01-17 20:03:46 +01:00
|
|
|
|
2017-01-10 13:35:55 +01:00
|
|
|
if (type & UCL_ITERATE_EXPLICIT) {
|
2015-02-21 19:11:12 +01:00
|
|
|
/* We flatten objects if need to expand values */
|
|
|
|
if (ret->type == UCL_OBJECT || ret->type == UCL_ARRAY) {
|
2017-01-10 13:35:55 +01:00
|
|
|
return ucl_object_iterate_safe (it, type);
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ucl_object_iterate_free (ucl_object_iter_t it)
|
|
|
|
{
|
|
|
|
struct ucl_object_safe_iter *rit = UCL_SAFE_ITER (it);
|
|
|
|
|
|
|
|
UCL_SAFE_ITER_CHECK (rit);
|
|
|
|
|
2017-01-17 20:03:46 +01:00
|
|
|
if (rit->expl_it != NULL) {
|
2017-03-08 16:54:46 +01:00
|
|
|
if (rit->flags == UCL_ITERATE_FLAG_INSIDE_OBJECT) {
|
|
|
|
UCL_FREE (sizeof (*rit->expl_it), rit->expl_it);
|
|
|
|
}
|
2017-01-17 20:03:46 +01:00
|
|
|
}
|
|
|
|
|
2015-02-21 19:11:12 +01:00
|
|
|
UCL_FREE (sizeof (*rit), it);
|
|
|
|
}
|
|
|
|
|
|
|
|
const ucl_object_t *
|
2016-02-16 10:59:52 +01:00
|
|
|
ucl_object_lookup_path (const ucl_object_t *top, const char *path_in) {
|
|
|
|
return ucl_object_lookup_path_char (top, path_in, '.');
|
2015-04-28 15:39:25 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
const ucl_object_t *
|
2016-02-16 10:59:52 +01:00
|
|
|
ucl_object_lookup_path_char (const ucl_object_t *top, const char *path_in, const char sep) {
|
2015-02-21 19:11:12 +01:00
|
|
|
const ucl_object_t *o = NULL, *found;
|
|
|
|
const char *p, *c;
|
|
|
|
char *err_str;
|
|
|
|
unsigned index;
|
|
|
|
|
|
|
|
if (path_in == NULL || top == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
found = NULL;
|
|
|
|
p = path_in;
|
|
|
|
|
|
|
|
/* Skip leading dots */
|
2015-04-28 15:39:25 +02:00
|
|
|
while (*p == sep) {
|
2015-02-21 19:11:12 +01:00
|
|
|
p ++;
|
|
|
|
}
|
|
|
|
|
|
|
|
c = p;
|
|
|
|
while (*p != '\0') {
|
|
|
|
p ++;
|
2015-04-28 15:39:25 +02:00
|
|
|
if (*p == sep || *p == '\0') {
|
2015-02-21 19:11:12 +01:00
|
|
|
if (p > c) {
|
|
|
|
switch (top->type) {
|
|
|
|
case UCL_ARRAY:
|
|
|
|
/* Key should be an int */
|
|
|
|
index = strtoul (c, &err_str, 10);
|
2015-04-28 15:39:25 +02:00
|
|
|
if (err_str != NULL && (*err_str != sep && *err_str != '\0')) {
|
2015-02-21 19:11:12 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
o = ucl_array_find_index (top, index);
|
|
|
|
break;
|
|
|
|
default:
|
2016-02-16 10:59:52 +01:00
|
|
|
o = ucl_object_lookup_len (top, c, p - c);
|
2015-02-21 19:11:12 +01:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (o == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
top = o;
|
|
|
|
}
|
|
|
|
if (*p != '\0') {
|
|
|
|
c = p + 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
found = o;
|
|
|
|
|
|
|
|
return found;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
ucl_object_t *
|
|
|
|
ucl_object_new (void)
|
|
|
|
{
|
|
|
|
return ucl_object_typed_new (UCL_NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
ucl_object_t *
|
|
|
|
ucl_object_typed_new (ucl_type_t type)
|
|
|
|
{
|
|
|
|
return ucl_object_new_full (type, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
ucl_object_t *
|
|
|
|
ucl_object_new_full (ucl_type_t type, unsigned priority)
|
|
|
|
{
|
|
|
|
ucl_object_t *new;
|
|
|
|
|
|
|
|
if (type != UCL_USERDATA) {
|
|
|
|
new = UCL_ALLOC (sizeof (ucl_object_t));
|
|
|
|
if (new != NULL) {
|
|
|
|
memset (new, 0, sizeof (ucl_object_t));
|
|
|
|
new->ref = 1;
|
|
|
|
new->type = (type <= UCL_NULL ? type : UCL_NULL);
|
|
|
|
new->next = NULL;
|
|
|
|
new->prev = new;
|
|
|
|
ucl_object_set_priority (new, priority);
|
|
|
|
|
|
|
|
if (type == UCL_ARRAY) {
|
|
|
|
new->value.av = UCL_ALLOC (sizeof (ucl_array_t));
|
|
|
|
if (new->value.av) {
|
|
|
|
memset (new->value.av, 0, sizeof (ucl_array_t));
|
|
|
|
UCL_ARRAY_GET (vec, new);
|
|
|
|
|
|
|
|
/* Preallocate some space for arrays */
|
2019-04-25 13:13:09 +02:00
|
|
|
kv_resize_safe (ucl_object_t *, *vec, 8, enomem);
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
2016-02-14 14:34:42 +01:00
|
|
|
new = ucl_object_new_userdata (NULL, NULL, NULL);
|
2015-02-21 19:11:12 +01:00
|
|
|
ucl_object_set_priority (new, priority);
|
|
|
|
}
|
2019-04-25 13:13:09 +02:00
|
|
|
enomem:
|
2015-02-21 19:11:12 +01:00
|
|
|
return new;
|
|
|
|
}
|
|
|
|
|
2019-04-25 13:13:09 +02:00
|
|
|
bool ucl_object_reserve (ucl_object_t *obj, size_t reserved)
|
2018-02-14 12:42:36 +01:00
|
|
|
{
|
|
|
|
if (obj->type == UCL_ARRAY) {
|
|
|
|
UCL_ARRAY_GET (vec, obj);
|
|
|
|
|
|
|
|
if (vec->m < reserved) {
|
|
|
|
/* Preallocate some space for arrays */
|
2019-04-25 13:13:09 +02:00
|
|
|
kv_resize_safe (ucl_object_t *, *vec, reserved, e0);
|
2018-02-14 12:42:36 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (obj->type == UCL_OBJECT) {
|
|
|
|
ucl_hash_reserve (obj->value.ov, reserved);
|
|
|
|
}
|
2019-04-25 13:13:09 +02:00
|
|
|
return true;
|
|
|
|
e0:
|
|
|
|
return false;
|
2018-02-14 12:42:36 +01:00
|
|
|
}
|
|
|
|
|
2015-02-21 19:11:12 +01:00
|
|
|
ucl_object_t*
|
2016-02-14 14:34:42 +01:00
|
|
|
ucl_object_new_userdata (ucl_userdata_dtor dtor,
|
|
|
|
ucl_userdata_emitter emitter,
|
|
|
|
void *ptr)
|
2015-02-21 19:11:12 +01:00
|
|
|
{
|
|
|
|
struct ucl_object_userdata *new;
|
|
|
|
size_t nsize = sizeof (*new);
|
|
|
|
|
|
|
|
new = UCL_ALLOC (nsize);
|
|
|
|
if (new != NULL) {
|
|
|
|
memset (new, 0, nsize);
|
|
|
|
new->obj.ref = 1;
|
|
|
|
new->obj.type = UCL_USERDATA;
|
|
|
|
new->obj.next = NULL;
|
|
|
|
new->obj.prev = (ucl_object_t *)new;
|
|
|
|
new->dtor = dtor;
|
|
|
|
new->emitter = emitter;
|
2016-02-14 14:34:42 +01:00
|
|
|
new->obj.value.ud = ptr;
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return (ucl_object_t *)new;
|
|
|
|
}
|
|
|
|
|
|
|
|
ucl_type_t
|
|
|
|
ucl_object_type (const ucl_object_t *obj)
|
|
|
|
{
|
2015-04-28 15:39:25 +02:00
|
|
|
if (obj == NULL) {
|
|
|
|
return UCL_NULL;
|
|
|
|
}
|
|
|
|
|
2015-02-21 19:11:12 +01:00
|
|
|
return obj->type;
|
|
|
|
}
|
|
|
|
|
|
|
|
ucl_object_t*
|
|
|
|
ucl_object_fromstring (const char *str)
|
|
|
|
{
|
|
|
|
return ucl_object_fromstring_common (str, 0, UCL_STRING_ESCAPE);
|
|
|
|
}
|
|
|
|
|
|
|
|
ucl_object_t *
|
|
|
|
ucl_object_fromlstring (const char *str, size_t len)
|
|
|
|
{
|
|
|
|
return ucl_object_fromstring_common (str, len, UCL_STRING_ESCAPE);
|
|
|
|
}
|
|
|
|
|
|
|
|
ucl_object_t *
|
|
|
|
ucl_object_fromint (int64_t iv)
|
|
|
|
{
|
|
|
|
ucl_object_t *obj;
|
|
|
|
|
|
|
|
obj = ucl_object_new ();
|
|
|
|
if (obj != NULL) {
|
|
|
|
obj->type = UCL_INT;
|
|
|
|
obj->value.iv = iv;
|
|
|
|
}
|
|
|
|
|
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
|
|
|
|
ucl_object_t *
|
|
|
|
ucl_object_fromdouble (double dv)
|
|
|
|
{
|
|
|
|
ucl_object_t *obj;
|
|
|
|
|
|
|
|
obj = ucl_object_new ();
|
|
|
|
if (obj != NULL) {
|
|
|
|
obj->type = UCL_FLOAT;
|
|
|
|
obj->value.dv = dv;
|
|
|
|
}
|
|
|
|
|
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
|
|
|
|
ucl_object_t*
|
|
|
|
ucl_object_frombool (bool bv)
|
|
|
|
{
|
|
|
|
ucl_object_t *obj;
|
|
|
|
|
|
|
|
obj = ucl_object_new ();
|
|
|
|
if (obj != NULL) {
|
|
|
|
obj->type = UCL_BOOLEAN;
|
|
|
|
obj->value.iv = bv;
|
|
|
|
}
|
|
|
|
|
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
ucl_array_append (ucl_object_t *top, ucl_object_t *elt)
|
|
|
|
{
|
|
|
|
UCL_ARRAY_GET (vec, top);
|
|
|
|
|
|
|
|
if (elt == NULL || top == NULL) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (vec == NULL) {
|
|
|
|
vec = UCL_ALLOC (sizeof (*vec));
|
2015-07-28 17:57:15 +02:00
|
|
|
|
|
|
|
if (vec == NULL) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-02-21 19:11:12 +01:00
|
|
|
kv_init (*vec);
|
|
|
|
top->value.av = (void *)vec;
|
|
|
|
}
|
|
|
|
|
2019-04-25 13:13:09 +02:00
|
|
|
kv_push_safe (ucl_object_t *, *vec, elt, e0);
|
2015-02-21 19:11:12 +01:00
|
|
|
|
|
|
|
top->len ++;
|
|
|
|
|
|
|
|
return true;
|
2019-04-25 13:13:09 +02:00
|
|
|
e0:
|
|
|
|
return false;
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
ucl_array_prepend (ucl_object_t *top, ucl_object_t *elt)
|
|
|
|
{
|
|
|
|
UCL_ARRAY_GET (vec, top);
|
|
|
|
|
|
|
|
if (elt == NULL || top == NULL) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (vec == NULL) {
|
|
|
|
vec = UCL_ALLOC (sizeof (*vec));
|
|
|
|
kv_init (*vec);
|
|
|
|
top->value.av = (void *)vec;
|
2019-04-25 13:13:09 +02:00
|
|
|
kv_push_safe (ucl_object_t *, *vec, elt, e0);
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* Slow O(n) algorithm */
|
2019-04-25 13:13:09 +02:00
|
|
|
kv_prepend_safe (ucl_object_t *, *vec, elt, e0);
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
top->len ++;
|
|
|
|
|
|
|
|
return true;
|
2019-04-25 13:13:09 +02:00
|
|
|
e0:
|
|
|
|
return false;
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
ucl_array_merge (ucl_object_t *top, ucl_object_t *elt, bool copy)
|
|
|
|
{
|
|
|
|
unsigned i;
|
2015-07-28 17:57:15 +02:00
|
|
|
ucl_object_t *cp = NULL;
|
2015-02-21 19:11:12 +01:00
|
|
|
ucl_object_t **obj;
|
|
|
|
|
|
|
|
if (elt == NULL || top == NULL || top->type != UCL_ARRAY || elt->type != UCL_ARRAY) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2015-07-28 17:57:15 +02:00
|
|
|
if (copy) {
|
|
|
|
cp = ucl_object_copy (elt);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
cp = ucl_object_ref (elt);
|
|
|
|
}
|
|
|
|
|
|
|
|
UCL_ARRAY_GET (v1, top);
|
|
|
|
UCL_ARRAY_GET (v2, cp);
|
|
|
|
|
2016-02-16 14:22:17 +01:00
|
|
|
if (v1 && v2) {
|
2019-04-25 13:13:09 +02:00
|
|
|
kv_concat_safe (ucl_object_t *, *v1, *v2, e0);
|
2015-02-21 19:11:12 +01:00
|
|
|
|
2016-02-16 14:22:17 +01:00
|
|
|
for (i = v2->n; i < v1->n; i ++) {
|
|
|
|
obj = &kv_A (*v1, i);
|
|
|
|
if (*obj == NULL) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
top->len ++;
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
2019-04-25 13:13:09 +02:00
|
|
|
e0:
|
|
|
|
return false;
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
ucl_object_t *
|
|
|
|
ucl_array_delete (ucl_object_t *top, ucl_object_t *elt)
|
|
|
|
{
|
|
|
|
UCL_ARRAY_GET (vec, top);
|
|
|
|
ucl_object_t *ret = NULL;
|
|
|
|
unsigned i;
|
|
|
|
|
2015-07-28 17:57:15 +02:00
|
|
|
if (vec == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-02-21 19:11:12 +01:00
|
|
|
for (i = 0; i < vec->n; i ++) {
|
|
|
|
if (kv_A (*vec, i) == elt) {
|
|
|
|
kv_del (ucl_object_t *, *vec, i);
|
|
|
|
ret = elt;
|
|
|
|
top->len --;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
const ucl_object_t *
|
|
|
|
ucl_array_head (const ucl_object_t *top)
|
|
|
|
{
|
|
|
|
UCL_ARRAY_GET (vec, top);
|
|
|
|
|
2015-07-28 17:57:15 +02:00
|
|
|
if (vec == NULL || top == NULL || top->type != UCL_ARRAY ||
|
|
|
|
top->value.av == NULL) {
|
2015-02-21 19:11:12 +01:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return (vec->n > 0 ? vec->a[0] : NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
const ucl_object_t *
|
|
|
|
ucl_array_tail (const ucl_object_t *top)
|
|
|
|
{
|
|
|
|
UCL_ARRAY_GET (vec, top);
|
|
|
|
|
|
|
|
if (top == NULL || top->type != UCL_ARRAY || top->value.av == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return (vec->n > 0 ? vec->a[vec->n - 1] : NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
ucl_object_t *
|
|
|
|
ucl_array_pop_last (ucl_object_t *top)
|
|
|
|
{
|
|
|
|
UCL_ARRAY_GET (vec, top);
|
|
|
|
ucl_object_t **obj, *ret = NULL;
|
|
|
|
|
|
|
|
if (vec != NULL && vec->n > 0) {
|
|
|
|
obj = &kv_A (*vec, vec->n - 1);
|
|
|
|
ret = *obj;
|
|
|
|
kv_del (ucl_object_t *, *vec, vec->n - 1);
|
|
|
|
top->len --;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
ucl_object_t *
|
|
|
|
ucl_array_pop_first (ucl_object_t *top)
|
|
|
|
{
|
|
|
|
UCL_ARRAY_GET (vec, top);
|
|
|
|
ucl_object_t **obj, *ret = NULL;
|
|
|
|
|
|
|
|
if (vec != NULL && vec->n > 0) {
|
|
|
|
obj = &kv_A (*vec, 0);
|
|
|
|
ret = *obj;
|
|
|
|
kv_del (ucl_object_t *, *vec, 0);
|
|
|
|
top->len --;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2018-03-21 14:08:45 +01:00
|
|
|
unsigned int
|
|
|
|
ucl_array_size (const ucl_object_t *top)
|
|
|
|
{
|
|
|
|
if (top == NULL || top->type != UCL_ARRAY) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
UCL_ARRAY_GET (vec, top);
|
|
|
|
|
|
|
|
if (vec != NULL) {
|
|
|
|
return kv_size(*vec);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-02-21 19:11:12 +01:00
|
|
|
const ucl_object_t *
|
|
|
|
ucl_array_find_index (const ucl_object_t *top, unsigned int index)
|
|
|
|
{
|
|
|
|
UCL_ARRAY_GET (vec, top);
|
|
|
|
|
|
|
|
if (vec != NULL && vec->n > 0 && index < vec->n) {
|
|
|
|
return kv_A (*vec, index);
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-05-17 17:10:29 +02:00
|
|
|
unsigned int
|
|
|
|
ucl_array_index_of (ucl_object_t *top, ucl_object_t *elt)
|
|
|
|
{
|
|
|
|
UCL_ARRAY_GET (vec, top);
|
|
|
|
unsigned i;
|
|
|
|
|
2015-07-28 17:57:15 +02:00
|
|
|
if (vec == NULL) {
|
|
|
|
return (unsigned int)(-1);
|
|
|
|
}
|
|
|
|
|
2015-05-17 17:10:29 +02:00
|
|
|
for (i = 0; i < vec->n; i ++) {
|
|
|
|
if (kv_A (*vec, i) == elt) {
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return (unsigned int)(-1);
|
|
|
|
}
|
|
|
|
|
2015-02-21 19:11:12 +01:00
|
|
|
ucl_object_t *
|
|
|
|
ucl_array_replace_index (ucl_object_t *top, ucl_object_t *elt,
|
|
|
|
unsigned int index)
|
|
|
|
{
|
|
|
|
UCL_ARRAY_GET (vec, top);
|
|
|
|
ucl_object_t *ret = NULL;
|
|
|
|
|
|
|
|
if (vec != NULL && vec->n > 0 && index < vec->n) {
|
|
|
|
ret = kv_A (*vec, index);
|
|
|
|
kv_A (*vec, index) = elt;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
ucl_object_t *
|
|
|
|
ucl_elt_append (ucl_object_t *head, ucl_object_t *elt)
|
|
|
|
{
|
|
|
|
|
|
|
|
if (head == NULL) {
|
|
|
|
elt->next = NULL;
|
|
|
|
elt->prev = elt;
|
|
|
|
head = elt;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
elt->prev = head->prev;
|
|
|
|
head->prev->next = elt;
|
|
|
|
head->prev = elt;
|
|
|
|
elt->next = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return head;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
ucl_object_todouble_safe (const ucl_object_t *obj, double *target)
|
|
|
|
{
|
|
|
|
if (obj == NULL || target == NULL) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
switch (obj->type) {
|
|
|
|
case UCL_INT:
|
2017-06-27 09:44:19 +02:00
|
|
|
*target = obj->value.iv; /* Probably could cause overflow */
|
2015-02-21 19:11:12 +01:00
|
|
|
break;
|
|
|
|
case UCL_FLOAT:
|
|
|
|
case UCL_TIME:
|
|
|
|
*target = obj->value.dv;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
double
|
|
|
|
ucl_object_todouble (const ucl_object_t *obj)
|
|
|
|
{
|
|
|
|
double result = 0.;
|
|
|
|
|
|
|
|
ucl_object_todouble_safe (obj, &result);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
ucl_object_toint_safe (const ucl_object_t *obj, int64_t *target)
|
|
|
|
{
|
|
|
|
if (obj == NULL || target == NULL) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
switch (obj->type) {
|
|
|
|
case UCL_INT:
|
|
|
|
*target = obj->value.iv;
|
|
|
|
break;
|
|
|
|
case UCL_FLOAT:
|
|
|
|
case UCL_TIME:
|
2018-03-21 14:08:45 +01:00
|
|
|
*target = obj->value.dv; /* Losing of decimal points */
|
2015-02-21 19:11:12 +01:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
int64_t
|
|
|
|
ucl_object_toint (const ucl_object_t *obj)
|
|
|
|
{
|
|
|
|
int64_t result = 0;
|
|
|
|
|
|
|
|
ucl_object_toint_safe (obj, &result);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
ucl_object_toboolean_safe (const ucl_object_t *obj, bool *target)
|
|
|
|
{
|
|
|
|
if (obj == NULL || target == NULL) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
switch (obj->type) {
|
|
|
|
case UCL_BOOLEAN:
|
|
|
|
*target = (obj->value.iv == true);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
ucl_object_toboolean (const ucl_object_t *obj)
|
|
|
|
{
|
|
|
|
bool result = false;
|
|
|
|
|
|
|
|
ucl_object_toboolean_safe (obj, &result);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
ucl_object_tostring_safe (const ucl_object_t *obj, const char **target)
|
|
|
|
{
|
|
|
|
if (obj == NULL || target == NULL) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (obj->type) {
|
|
|
|
case UCL_STRING:
|
2015-10-13 18:05:19 +02:00
|
|
|
if (!(obj->flags & UCL_OBJECT_BINARY)) {
|
|
|
|
*target = ucl_copy_value_trash (obj);
|
|
|
|
}
|
2015-02-21 19:11:12 +01:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *
|
|
|
|
ucl_object_tostring (const ucl_object_t *obj)
|
|
|
|
{
|
|
|
|
const char *result = NULL;
|
|
|
|
|
|
|
|
ucl_object_tostring_safe (obj, &result);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *
|
|
|
|
ucl_object_tostring_forced (const ucl_object_t *obj)
|
|
|
|
{
|
2015-10-13 18:05:19 +02:00
|
|
|
/* TODO: For binary strings we might encode string here */
|
|
|
|
if (!(obj->flags & UCL_OBJECT_BINARY)) {
|
|
|
|
return ucl_copy_value_trash (obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
ucl_object_tolstring_safe (const ucl_object_t *obj, const char **target, size_t *tlen)
|
|
|
|
{
|
|
|
|
if (obj == NULL || target == NULL) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
switch (obj->type) {
|
|
|
|
case UCL_STRING:
|
|
|
|
*target = obj->value.sv;
|
|
|
|
if (tlen != NULL) {
|
|
|
|
*tlen = obj->len;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *
|
|
|
|
ucl_object_tolstring (const ucl_object_t *obj, size_t *tlen)
|
|
|
|
{
|
|
|
|
const char *result = NULL;
|
|
|
|
|
|
|
|
ucl_object_tolstring_safe (obj, &result, tlen);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *
|
|
|
|
ucl_object_key (const ucl_object_t *obj)
|
|
|
|
{
|
|
|
|
return ucl_copy_key_trash (obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *
|
|
|
|
ucl_object_keyl (const ucl_object_t *obj, size_t *len)
|
|
|
|
{
|
|
|
|
if (len == NULL || obj == NULL) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
*len = obj->keylen;
|
|
|
|
return obj->key;
|
|
|
|
}
|
|
|
|
|
|
|
|
ucl_object_t *
|
|
|
|
ucl_object_ref (const ucl_object_t *obj)
|
|
|
|
{
|
|
|
|
ucl_object_t *res = NULL;
|
|
|
|
|
|
|
|
if (obj != NULL) {
|
|
|
|
if (obj->flags & UCL_OBJECT_EPHEMERAL) {
|
|
|
|
/*
|
|
|
|
* Use deep copy for ephemeral objects, note that its refcount
|
|
|
|
* is NOT increased, since ephemeral objects does not need refcount
|
|
|
|
* at all
|
|
|
|
*/
|
|
|
|
res = ucl_object_copy (obj);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
res = __DECONST (ucl_object_t *, obj);
|
|
|
|
#ifdef HAVE_ATOMIC_BUILTINS
|
|
|
|
(void)__sync_add_and_fetch (&res->ref, 1);
|
|
|
|
#else
|
|
|
|
res->ref ++;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ucl_object_t *
|
|
|
|
ucl_object_copy_internal (const ucl_object_t *other, bool allow_array)
|
|
|
|
{
|
|
|
|
|
|
|
|
ucl_object_t *new;
|
|
|
|
ucl_object_iter_t it = NULL;
|
|
|
|
const ucl_object_t *cur;
|
|
|
|
|
|
|
|
new = malloc (sizeof (*new));
|
|
|
|
|
|
|
|
if (new != NULL) {
|
|
|
|
memcpy (new, other, sizeof (*new));
|
|
|
|
if (other->flags & UCL_OBJECT_EPHEMERAL) {
|
|
|
|
/* Copied object is always non ephemeral */
|
|
|
|
new->flags &= ~UCL_OBJECT_EPHEMERAL;
|
|
|
|
}
|
|
|
|
new->ref = 1;
|
|
|
|
/* Unlink from others */
|
|
|
|
new->next = NULL;
|
|
|
|
new->prev = new;
|
|
|
|
|
|
|
|
/* deep copy of values stored */
|
|
|
|
if (other->trash_stack[UCL_TRASH_KEY] != NULL) {
|
2022-01-06 15:05:35 +01:00
|
|
|
new->trash_stack[UCL_TRASH_KEY] = NULL;
|
2015-02-21 19:11:12 +01:00
|
|
|
if (other->key == (const char *)other->trash_stack[UCL_TRASH_KEY]) {
|
2022-01-06 15:05:35 +01:00
|
|
|
new->trash_stack[UCL_TRASH_KEY] = malloc(other->keylen + 1);
|
|
|
|
memcpy(new->trash_stack[UCL_TRASH_KEY], other->trash_stack[UCL_TRASH_KEY], other->keylen);
|
|
|
|
new->trash_stack[UCL_TRASH_KEY][other->keylen] = '\0';
|
2015-02-21 19:11:12 +01:00
|
|
|
new->key = new->trash_stack[UCL_TRASH_KEY];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (other->trash_stack[UCL_TRASH_VALUE] != NULL) {
|
|
|
|
new->trash_stack[UCL_TRASH_VALUE] =
|
|
|
|
strdup (other->trash_stack[UCL_TRASH_VALUE]);
|
|
|
|
if (new->type == UCL_STRING) {
|
|
|
|
new->value.sv = new->trash_stack[UCL_TRASH_VALUE];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (other->type == UCL_ARRAY || other->type == UCL_OBJECT) {
|
|
|
|
/* reset old value */
|
|
|
|
memset (&new->value, 0, sizeof (new->value));
|
|
|
|
|
2016-02-16 10:59:52 +01:00
|
|
|
while ((cur = ucl_object_iterate (other, &it, true)) != NULL) {
|
2015-02-21 19:11:12 +01:00
|
|
|
if (other->type == UCL_ARRAY) {
|
|
|
|
ucl_array_append (new, ucl_object_copy_internal (cur, false));
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
ucl_object_t *cp = ucl_object_copy_internal (cur, true);
|
|
|
|
if (cp != NULL) {
|
|
|
|
ucl_object_insert_key (new, cp, cp->key, cp->keylen,
|
|
|
|
false);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (allow_array && other->next != NULL) {
|
|
|
|
LL_FOREACH (other->next, cur) {
|
|
|
|
ucl_object_t *cp = ucl_object_copy_internal (cur, false);
|
|
|
|
if (cp != NULL) {
|
|
|
|
DL_APPEND (new, cp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return new;
|
|
|
|
}
|
|
|
|
|
|
|
|
ucl_object_t *
|
|
|
|
ucl_object_copy (const ucl_object_t *other)
|
|
|
|
{
|
|
|
|
return ucl_object_copy_internal (other, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ucl_object_unref (ucl_object_t *obj)
|
|
|
|
{
|
|
|
|
if (obj != NULL) {
|
|
|
|
#ifdef HAVE_ATOMIC_BUILTINS
|
|
|
|
unsigned int rc = __sync_sub_and_fetch (&obj->ref, 1);
|
|
|
|
if (rc == 0) {
|
|
|
|
#else
|
|
|
|
if (--obj->ref == 0) {
|
|
|
|
#endif
|
|
|
|
ucl_object_free_internal (obj, true, ucl_object_dtor_unref);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ucl_object_compare (const ucl_object_t *o1, const ucl_object_t *o2)
|
|
|
|
{
|
|
|
|
const ucl_object_t *it1, *it2;
|
|
|
|
ucl_object_iter_t iter = NULL;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (o1->type != o2->type) {
|
|
|
|
return (o1->type) - (o2->type);
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (o1->type) {
|
|
|
|
case UCL_STRING:
|
|
|
|
if (o1->len == o2->len && o1->len > 0) {
|
|
|
|
ret = strcmp (ucl_object_tostring(o1), ucl_object_tostring(o2));
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
ret = o1->len - o2->len;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case UCL_FLOAT:
|
|
|
|
case UCL_INT:
|
|
|
|
case UCL_TIME:
|
|
|
|
ret = ucl_object_todouble (o1) - ucl_object_todouble (o2);
|
|
|
|
break;
|
|
|
|
case UCL_BOOLEAN:
|
|
|
|
ret = ucl_object_toboolean (o1) - ucl_object_toboolean (o2);
|
|
|
|
break;
|
|
|
|
case UCL_ARRAY:
|
|
|
|
if (o1->len == o2->len && o1->len > 0) {
|
|
|
|
UCL_ARRAY_GET (vec1, o1);
|
|
|
|
UCL_ARRAY_GET (vec2, o2);
|
|
|
|
unsigned i;
|
|
|
|
|
|
|
|
/* Compare all elements in both arrays */
|
|
|
|
for (i = 0; i < vec1->n; i ++) {
|
|
|
|
it1 = kv_A (*vec1, i);
|
|
|
|
it2 = kv_A (*vec2, i);
|
|
|
|
|
|
|
|
if (it1 == NULL && it2 != NULL) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
else if (it2 == NULL && it1 != NULL) {
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
else if (it1 != NULL && it2 != NULL) {
|
|
|
|
ret = ucl_object_compare (it1, it2);
|
|
|
|
if (ret != 0) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
ret = o1->len - o2->len;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case UCL_OBJECT:
|
|
|
|
if (o1->len == o2->len && o1->len > 0) {
|
2016-02-16 10:59:52 +01:00
|
|
|
while ((it1 = ucl_object_iterate (o1, &iter, true)) != NULL) {
|
|
|
|
it2 = ucl_object_lookup (o2, ucl_object_key (it1));
|
2015-02-21 19:11:12 +01:00
|
|
|
if (it2 == NULL) {
|
|
|
|
ret = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
ret = ucl_object_compare (it1, it2);
|
|
|
|
if (ret != 0) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
ret = o1->len - o2->len;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ret = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-02-14 14:34:42 +01:00
|
|
|
int
|
|
|
|
ucl_object_compare_qsort (const ucl_object_t **o1,
|
|
|
|
const ucl_object_t **o2)
|
|
|
|
{
|
|
|
|
return ucl_object_compare (*o1, *o2);
|
|
|
|
}
|
|
|
|
|
2015-02-21 19:11:12 +01:00
|
|
|
void
|
|
|
|
ucl_object_array_sort (ucl_object_t *ar,
|
2015-10-19 19:53:39 +02:00
|
|
|
int (*cmp)(const ucl_object_t **o1, const ucl_object_t **o2))
|
2015-02-21 19:11:12 +01:00
|
|
|
{
|
|
|
|
UCL_ARRAY_GET (vec, ar);
|
|
|
|
|
|
|
|
if (cmp == NULL || ar == NULL || ar->type != UCL_ARRAY) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
qsort (vec->a, vec->n, sizeof (ucl_object_t *),
|
|
|
|
(int (*)(const void *, const void *))cmp);
|
|
|
|
}
|
|
|
|
|
2019-07-08 14:01:08 +02:00
|
|
|
void ucl_object_sort_keys (ucl_object_t *obj,
|
|
|
|
enum ucl_object_keys_sort_flags how)
|
|
|
|
{
|
|
|
|
if (obj != NULL && obj->type == UCL_OBJECT) {
|
|
|
|
ucl_hash_sort (obj->value.ov, how);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-21 19:11:12 +01:00
|
|
|
#define PRIOBITS 4
|
|
|
|
|
|
|
|
unsigned int
|
|
|
|
ucl_object_get_priority (const ucl_object_t *obj)
|
|
|
|
{
|
|
|
|
if (obj == NULL) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return (obj->flags >> ((sizeof (obj->flags) * NBBY) - PRIOBITS));
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ucl_object_set_priority (ucl_object_t *obj,
|
|
|
|
unsigned int priority)
|
|
|
|
{
|
|
|
|
if (obj != NULL) {
|
|
|
|
priority &= (0x1 << PRIOBITS) - 1;
|
2015-07-28 17:57:15 +02:00
|
|
|
priority <<= ((sizeof (obj->flags) * NBBY) - PRIOBITS);
|
|
|
|
priority |= obj->flags & ((1 << ((sizeof (obj->flags) * NBBY) -
|
|
|
|
PRIOBITS)) - 1);
|
|
|
|
obj->flags = priority;
|
2015-02-21 19:11:12 +01:00
|
|
|
}
|
|
|
|
}
|
2015-12-27 16:12:28 +01:00
|
|
|
|
|
|
|
bool
|
|
|
|
ucl_object_string_to_type (const char *input, ucl_type_t *res)
|
|
|
|
{
|
|
|
|
if (strcasecmp (input, "object") == 0) {
|
|
|
|
*res = UCL_OBJECT;
|
|
|
|
}
|
|
|
|
else if (strcasecmp (input, "array") == 0) {
|
|
|
|
*res = UCL_ARRAY;
|
|
|
|
}
|
|
|
|
else if (strcasecmp (input, "integer") == 0) {
|
|
|
|
*res = UCL_INT;
|
|
|
|
}
|
|
|
|
else if (strcasecmp (input, "number") == 0) {
|
|
|
|
*res = UCL_FLOAT;
|
|
|
|
}
|
|
|
|
else if (strcasecmp (input, "string") == 0) {
|
|
|
|
*res = UCL_STRING;
|
|
|
|
}
|
|
|
|
else if (strcasecmp (input, "boolean") == 0) {
|
|
|
|
*res = UCL_BOOLEAN;
|
|
|
|
}
|
|
|
|
else if (strcasecmp (input, "null") == 0) {
|
|
|
|
*res = UCL_NULL;
|
|
|
|
}
|
|
|
|
else if (strcasecmp (input, "userdata") == 0) {
|
|
|
|
*res = UCL_USERDATA;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *
|
|
|
|
ucl_object_type_to_string (ucl_type_t type)
|
|
|
|
{
|
|
|
|
const char *res = "unknown";
|
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
case UCL_OBJECT:
|
|
|
|
res = "object";
|
|
|
|
break;
|
|
|
|
case UCL_ARRAY:
|
|
|
|
res = "array";
|
|
|
|
break;
|
|
|
|
case UCL_INT:
|
|
|
|
res = "integer";
|
|
|
|
break;
|
|
|
|
case UCL_FLOAT:
|
|
|
|
case UCL_TIME:
|
|
|
|
res = "number";
|
|
|
|
break;
|
|
|
|
case UCL_STRING:
|
|
|
|
res = "string";
|
|
|
|
break;
|
|
|
|
case UCL_BOOLEAN:
|
|
|
|
res = "boolean";
|
|
|
|
break;
|
|
|
|
case UCL_USERDATA:
|
|
|
|
res = "userdata";
|
|
|
|
break;
|
|
|
|
case UCL_NULL:
|
|
|
|
res = "null";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
2016-02-08 19:26:58 +01:00
|
|
|
|
|
|
|
const ucl_object_t *
|
|
|
|
ucl_parser_get_comments (struct ucl_parser *parser)
|
|
|
|
{
|
|
|
|
if (parser && parser->comments) {
|
|
|
|
return parser->comments;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
const ucl_object_t *
|
|
|
|
ucl_comments_find (const ucl_object_t *comments,
|
|
|
|
const ucl_object_t *srch)
|
|
|
|
{
|
|
|
|
if (comments && srch) {
|
2016-02-16 10:59:52 +01:00
|
|
|
return ucl_object_lookup_len (comments, (const char *)&srch,
|
2016-02-08 19:26:58 +01:00
|
|
|
sizeof (void *));
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
2016-04-18 19:30:08 +02:00
|
|
|
|
|
|
|
bool
|
|
|
|
ucl_comments_move (ucl_object_t *comments,
|
|
|
|
const ucl_object_t *from, const ucl_object_t *to)
|
|
|
|
{
|
|
|
|
const ucl_object_t *found;
|
|
|
|
ucl_object_t *obj;
|
|
|
|
|
|
|
|
if (comments && from && to) {
|
|
|
|
found = ucl_object_lookup_len (comments,
|
|
|
|
(const char *)&from, sizeof (void *));
|
|
|
|
|
|
|
|
if (found) {
|
|
|
|
/* Replace key */
|
|
|
|
obj = ucl_object_ref (found);
|
|
|
|
ucl_object_delete_keyl (comments, (const char *)&from,
|
|
|
|
sizeof (void *));
|
|
|
|
ucl_object_insert_key (comments, obj, (const char *)&to,
|
|
|
|
sizeof (void *), true);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ucl_comments_add (ucl_object_t *comments, const ucl_object_t *obj,
|
|
|
|
const char *comment)
|
|
|
|
{
|
|
|
|
if (comments && obj && comment) {
|
|
|
|
ucl_object_insert_key (comments, ucl_object_fromstring (comment),
|
|
|
|
(const char *)&obj, sizeof (void *), true);
|
|
|
|
}
|
|
|
|
}
|
2019-03-07 16:29:14 +01:00
|
|
|
|
|
|
|
void
|
|
|
|
ucl_parser_set_include_tracer (struct ucl_parser *parser,
|
|
|
|
ucl_include_trace_func_t func,
|
|
|
|
void *user_data)
|
|
|
|
{
|
|
|
|
parser->include_trace_func = func;
|
|
|
|
parser->include_trace_ud = user_data;
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *
|
|
|
|
ucl_parser_get_cur_file (struct ucl_parser *parser)
|
|
|
|
{
|
|
|
|
return parser->cur_file;
|
|
|
|
}
|