Deleted Added
sdiff udiff text old ( 263019 ) new ( 268896 )
full compact
ucl_util.c (263019) ucl_util.c (268896)
1/* Copyright (c) 2013, Vsevolod Stakhov
2 * All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are met:
6 * * Redistributions of source code must retain the above copyright
7 * notice, this list of conditions and the following disclaimer.
8 * * Redistributions in binary form must reproduce the above copyright

--- 11 unchanged lines hidden (view full) ---

20 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
21 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
22 */
23
24#include "ucl.h"
25#include "ucl_internal.h"
26#include "ucl_chartable.h"
27
1/* Copyright (c) 2013, Vsevolod Stakhov
2 * All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are met:
6 * * Redistributions of source code must retain the above copyright
7 * notice, this list of conditions and the following disclaimer.
8 * * Redistributions in binary form must reproduce the above copyright

--- 11 unchanged lines hidden (view full) ---

20 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
21 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
22 */
23
24#include "ucl.h"
25#include "ucl_internal.h"
26#include "ucl_chartable.h"
27
28#ifdef HAVE_LIBGEN_H
28#include <libgen.h> /* For dirname */
29#include <libgen.h> /* For dirname */
30#endif
29
30#ifdef HAVE_OPENSSL
31#include <openssl/err.h>
32#include <openssl/sha.h>
33#include <openssl/rsa.h>
34#include <openssl/ssl.h>
35#include <openssl/evp.h>
36#endif
37
31
32#ifdef HAVE_OPENSSL
33#include <openssl/err.h>
34#include <openssl/sha.h>
35#include <openssl/rsa.h>
36#include <openssl/ssl.h>
37#include <openssl/evp.h>
38#endif
39
40#ifdef CURL_FOUND
41#include <curl/curl.h>
42#endif
43#ifdef HAVE_FETCH_H
44#include <fetch.h>
45#endif
46
38#ifdef _WIN32
39#include <windows.h>
40
47#ifdef _WIN32
48#include <windows.h>
49
50#ifndef PROT_READ
41#define PROT_READ 1
51#define PROT_READ 1
52#endif
53#ifndef PROT_WRITE
42#define PROT_WRITE 2
54#define PROT_WRITE 2
55#endif
56#ifndef PROT_READWRITE
43#define PROT_READWRITE 3
57#define PROT_READWRITE 3
58#endif
59#ifndef MAP_SHARED
44#define MAP_SHARED 1
60#define MAP_SHARED 1
61#endif
62#ifndef MAP_PRIVATE
45#define MAP_PRIVATE 2
63#define MAP_PRIVATE 2
64#endif
65#ifndef MAP_FAILED
46#define MAP_FAILED ((void *) -1)
66#define MAP_FAILED ((void *) -1)
67#endif
47
68
48static void *mmap(char *addr, size_t length, int prot, int access, int fd, off_t offset)
69static void *ucl_mmap(char *addr, size_t length, int prot, int access, int fd, off_t offset)
49{
50 void *map = NULL;
51 HANDLE handle = INVALID_HANDLE_VALUE;
52
53 switch (prot) {
54 default:
55 case PROT_READ:
56 {

--- 21 unchanged lines hidden (view full) ---

78 }
79 }
80 if (map == (void *) NULL) {
81 return (void *) MAP_FAILED;
82 }
83 return (void *) ((char *) map + offset);
84}
85
70{
71 void *map = NULL;
72 HANDLE handle = INVALID_HANDLE_VALUE;
73
74 switch (prot) {
75 default:
76 case PROT_READ:
77 {

--- 21 unchanged lines hidden (view full) ---

99 }
100 }
101 if (map == (void *) NULL) {
102 return (void *) MAP_FAILED;
103 }
104 return (void *) ((char *) map + offset);
105}
106
86static int munmap(void *map,size_t length)
107static int ucl_munmap(void *map,size_t length)
87{
88 if (!UnmapViewOfFile(map)) {
89 return(-1);
90 }
91 return(0);
92}
93
108{
109 if (!UnmapViewOfFile(map)) {
110 return(-1);
111 }
112 return(0);
113}
114
94static char* realpath(const char *path, char *resolved_path) {
115static char* ucl_realpath(const char *path, char *resolved_path) {
95 char *p;
96 char tmp[MAX_PATH + 1];
97 strncpy(tmp, path, sizeof(tmp)-1);
98 p = tmp;
99 while(*p) {
100 if (*p == '/') *p = '\\';
101 p++;
102 }
103 return _fullpath(resolved_path, tmp, MAX_PATH);
104}
116 char *p;
117 char tmp[MAX_PATH + 1];
118 strncpy(tmp, path, sizeof(tmp)-1);
119 p = tmp;
120 while(*p) {
121 if (*p == '/') *p = '\\';
122 p++;
123 }
124 return _fullpath(resolved_path, tmp, MAX_PATH);
125}
126#else
127#define ucl_mmap mmap
128#define ucl_munmap munmap
129#define ucl_realpath realpath
105#endif
106
107/**
108 * @file rcl_util.c
109 * Utilities for rcl parsing
110 */
111
130#endif
131
132/**
133 * @file rcl_util.c
134 * Utilities for rcl parsing
135 */
136
137typedef void (*ucl_object_dtor) (ucl_object_t *obj);
138static void ucl_object_free_internal (ucl_object_t *obj, bool allow_rec,
139 ucl_object_dtor dtor);
140static void ucl_object_dtor_unref (ucl_object_t *obj);
112
113static void
141
142static void
114ucl_object_free_internal (ucl_object_t *obj, bool allow_rec)
143ucl_object_dtor_free (ucl_object_t *obj)
115{
144{
116 ucl_object_t *sub, *tmp;
145 if (obj->trash_stack[UCL_TRASH_KEY] != NULL) {
146 UCL_FREE (obj->hh.keylen, obj->trash_stack[UCL_TRASH_KEY]);
147 }
148 if (obj->trash_stack[UCL_TRASH_VALUE] != NULL) {
149 UCL_FREE (obj->len, obj->trash_stack[UCL_TRASH_VALUE]);
150 }
151 UCL_FREE (sizeof (ucl_object_t), obj);
152}
117
153
118 while (obj != NULL) {
119 if (obj->trash_stack[UCL_TRASH_KEY] != NULL) {
120 UCL_FREE (obj->hh.keylen, obj->trash_stack[UCL_TRASH_KEY]);
154/*
155 * This is a helper function that performs exactly the same as
156 * `ucl_object_unref` but it doesn't iterate over elements allowing
157 * to use it for individual elements of arrays and multiple values
158 */
159static void
160ucl_object_dtor_unref_single (ucl_object_t *obj)
161{
162 if (obj != NULL) {
163#ifdef HAVE_ATOMIC_BUILTINS
164 unsigned int rc = __sync_sub_and_fetch (&obj->ref, 1);
165 if (rc == 0) {
166#else
167 if (--obj->ref == 0) {
168#endif
169 ucl_object_free_internal (obj, false, ucl_object_dtor_unref);
121 }
170 }
122 if (obj->trash_stack[UCL_TRASH_VALUE] != NULL) {
123 UCL_FREE (obj->len, obj->trash_stack[UCL_TRASH_VALUE]);
124 }
171 }
172}
125
173
174static void
175ucl_object_dtor_unref (ucl_object_t *obj)
176{
177 if (obj->ref == 0) {
178 ucl_object_dtor_free (obj);
179 }
180 else {
181 /* This may cause dtor unref being called one more time */
182 ucl_object_dtor_unref_single (obj);
183 }
184}
185
186static void
187ucl_object_free_internal (ucl_object_t *obj, bool allow_rec, ucl_object_dtor dtor)
188{
189 ucl_object_t *sub, *tmp;
190
191 while (obj != NULL) {
126 if (obj->type == UCL_ARRAY) {
127 sub = obj->value.av;
128 while (sub != NULL) {
129 tmp = sub->next;
192 if (obj->type == UCL_ARRAY) {
193 sub = obj->value.av;
194 while (sub != NULL) {
195 tmp = sub->next;
130 ucl_object_free_internal (sub, false);
196 dtor (sub);
131 sub = tmp;
132 }
133 }
134 else if (obj->type == UCL_OBJECT) {
135 if (obj->value.ov != NULL) {
197 sub = tmp;
198 }
199 }
200 else if (obj->type == UCL_OBJECT) {
201 if (obj->value.ov != NULL) {
136 ucl_hash_destroy (obj->value.ov, (ucl_hash_free_func *)ucl_object_unref);
202 ucl_hash_destroy (obj->value.ov, (ucl_hash_free_func *)dtor);
137 }
138 }
139 tmp = obj->next;
203 }
204 }
205 tmp = obj->next;
140 UCL_FREE (sizeof (ucl_object_t), obj);
206 dtor (obj);
141 obj = tmp;
142
143 if (!allow_rec) {
144 break;
145 }
146 }
147}
148
149void
150ucl_object_free (ucl_object_t *obj)
151{
207 obj = tmp;
208
209 if (!allow_rec) {
210 break;
211 }
212 }
213}
214
215void
216ucl_object_free (ucl_object_t *obj)
217{
152 ucl_object_free_internal (obj, true);
218 ucl_object_free_internal (obj, true, ucl_object_dtor_free);
153}
154
155size_t
156ucl_unescape_json_string (char *str, size_t len)
157{
158 char *t = str, *h = str;
159 int i, uval;
160
219}
220
221size_t
222ucl_unescape_json_string (char *str, size_t len)
223{
224 char *t = str, *h = str;
225 int i, uval;
226
227 if (len <= 1) {
228 return len;
229 }
161 /* t is target (tortoise), h is source (hare) */
162
163 while (len) {
164 if (*h == '\\') {
165 h ++;
166 switch (*h) {
167 case 'n':
168 *t++ = '\n';

--- 14 unchanged lines hidden (view full) ---

183 *t++ = '\\';
184 break;
185 case '"':
186 *t++ = '"';
187 break;
188 case 'u':
189 /* Unicode escape */
190 uval = 0;
230 /* t is target (tortoise), h is source (hare) */
231
232 while (len) {
233 if (*h == '\\') {
234 h ++;
235 switch (*h) {
236 case 'n':
237 *t++ = '\n';

--- 14 unchanged lines hidden (view full) ---

252 *t++ = '\\';
253 break;
254 case '"':
255 *t++ = '"';
256 break;
257 case 'u':
258 /* Unicode escape */
259 uval = 0;
191 for (i = 0; i < 4; i++) {
192 uval <<= 4;
193 if (isdigit (h[i])) {
194 uval += h[i] - '0';
260 if (len > 3) {
261 for (i = 0; i < 4; i++) {
262 uval <<= 4;
263 if (isdigit (h[i])) {
264 uval += h[i] - '0';
265 }
266 else if (h[i] >= 'a' && h[i] <= 'f') {
267 uval += h[i] - 'a' + 10;
268 }
269 else if (h[i] >= 'A' && h[i] <= 'F') {
270 uval += h[i] - 'A' + 10;
271 }
272 else {
273 break;
274 }
195 }
275 }
196 else if (h[i] >= 'a' && h[i] <= 'f') {
197 uval += h[i] - 'a' + 10;
276 h += 3;
277 len -= 3;
278 /* Encode */
279 if(uval < 0x80) {
280 t[0] = (char)uval;
281 t ++;
198 }
282 }
199 else if (h[i] >= 'A' && h[i] <= 'F') {
200 uval += h[i] - 'A' + 10;
283 else if(uval < 0x800) {
284 t[0] = 0xC0 + ((uval & 0x7C0) >> 6);
285 t[1] = 0x80 + ((uval & 0x03F));
286 t += 2;
201 }
287 }
288 else if(uval < 0x10000) {
289 t[0] = 0xE0 + ((uval & 0xF000) >> 12);
290 t[1] = 0x80 + ((uval & 0x0FC0) >> 6);
291 t[2] = 0x80 + ((uval & 0x003F));
292 t += 3;
293 }
294 else if(uval <= 0x10FFFF) {
295 t[0] = 0xF0 + ((uval & 0x1C0000) >> 18);
296 t[1] = 0x80 + ((uval & 0x03F000) >> 12);
297 t[2] = 0x80 + ((uval & 0x000FC0) >> 6);
298 t[3] = 0x80 + ((uval & 0x00003F));
299 t += 4;
300 }
301 else {
302 *t++ = '?';
303 }
202 }
304 }
203 h += 3;
204 len -= 3;
205 /* Encode */
206 if(uval < 0x80) {
207 t[0] = (char)uval;
208 t ++;
209 }
210 else if(uval < 0x800) {
211 t[0] = 0xC0 + ((uval & 0x7C0) >> 6);
212 t[1] = 0x80 + ((uval & 0x03F));
213 t += 2;
214 }
215 else if(uval < 0x10000) {
216 t[0] = 0xE0 + ((uval & 0xF000) >> 12);
217 t[1] = 0x80 + ((uval & 0x0FC0) >> 6);
218 t[2] = 0x80 + ((uval & 0x003F));
219 t += 3;
220 }
221 else if(uval <= 0x10FFFF) {
222 t[0] = 0xF0 + ((uval & 0x1C0000) >> 18);
223 t[1] = 0x80 + ((uval & 0x03F000) >> 12);
224 t[2] = 0x80 + ((uval & 0x000FC0) >> 6);
225 t[3] = 0x80 + ((uval & 0x00003F));
226 t += 4;
227 }
228 else {
305 else {
229 *t++ = '?';
306 *t++ = 'u';
230 }
231 break;
232 default:
233 *t++ = *h;
234 break;
235 }
236 h ++;
237 len --;
238 }
239 else {
240 *t++ = *h++;
241 }
242 len --;
243 }
244 *t = '\0';
245
246 return (t - str);
247}
248
307 }
308 break;
309 default:
310 *t++ = *h;
311 break;
312 }
313 h ++;
314 len --;
315 }
316 else {
317 *t++ = *h++;
318 }
319 len --;
320 }
321 *t = '\0';
322
323 return (t - str);
324}
325
249UCL_EXTERN char *
250ucl_copy_key_trash (ucl_object_t *obj)
326char *
327ucl_copy_key_trash (const ucl_object_t *obj)
251{
328{
329 ucl_object_t *deconst;
330
331 if (obj == NULL) {
332 return NULL;
333 }
252 if (obj->trash_stack[UCL_TRASH_KEY] == NULL && obj->key != NULL) {
334 if (obj->trash_stack[UCL_TRASH_KEY] == NULL && obj->key != NULL) {
253 obj->trash_stack[UCL_TRASH_KEY] = malloc (obj->keylen + 1);
254 if (obj->trash_stack[UCL_TRASH_KEY] != NULL) {
255 memcpy (obj->trash_stack[UCL_TRASH_KEY], obj->key, obj->keylen);
256 obj->trash_stack[UCL_TRASH_KEY][obj->keylen] = '\0';
335 deconst = __DECONST (ucl_object_t *, obj);
336 deconst->trash_stack[UCL_TRASH_KEY] = malloc (obj->keylen + 1);
337 if (deconst->trash_stack[UCL_TRASH_KEY] != NULL) {
338 memcpy (deconst->trash_stack[UCL_TRASH_KEY], obj->key, obj->keylen);
339 deconst->trash_stack[UCL_TRASH_KEY][obj->keylen] = '\0';
257 }
340 }
258 obj->key = obj->trash_stack[UCL_TRASH_KEY];
259 obj->flags |= UCL_OBJECT_ALLOCATED_KEY;
341 deconst->key = obj->trash_stack[UCL_TRASH_KEY];
342 deconst->flags |= UCL_OBJECT_ALLOCATED_KEY;
260 }
261
262 return obj->trash_stack[UCL_TRASH_KEY];
263}
264
343 }
344
345 return obj->trash_stack[UCL_TRASH_KEY];
346}
347
265UCL_EXTERN char *
266ucl_copy_value_trash (ucl_object_t *obj)
348char *
349ucl_copy_value_trash (const ucl_object_t *obj)
267{
350{
351 ucl_object_t *deconst;
352
353 if (obj == NULL) {
354 return NULL;
355 }
268 if (obj->trash_stack[UCL_TRASH_VALUE] == NULL) {
356 if (obj->trash_stack[UCL_TRASH_VALUE] == NULL) {
357 deconst = __DECONST (ucl_object_t *, obj);
269 if (obj->type == UCL_STRING) {
358 if (obj->type == UCL_STRING) {
359
270 /* Special case for strings */
360 /* Special case for strings */
271 obj->trash_stack[UCL_TRASH_VALUE] = malloc (obj->len + 1);
272 if (obj->trash_stack[UCL_TRASH_VALUE] != NULL) {
273 memcpy (obj->trash_stack[UCL_TRASH_VALUE], obj->value.sv, obj->len);
274 obj->trash_stack[UCL_TRASH_VALUE][obj->len] = '\0';
275 obj->value.sv = obj->trash_stack[UCL_TRASH_VALUE];
361 deconst->trash_stack[UCL_TRASH_VALUE] = malloc (obj->len + 1);
362 if (deconst->trash_stack[UCL_TRASH_VALUE] != NULL) {
363 memcpy (deconst->trash_stack[UCL_TRASH_VALUE], obj->value.sv, obj->len);
364 deconst->trash_stack[UCL_TRASH_VALUE][obj->len] = '\0';
365 deconst->value.sv = obj->trash_stack[UCL_TRASH_VALUE];
276 }
277 }
278 else {
279 /* Just emit value in json notation */
366 }
367 }
368 else {
369 /* Just emit value in json notation */
280 obj->trash_stack[UCL_TRASH_VALUE] = ucl_object_emit_single_json (obj);
281 obj->len = strlen (obj->trash_stack[UCL_TRASH_VALUE]);
370 deconst->trash_stack[UCL_TRASH_VALUE] = ucl_object_emit_single_json (obj);
371 deconst->len = strlen (obj->trash_stack[UCL_TRASH_VALUE]);
282 }
372 }
283 obj->flags |= UCL_OBJECT_ALLOCATED_VALUE;
373 deconst->flags |= UCL_OBJECT_ALLOCATED_VALUE;
284 }
285 return obj->trash_stack[UCL_TRASH_VALUE];
286}
287
288UCL_EXTERN ucl_object_t*
289ucl_parser_get_object (struct ucl_parser *parser)
290{
291 if (parser->state != UCL_STATE_ERROR && parser->top_obj != NULL) {

--- 7 unchanged lines hidden (view full) ---

299ucl_parser_free (struct ucl_parser *parser)
300{
301 struct ucl_stack *stack, *stmp;
302 struct ucl_macro *macro, *mtmp;
303 struct ucl_chunk *chunk, *ctmp;
304 struct ucl_pubkey *key, *ktmp;
305 struct ucl_variable *var, *vtmp;
306
374 }
375 return obj->trash_stack[UCL_TRASH_VALUE];
376}
377
378UCL_EXTERN ucl_object_t*
379ucl_parser_get_object (struct ucl_parser *parser)
380{
381 if (parser->state != UCL_STATE_ERROR && parser->top_obj != NULL) {

--- 7 unchanged lines hidden (view full) ---

389ucl_parser_free (struct ucl_parser *parser)
390{
391 struct ucl_stack *stack, *stmp;
392 struct ucl_macro *macro, *mtmp;
393 struct ucl_chunk *chunk, *ctmp;
394 struct ucl_pubkey *key, *ktmp;
395 struct ucl_variable *var, *vtmp;
396
397 if (parser == NULL) {
398 return;
399 }
400
307 if (parser->top_obj != NULL) {
308 ucl_object_unref (parser->top_obj);
309 }
310
311 LL_FOREACH_SAFE (parser->stack, stack, stmp) {
312 free (stack);
313 }
314 HASH_ITER (hh, parser->macroes, macro, mtmp) {

--- 18 unchanged lines hidden (view full) ---

333 }
334
335 UCL_FREE (sizeof (struct ucl_parser), parser);
336}
337
338UCL_EXTERN const char *
339ucl_parser_get_error(struct ucl_parser *parser)
340{
401 if (parser->top_obj != NULL) {
402 ucl_object_unref (parser->top_obj);
403 }
404
405 LL_FOREACH_SAFE (parser->stack, stack, stmp) {
406 free (stack);
407 }
408 HASH_ITER (hh, parser->macroes, macro, mtmp) {

--- 18 unchanged lines hidden (view full) ---

427 }
428
429 UCL_FREE (sizeof (struct ucl_parser), parser);
430}
431
432UCL_EXTERN const char *
433ucl_parser_get_error(struct ucl_parser *parser)
434{
435 if (parser == NULL) {
436 return NULL;
437 }
438
341 if (parser->err == NULL)
342 return NULL;
343
344 return utstring_body(parser->err);
345}
346
347UCL_EXTERN bool
348ucl_pubkey_add (struct ucl_parser *parser, const unsigned char *key, size_t len)

--- 6 unchanged lines hidden (view full) ---

355 ucl_create_err (&parser->err, "cannot check signatures, openssl version is unsupported");
356 return EXIT_FAILURE;
357# else
358 struct ucl_pubkey *nkey;
359 BIO *mem;
360
361 mem = BIO_new_mem_buf ((void *)key, len);
362 nkey = UCL_ALLOC (sizeof (struct ucl_pubkey));
439 if (parser->err == NULL)
440 return NULL;
441
442 return utstring_body(parser->err);
443}
444
445UCL_EXTERN bool
446ucl_pubkey_add (struct ucl_parser *parser, const unsigned char *key, size_t len)

--- 6 unchanged lines hidden (view full) ---

453 ucl_create_err (&parser->err, "cannot check signatures, openssl version is unsupported");
454 return EXIT_FAILURE;
455# else
456 struct ucl_pubkey *nkey;
457 BIO *mem;
458
459 mem = BIO_new_mem_buf ((void *)key, len);
460 nkey = UCL_ALLOC (sizeof (struct ucl_pubkey));
461 if (nkey == NULL) {
462 ucl_create_err (&parser->err, "cannot allocate memory for key");
463 return false;
464 }
363 nkey->key = PEM_read_bio_PUBKEY (mem, &nkey->key, NULL, NULL);
364 BIO_free (mem);
365 if (nkey->key == NULL) {
366 UCL_FREE (sizeof (struct ucl_pubkey), nkey);
367 ucl_create_err (&parser->err, "%s",
368 ERR_error_string (ERR_get_error (), NULL));
369 return false;
370 }

--- 151 unchanged lines hidden (view full) ---

522 *buflen = 0;
523 }
524 else {
525 if ((fd = open (filename, O_RDONLY)) == -1) {
526 ucl_create_err (err, "cannot open file %s: %s",
527 filename, strerror (errno));
528 return false;
529 }
465 nkey->key = PEM_read_bio_PUBKEY (mem, &nkey->key, NULL, NULL);
466 BIO_free (mem);
467 if (nkey->key == NULL) {
468 UCL_FREE (sizeof (struct ucl_pubkey), nkey);
469 ucl_create_err (&parser->err, "%s",
470 ERR_error_string (ERR_get_error (), NULL));
471 return false;
472 }

--- 151 unchanged lines hidden (view full) ---

624 *buflen = 0;
625 }
626 else {
627 if ((fd = open (filename, O_RDONLY)) == -1) {
628 ucl_create_err (err, "cannot open file %s: %s",
629 filename, strerror (errno));
630 return false;
631 }
530 if ((*buf = mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
632 if ((*buf = ucl_mmap (NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
531 close (fd);
532 ucl_create_err (err, "cannot mmap file %s: %s",
533 filename, strerror (errno));
534 return false;
535 }
536 *buflen = st.st_size;
537 close (fd);
538 }

--- 85 unchanged lines hidden (view full) ---

624 if (!ucl_fetch_url (urlbuf, &sigbuf, &siglen, &parser->err, true)) {
625 return false;
626 }
627 if (!ucl_sig_check (buf, buflen, sigbuf, siglen, parser)) {
628 ucl_create_err (&parser->err, "cannot verify url %s: %s",
629 urlbuf,
630 ERR_error_string (ERR_get_error (), NULL));
631 if (siglen > 0) {
633 close (fd);
634 ucl_create_err (err, "cannot mmap file %s: %s",
635 filename, strerror (errno));
636 return false;
637 }
638 *buflen = st.st_size;
639 close (fd);
640 }

--- 85 unchanged lines hidden (view full) ---

726 if (!ucl_fetch_url (urlbuf, &sigbuf, &siglen, &parser->err, true)) {
727 return false;
728 }
729 if (!ucl_sig_check (buf, buflen, sigbuf, siglen, parser)) {
730 ucl_create_err (&parser->err, "cannot verify url %s: %s",
731 urlbuf,
732 ERR_error_string (ERR_get_error (), NULL));
733 if (siglen > 0) {
632 munmap (sigbuf, siglen);
734 ucl_munmap (sigbuf, siglen);
633 }
634 return false;
635 }
636 if (siglen > 0) {
735 }
736 return false;
737 }
738 if (siglen > 0) {
637 munmap (sigbuf, siglen);
739 ucl_munmap (sigbuf, siglen);
638 }
639#endif
640 }
641
642 prev_state = parser->state;
643 parser->state = UCL_STATE_INIT;
644
645 res = ucl_parser_add_chunk (parser, buf, buflen);

--- 27 unchanged lines hidden (view full) ---

673 bool res;
674 struct ucl_chunk *chunk;
675 unsigned char *buf = NULL;
676 size_t buflen;
677 char filebuf[PATH_MAX], realbuf[PATH_MAX];
678 int prev_state;
679
680 snprintf (filebuf, sizeof (filebuf), "%.*s", (int)len, data);
740 }
741#endif
742 }
743
744 prev_state = parser->state;
745 parser->state = UCL_STATE_INIT;
746
747 res = ucl_parser_add_chunk (parser, buf, buflen);

--- 27 unchanged lines hidden (view full) ---

775 bool res;
776 struct ucl_chunk *chunk;
777 unsigned char *buf = NULL;
778 size_t buflen;
779 char filebuf[PATH_MAX], realbuf[PATH_MAX];
780 int prev_state;
781
782 snprintf (filebuf, sizeof (filebuf), "%.*s", (int)len, data);
681 if (realpath (filebuf, realbuf) == NULL) {
783 if (ucl_realpath (filebuf, realbuf) == NULL) {
682 if (!must_exist) {
683 return true;
684 }
685 ucl_create_err (&parser->err, "cannot open file %s: %s",
686 filebuf,
687 strerror (errno));
688 return false;
689 }

--- 11 unchanged lines hidden (view full) ---

701 if (!ucl_fetch_file (filebuf, &sigbuf, &siglen, &parser->err, true)) {
702 return false;
703 }
704 if (!ucl_sig_check (buf, buflen, sigbuf, siglen, parser)) {
705 ucl_create_err (&parser->err, "cannot verify file %s: %s",
706 filebuf,
707 ERR_error_string (ERR_get_error (), NULL));
708 if (siglen > 0) {
784 if (!must_exist) {
785 return true;
786 }
787 ucl_create_err (&parser->err, "cannot open file %s: %s",
788 filebuf,
789 strerror (errno));
790 return false;
791 }

--- 11 unchanged lines hidden (view full) ---

803 if (!ucl_fetch_file (filebuf, &sigbuf, &siglen, &parser->err, true)) {
804 return false;
805 }
806 if (!ucl_sig_check (buf, buflen, sigbuf, siglen, parser)) {
807 ucl_create_err (&parser->err, "cannot verify file %s: %s",
808 filebuf,
809 ERR_error_string (ERR_get_error (), NULL));
810 if (siglen > 0) {
709 munmap (sigbuf, siglen);
811 ucl_munmap (sigbuf, siglen);
710 }
711 return false;
712 }
713 if (siglen > 0) {
812 }
813 return false;
814 }
815 if (siglen > 0) {
714 munmap (sigbuf, siglen);
816 ucl_munmap (sigbuf, siglen);
715 }
716#endif
717 }
718
719 ucl_parser_set_filevars (parser, realbuf, false);
720
721 prev_state = parser->state;
722 parser->state = UCL_STATE_INIT;

--- 6 unchanged lines hidden (view full) ---

729 parser->chunks = chunk->next;
730 UCL_FREE (sizeof (struct ucl_chunk), chunk);
731 }
732 }
733
734 parser->state = prev_state;
735
736 if (buflen > 0) {
817 }
818#endif
819 }
820
821 ucl_parser_set_filevars (parser, realbuf, false);
822
823 prev_state = parser->state;
824 parser->state = UCL_STATE_INIT;

--- 6 unchanged lines hidden (view full) ---

831 parser->chunks = chunk->next;
832 UCL_FREE (sizeof (struct ucl_chunk), chunk);
833 }
834 }
835
836 parser->state = prev_state;
837
838 if (buflen > 0) {
737 munmap (buf, buflen);
839 ucl_munmap (buf, buflen);
738 }
739
740 return res;
741}
742
743/**
744 * Handle include macro
745 * @param data include data

--- 52 unchanged lines hidden (view full) ---

798
799UCL_EXTERN bool
800ucl_parser_set_filevars (struct ucl_parser *parser, const char *filename, bool need_expand)
801{
802 char realbuf[PATH_MAX], *curdir;
803
804 if (filename != NULL) {
805 if (need_expand) {
840 }
841
842 return res;
843}
844
845/**
846 * Handle include macro
847 * @param data include data

--- 52 unchanged lines hidden (view full) ---

900
901UCL_EXTERN bool
902ucl_parser_set_filevars (struct ucl_parser *parser, const char *filename, bool need_expand)
903{
904 char realbuf[PATH_MAX], *curdir;
905
906 if (filename != NULL) {
907 if (need_expand) {
806 if (realpath (filename, realbuf) == NULL) {
908 if (ucl_realpath (filename, realbuf) == NULL) {
807 return false;
808 }
809 }
810 else {
811 ucl_strlcpy (realbuf, filename, sizeof (realbuf));
812 }
813
814 /* Define variables */

--- 14 unchanged lines hidden (view full) ---

829UCL_EXTERN bool
830ucl_parser_add_file (struct ucl_parser *parser, const char *filename)
831{
832 unsigned char *buf;
833 size_t len;
834 bool ret;
835 char realbuf[PATH_MAX];
836
909 return false;
910 }
911 }
912 else {
913 ucl_strlcpy (realbuf, filename, sizeof (realbuf));
914 }
915
916 /* Define variables */

--- 14 unchanged lines hidden (view full) ---

931UCL_EXTERN bool
932ucl_parser_add_file (struct ucl_parser *parser, const char *filename)
933{
934 unsigned char *buf;
935 size_t len;
936 bool ret;
937 char realbuf[PATH_MAX];
938
837 if (realpath (filename, realbuf) == NULL) {
939 if (ucl_realpath (filename, realbuf) == NULL) {
838 ucl_create_err (&parser->err, "cannot open file %s: %s",
839 filename,
840 strerror (errno));
841 return false;
842 }
843
844 if (!ucl_fetch_file (realbuf, &buf, &len, &parser->err, true)) {
845 return false;
846 }
847
848 ucl_parser_set_filevars (parser, realbuf, false);
849 ret = ucl_parser_add_chunk (parser, buf, len);
850
851 if (len > 0) {
940 ucl_create_err (&parser->err, "cannot open file %s: %s",
941 filename,
942 strerror (errno));
943 return false;
944 }
945
946 if (!ucl_fetch_file (realbuf, &buf, &len, &parser->err, true)) {
947 return false;
948 }
949
950 ucl_parser_set_filevars (parser, realbuf, false);
951 ret = ucl_parser_add_chunk (parser, buf, len);
952
953 if (len > 0) {
852 munmap (buf, len);
954 ucl_munmap (buf, len);
853 }
854
855 return ret;
856}
857
858size_t
859ucl_strlcpy (char *dst, const char *src, size_t siz)
860{

--- 148 unchanged lines hidden (view full) ---

1009 }
1010 }
1011 if ((flags & UCL_STRING_PARSE) && dst != NULL) {
1012 /* Parse what we have */
1013 if (flags & UCL_STRING_PARSE_BOOLEAN) {
1014 if (!ucl_maybe_parse_boolean (obj, dst, obj->len) && (flags & UCL_STRING_PARSE_NUMBER)) {
1015 ucl_maybe_parse_number (obj, dst, dst + obj->len, &pos,
1016 flags & UCL_STRING_PARSE_DOUBLE,
955 }
956
957 return ret;
958}
959
960size_t
961ucl_strlcpy (char *dst, const char *src, size_t siz)
962{

--- 148 unchanged lines hidden (view full) ---

1111 }
1112 }
1113 if ((flags & UCL_STRING_PARSE) && dst != NULL) {
1114 /* Parse what we have */
1115 if (flags & UCL_STRING_PARSE_BOOLEAN) {
1116 if (!ucl_maybe_parse_boolean (obj, dst, obj->len) && (flags & UCL_STRING_PARSE_NUMBER)) {
1117 ucl_maybe_parse_number (obj, dst, dst + obj->len, &pos,
1118 flags & UCL_STRING_PARSE_DOUBLE,
1017 flags & UCL_STRING_PARSE_BYTES);
1119 flags & UCL_STRING_PARSE_BYTES,
1120 flags & UCL_STRING_PARSE_TIME);
1018 }
1019 }
1020 else {
1021 ucl_maybe_parse_number (obj, dst, dst + obj->len, &pos,
1022 flags & UCL_STRING_PARSE_DOUBLE,
1121 }
1122 }
1123 else {
1124 ucl_maybe_parse_number (obj, dst, dst + obj->len, &pos,
1125 flags & UCL_STRING_PARSE_DOUBLE,
1023 flags & UCL_STRING_PARSE_BYTES);
1126 flags & UCL_STRING_PARSE_BYTES,
1127 flags & UCL_STRING_PARSE_TIME);
1024 }
1025 }
1026 }
1027
1028 return obj;
1029}
1030
1128 }
1129 }
1130 }
1131
1132 return obj;
1133}
1134
1031static ucl_object_t *
1135static bool
1032ucl_object_insert_key_common (ucl_object_t *top, ucl_object_t *elt,
1033 const char *key, size_t keylen, bool copy_key, bool merge, bool replace)
1034{
1136ucl_object_insert_key_common (ucl_object_t *top, ucl_object_t *elt,
1137 const char *key, size_t keylen, bool copy_key, bool merge, bool replace)
1138{
1035 ucl_object_t *found, *cur;
1139 ucl_object_t *found, *tmp;
1140 const ucl_object_t *cur;
1036 ucl_object_iter_t it = NULL;
1037 const char *p;
1141 ucl_object_iter_t it = NULL;
1142 const char *p;
1143 int ret = true;
1038
1039 if (elt == NULL || key == NULL) {
1144
1145 if (elt == NULL || key == NULL) {
1040 return NULL;
1146 return false;
1041 }
1042
1043 if (top == NULL) {
1147 }
1148
1149 if (top == NULL) {
1044 top = ucl_object_new ();
1045 top->type = UCL_OBJECT;
1150 return false;
1046 }
1047
1048 if (top->type != UCL_OBJECT) {
1049 /* It is possible to convert NULL type to an object */
1050 if (top->type == UCL_NULL) {
1051 top->type = UCL_OBJECT;
1052 }
1053 else {
1054 /* Refuse converting of other object types */
1151 }
1152
1153 if (top->type != UCL_OBJECT) {
1154 /* It is possible to convert NULL type to an object */
1155 if (top->type == UCL_NULL) {
1156 top->type = UCL_OBJECT;
1157 }
1158 else {
1159 /* Refuse converting of other object types */
1055 return top;
1160 return false;
1056 }
1057 }
1058
1059 if (top->value.ov == NULL) {
1060 top->value.ov = ucl_hash_create ();
1061 }
1062
1063 if (keylen == 0) {

--- 9 unchanged lines hidden (view full) ---

1073
1074 elt->key = key;
1075 elt->keylen = keylen;
1076
1077 if (copy_key) {
1078 ucl_copy_key_trash (elt);
1079 }
1080
1161 }
1162 }
1163
1164 if (top->value.ov == NULL) {
1165 top->value.ov = ucl_hash_create ();
1166 }
1167
1168 if (keylen == 0) {

--- 9 unchanged lines hidden (view full) ---

1178
1179 elt->key = key;
1180 elt->keylen = keylen;
1181
1182 if (copy_key) {
1183 ucl_copy_key_trash (elt);
1184 }
1185
1081 found = ucl_hash_search_obj (top->value.ov, elt);
1186 found = __DECONST (ucl_object_t *, ucl_hash_search_obj (top->value.ov, elt));
1082
1083 if (!found) {
1084 top->value.ov = ucl_hash_insert_object (top->value.ov, elt);
1085 DL_APPEND (found, elt);
1187
1188 if (!found) {
1189 top->value.ov = ucl_hash_insert_object (top->value.ov, elt);
1190 DL_APPEND (found, elt);
1191 top->len ++;
1192 if (replace) {
1193 ret = false;
1194 }
1086 }
1087 else {
1088 if (replace) {
1089 ucl_hash_delete (top->value.ov, found);
1090 ucl_object_unref (found);
1091 top->value.ov = ucl_hash_insert_object (top->value.ov, elt);
1092 found = NULL;
1093 DL_APPEND (found, elt);
1094 }
1095 else if (merge) {
1096 if (found->type != UCL_OBJECT && elt->type == UCL_OBJECT) {
1097 /* Insert old elt to new one */
1195 }
1196 else {
1197 if (replace) {
1198 ucl_hash_delete (top->value.ov, found);
1199 ucl_object_unref (found);
1200 top->value.ov = ucl_hash_insert_object (top->value.ov, elt);
1201 found = NULL;
1202 DL_APPEND (found, elt);
1203 }
1204 else if (merge) {
1205 if (found->type != UCL_OBJECT && elt->type == UCL_OBJECT) {
1206 /* Insert old elt to new one */
1098 elt = ucl_object_insert_key_common (elt, found, found->key, found->keylen, copy_key, false, false);
1207 ucl_object_insert_key_common (elt, found, found->key,
1208 found->keylen, copy_key, false, false);
1099 ucl_hash_delete (top->value.ov, found);
1100 top->value.ov = ucl_hash_insert_object (top->value.ov, elt);
1101 }
1102 else if (found->type == UCL_OBJECT && elt->type != UCL_OBJECT) {
1103 /* Insert new to old */
1209 ucl_hash_delete (top->value.ov, found);
1210 top->value.ov = ucl_hash_insert_object (top->value.ov, elt);
1211 }
1212 else if (found->type == UCL_OBJECT && elt->type != UCL_OBJECT) {
1213 /* Insert new to old */
1104 found = ucl_object_insert_key_common (found, elt, elt->key, elt->keylen, copy_key, false, false);
1214 ucl_object_insert_key_common (found, elt, elt->key,
1215 elt->keylen, copy_key, false, false);
1105 }
1106 else if (found->type == UCL_OBJECT && elt->type == UCL_OBJECT) {
1107 /* Mix two hashes */
1108 while ((cur = ucl_iterate_object (elt, &it, true)) != NULL) {
1216 }
1217 else if (found->type == UCL_OBJECT && elt->type == UCL_OBJECT) {
1218 /* Mix two hashes */
1219 while ((cur = ucl_iterate_object (elt, &it, true)) != NULL) {
1109 ucl_object_ref (cur);
1110 found = ucl_object_insert_key_common (found, cur, cur->key, cur->keylen, copy_key, false, false);
1220 tmp = ucl_object_ref (cur);
1221 ucl_object_insert_key_common (found, tmp, cur->key,
1222 cur->keylen, copy_key, false, false);
1111 }
1112 ucl_object_unref (elt);
1113 }
1114 else {
1115 /* Just make a list of scalars */
1116 DL_APPEND (found, elt);
1117 }
1118 }
1119 else {
1120 DL_APPEND (found, elt);
1121 }
1122 }
1123
1223 }
1224 ucl_object_unref (elt);
1225 }
1226 else {
1227 /* Just make a list of scalars */
1228 DL_APPEND (found, elt);
1229 }
1230 }
1231 else {
1232 DL_APPEND (found, elt);
1233 }
1234 }
1235
1124 return top;
1236 return ret;
1125}
1126
1127bool
1237}
1238
1239bool
1128ucl_object_delete_keyl(ucl_object_t *top, const char *key, size_t keylen)
1240ucl_object_delete_keyl (ucl_object_t *top, const char *key, size_t keylen)
1129{
1130 ucl_object_t *found;
1131
1241{
1242 ucl_object_t *found;
1243
1132 found = ucl_object_find_keyl(top, key, keylen);
1244 if (top == NULL || key == NULL) {
1245 return false;
1246 }
1133
1247
1134 if (found == NULL)
1248 found = __DECONST (ucl_object_t *, ucl_object_find_keyl (top, key, keylen));
1249
1250 if (found == NULL) {
1135 return false;
1251 return false;
1252 }
1136
1253
1137 ucl_hash_delete(top->value.ov, found);
1254 ucl_hash_delete (top->value.ov, found);
1138 ucl_object_unref (found);
1139 top->len --;
1140
1141 return true;
1142}
1143
1144bool
1255 ucl_object_unref (found);
1256 top->len --;
1257
1258 return true;
1259}
1260
1261bool
1145ucl_object_delete_key(ucl_object_t *top, const char *key)
1262ucl_object_delete_key (ucl_object_t *top, const char *key)
1146{
1263{
1147 return ucl_object_delete_keyl(top, key, 0);
1264 return ucl_object_delete_keyl (top, key, strlen(key));
1148}
1149
1265}
1266
1150ucl_object_t *
1267ucl_object_t*
1268ucl_object_pop_keyl (ucl_object_t *top, const char *key, size_t keylen)
1269{
1270 const ucl_object_t *found;
1271
1272 if (top == NULL || key == NULL) {
1273 return false;
1274 }
1275 found = ucl_object_find_keyl (top, key, keylen);
1276
1277 if (found == NULL) {
1278 return NULL;
1279 }
1280 ucl_hash_delete (top->value.ov, found);
1281 top->len --;
1282
1283 return __DECONST (ucl_object_t *, found);
1284}
1285
1286ucl_object_t*
1287ucl_object_pop_key (ucl_object_t *top, const char *key)
1288{
1289 return ucl_object_pop_keyl (top, key, strlen(key));
1290}
1291
1292bool
1151ucl_object_insert_key (ucl_object_t *top, ucl_object_t *elt,
1152 const char *key, size_t keylen, bool copy_key)
1153{
1154 return ucl_object_insert_key_common (top, elt, key, keylen, copy_key, false, false);
1155}
1156
1293ucl_object_insert_key (ucl_object_t *top, ucl_object_t *elt,
1294 const char *key, size_t keylen, bool copy_key)
1295{
1296 return ucl_object_insert_key_common (top, elt, key, keylen, copy_key, false, false);
1297}
1298
1157ucl_object_t *
1299bool
1158ucl_object_insert_key_merged (ucl_object_t *top, ucl_object_t *elt,
1159 const char *key, size_t keylen, bool copy_key)
1160{
1161 return ucl_object_insert_key_common (top, elt, key, keylen, copy_key, true, false);
1162}
1163
1300ucl_object_insert_key_merged (ucl_object_t *top, ucl_object_t *elt,
1301 const char *key, size_t keylen, bool copy_key)
1302{
1303 return ucl_object_insert_key_common (top, elt, key, keylen, copy_key, true, false);
1304}
1305
1164ucl_object_t *
1306bool
1165ucl_object_replace_key (ucl_object_t *top, ucl_object_t *elt,
1166 const char *key, size_t keylen, bool copy_key)
1167{
1168 return ucl_object_insert_key_common (top, elt, key, keylen, copy_key, false, true);
1169}
1170
1307ucl_object_replace_key (ucl_object_t *top, ucl_object_t *elt,
1308 const char *key, size_t keylen, bool copy_key)
1309{
1310 return ucl_object_insert_key_common (top, elt, key, keylen, copy_key, false, true);
1311}
1312
1171ucl_object_t *
1172ucl_object_find_keyl (ucl_object_t *obj, const char *key, size_t klen)
1313const ucl_object_t *
1314ucl_object_find_keyl (const ucl_object_t *obj, const char *key, size_t klen)
1173{
1315{
1174 ucl_object_t *ret, srch;
1316 const ucl_object_t *ret;
1317 ucl_object_t srch;
1175
1176 if (obj == NULL || obj->type != UCL_OBJECT || key == NULL) {
1177 return NULL;
1178 }
1179
1180 srch.key = key;
1181 srch.keylen = klen;
1182 ret = ucl_hash_search_obj (obj->value.ov, &srch);
1183
1184 return ret;
1185}
1186
1318
1319 if (obj == NULL || obj->type != UCL_OBJECT || key == NULL) {
1320 return NULL;
1321 }
1322
1323 srch.key = key;
1324 srch.keylen = klen;
1325 ret = ucl_hash_search_obj (obj->value.ov, &srch);
1326
1327 return ret;
1328}
1329
1187ucl_object_t *
1188ucl_object_find_key (ucl_object_t *obj, const char *key)
1330const ucl_object_t *
1331ucl_object_find_key (const ucl_object_t *obj, const char *key)
1189{
1332{
1190 size_t klen;
1191 ucl_object_t *ret, srch;
1192
1193 if (obj == NULL || obj->type != UCL_OBJECT || key == NULL) {
1333 if (key == NULL)
1194 return NULL;
1334 return NULL;
1195 }
1196
1335
1197 klen = strlen (key);
1198 srch.key = key;
1199 srch.keylen = klen;
1200 ret = ucl_hash_search_obj (obj->value.ov, &srch);
1201
1202 return ret;
1336 return ucl_object_find_keyl (obj, key, strlen(key));
1203}
1204
1337}
1338
1205ucl_object_t*
1206ucl_iterate_object (ucl_object_t *obj, ucl_object_iter_t *iter, bool expand_values)
1339const ucl_object_t*
1340ucl_iterate_object (const ucl_object_t *obj, ucl_object_iter_t *iter, bool expand_values)
1207{
1341{
1208 ucl_object_t *elt;
1342 const ucl_object_t *elt;
1209
1343
1344 if (obj == NULL || iter == NULL) {
1345 return NULL;
1346 }
1347
1210 if (expand_values) {
1211 switch (obj->type) {
1212 case UCL_OBJECT:
1348 if (expand_values) {
1349 switch (obj->type) {
1350 case UCL_OBJECT:
1213 return (ucl_object_t*)ucl_hash_iterate (obj->value.ov, iter);
1351 return (const ucl_object_t*)ucl_hash_iterate (obj->value.ov, iter);
1214 break;
1215 case UCL_ARRAY:
1216 elt = *iter;
1217 if (elt == NULL) {
1218 elt = obj->value.av;
1219 if (elt == NULL) {
1220 return NULL;
1221 }

--- 14 unchanged lines hidden (view full) ---

1236 elt = obj;
1237 if (elt == NULL) {
1238 return NULL;
1239 }
1240 }
1241 else if (elt == obj) {
1242 return NULL;
1243 }
1352 break;
1353 case UCL_ARRAY:
1354 elt = *iter;
1355 if (elt == NULL) {
1356 elt = obj->value.av;
1357 if (elt == NULL) {
1358 return NULL;
1359 }

--- 14 unchanged lines hidden (view full) ---

1374 elt = obj;
1375 if (elt == NULL) {
1376 return NULL;
1377 }
1378 }
1379 else if (elt == obj) {
1380 return NULL;
1381 }
1244 *iter = elt->next ? elt->next : obj;
1382 *iter = __DECONST (void *, elt->next ? elt->next : obj);
1245 return elt;
1246
1247 /* Not reached */
1248 return NULL;
1249}
1383 return elt;
1384
1385 /* Not reached */
1386 return NULL;
1387}
1388
1389const ucl_object_t *
1390ucl_lookup_path (const ucl_object_t *top, const char *path_in) {
1391 const ucl_object_t *o = NULL, *found;
1392 const char *p, *c;
1393 char *err_str;
1394 unsigned index;
1395
1396 if (path_in == NULL || top == NULL) {
1397 return NULL;
1398 }
1399
1400 found = NULL;
1401 p = path_in;
1402
1403 /* Skip leading dots */
1404 while (*p == '.') {
1405 p ++;
1406 }
1407
1408 c = p;
1409 while (*p != '\0') {
1410 p ++;
1411 if (*p == '.' || *p == '\0') {
1412 if (p > c) {
1413 switch (top->type) {
1414 case UCL_ARRAY:
1415 /* Key should be an int */
1416 index = strtoul (c, &err_str, 10);
1417 if (err_str != NULL && (*err_str != '.' && *err_str != '\0')) {
1418 return NULL;
1419 }
1420 o = ucl_array_find_index (top, index);
1421 break;
1422 default:
1423 o = ucl_object_find_keyl (top, c, p - c);
1424 break;
1425 }
1426 if (o == NULL) {
1427 return NULL;
1428 }
1429 top = o;
1430 }
1431 if (*p != '\0') {
1432 c = p + 1;
1433 }
1434 }
1435 }
1436 found = o;
1437
1438 return found;
1439}
1440
1441
1442ucl_object_t *
1443ucl_object_new (void)
1444{
1445 ucl_object_t *new;
1446 new = malloc (sizeof (ucl_object_t));
1447 if (new != NULL) {
1448 memset (new, 0, sizeof (ucl_object_t));
1449 new->ref = 1;
1450 new->type = UCL_NULL;
1451 }
1452 return new;
1453}
1454
1455ucl_object_t *
1456ucl_object_typed_new (ucl_type_t type)
1457{
1458 ucl_object_t *new;
1459 new = malloc (sizeof (ucl_object_t));
1460 if (new != NULL) {
1461 memset (new, 0, sizeof (ucl_object_t));
1462 new->ref = 1;
1463 new->type = (type <= UCL_NULL ? type : UCL_NULL);
1464 }
1465 return new;
1466}
1467
1468ucl_type_t
1469ucl_object_type (const ucl_object_t *obj)
1470{
1471 return obj->type;
1472}
1473
1474ucl_object_t*
1475ucl_object_fromstring (const char *str)
1476{
1477 return ucl_object_fromstring_common (str, 0, UCL_STRING_ESCAPE);
1478}
1479
1480ucl_object_t *
1481ucl_object_fromlstring (const char *str, size_t len)
1482{
1483 return ucl_object_fromstring_common (str, len, UCL_STRING_ESCAPE);
1484}
1485
1486ucl_object_t *
1487ucl_object_fromint (int64_t iv)
1488{
1489 ucl_object_t *obj;
1490
1491 obj = ucl_object_new ();
1492 if (obj != NULL) {
1493 obj->type = UCL_INT;
1494 obj->value.iv = iv;
1495 }
1496
1497 return obj;
1498}
1499
1500ucl_object_t *
1501ucl_object_fromdouble (double dv)
1502{
1503 ucl_object_t *obj;
1504
1505 obj = ucl_object_new ();
1506 if (obj != NULL) {
1507 obj->type = UCL_FLOAT;
1508 obj->value.dv = dv;
1509 }
1510
1511 return obj;
1512}
1513
1514ucl_object_t*
1515ucl_object_frombool (bool bv)
1516{
1517 ucl_object_t *obj;
1518
1519 obj = ucl_object_new ();
1520 if (obj != NULL) {
1521 obj->type = UCL_BOOLEAN;
1522 obj->value.iv = bv;
1523 }
1524
1525 return obj;
1526}
1527
1528bool
1529ucl_array_append (ucl_object_t *top, ucl_object_t *elt)
1530{
1531 ucl_object_t *head;
1532
1533 if (elt == NULL || top == NULL) {
1534 return false;
1535 }
1536
1537 head = top->value.av;
1538 if (head == NULL) {
1539 top->value.av = elt;
1540 elt->prev = elt;
1541 }
1542 else {
1543 elt->prev = head->prev;
1544 head->prev->next = elt;
1545 head->prev = elt;
1546 }
1547 elt->next = NULL;
1548 top->len ++;
1549
1550 return true;
1551}
1552
1553bool
1554ucl_array_prepend (ucl_object_t *top, ucl_object_t *elt)
1555{
1556 ucl_object_t *head;
1557
1558 if (elt == NULL || top == NULL) {
1559 return false;
1560 }
1561
1562
1563 head = top->value.av;
1564 if (head == NULL) {
1565 top->value.av = elt;
1566 elt->prev = elt;
1567 }
1568 else {
1569 elt->prev = head->prev;
1570 head->prev = elt;
1571 }
1572 elt->next = head;
1573 top->value.av = elt;
1574 top->len ++;
1575
1576 return true;
1577}
1578
1579ucl_object_t *
1580ucl_array_delete (ucl_object_t *top, ucl_object_t *elt)
1581{
1582 ucl_object_t *head;
1583
1584 if (top == NULL || top->type != UCL_ARRAY || top->value.av == NULL) {
1585 return NULL;
1586 }
1587 head = top->value.av;
1588
1589 if (elt->prev == elt) {
1590 top->value.av = NULL;
1591 }
1592 else if (elt == head) {
1593 elt->next->prev = elt->prev;
1594 top->value.av = elt->next;
1595 }
1596 else {
1597 elt->prev->next = elt->next;
1598 if (elt->next) {
1599 elt->next->prev = elt->prev;
1600 }
1601 else {
1602 head->prev = elt->prev;
1603 }
1604 }
1605 elt->next = NULL;
1606 elt->prev = elt;
1607 top->len --;
1608
1609 return elt;
1610}
1611
1612const ucl_object_t *
1613ucl_array_head (const ucl_object_t *top)
1614{
1615 if (top == NULL || top->type != UCL_ARRAY || top->value.av == NULL) {
1616 return NULL;
1617 }
1618 return top->value.av;
1619}
1620
1621const ucl_object_t *
1622ucl_array_tail (const ucl_object_t *top)
1623{
1624 if (top == NULL || top->type != UCL_ARRAY || top->value.av == NULL) {
1625 return NULL;
1626 }
1627 return top->value.av->prev;
1628}
1629
1630ucl_object_t *
1631ucl_array_pop_last (ucl_object_t *top)
1632{
1633 return ucl_array_delete (top, __DECONST(ucl_object_t *, ucl_array_tail (top)));
1634}
1635
1636ucl_object_t *
1637ucl_array_pop_first (ucl_object_t *top)
1638{
1639 return ucl_array_delete (top, __DECONST(ucl_object_t *, ucl_array_head (top)));
1640}
1641
1642const ucl_object_t *
1643ucl_array_find_index (const ucl_object_t *top, unsigned int index)
1644{
1645 ucl_object_iter_t it = NULL;
1646 const ucl_object_t *ret;
1647
1648 if (top == NULL || top->type != UCL_ARRAY || top->len == 0 ||
1649 (index + 1) > top->len) {
1650 return NULL;
1651 }
1652
1653 while ((ret = ucl_iterate_object (top, &it, true)) != NULL) {
1654 if (index == 0) {
1655 return ret;
1656 }
1657 --index;
1658 }
1659
1660 return NULL;
1661}
1662
1663ucl_object_t *
1664ucl_elt_append (ucl_object_t *head, ucl_object_t *elt)
1665{
1666
1667 if (head == NULL) {
1668 elt->next = NULL;
1669 elt->prev = elt;
1670 head = elt;
1671 }
1672 else {
1673 elt->prev = head->prev;
1674 head->prev->next = elt;
1675 head->prev = elt;
1676 elt->next = NULL;
1677 }
1678
1679 return head;
1680}
1681
1682bool
1683ucl_object_todouble_safe (const ucl_object_t *obj, double *target)
1684{
1685 if (obj == NULL || target == NULL) {
1686 return false;
1687 }
1688 switch (obj->type) {
1689 case UCL_INT:
1690 *target = obj->value.iv; /* Probaly could cause overflow */
1691 break;
1692 case UCL_FLOAT:
1693 case UCL_TIME:
1694 *target = obj->value.dv;
1695 break;
1696 default:
1697 return false;
1698 }
1699
1700 return true;
1701}
1702
1703double
1704ucl_object_todouble (const ucl_object_t *obj)
1705{
1706 double result = 0.;
1707
1708 ucl_object_todouble_safe (obj, &result);
1709 return result;
1710}
1711
1712bool
1713ucl_object_toint_safe (const ucl_object_t *obj, int64_t *target)
1714{
1715 if (obj == NULL || target == NULL) {
1716 return false;
1717 }
1718 switch (obj->type) {
1719 case UCL_INT:
1720 *target = obj->value.iv;
1721 break;
1722 case UCL_FLOAT:
1723 case UCL_TIME:
1724 *target = obj->value.dv; /* Loosing of decimal points */
1725 break;
1726 default:
1727 return false;
1728 }
1729
1730 return true;
1731}
1732
1733int64_t
1734ucl_object_toint (const ucl_object_t *obj)
1735{
1736 int64_t result = 0;
1737
1738 ucl_object_toint_safe (obj, &result);
1739 return result;
1740}
1741
1742bool
1743ucl_object_toboolean_safe (const ucl_object_t *obj, bool *target)
1744{
1745 if (obj == NULL || target == NULL) {
1746 return false;
1747 }
1748 switch (obj->type) {
1749 case UCL_BOOLEAN:
1750 *target = (obj->value.iv == true);
1751 break;
1752 default:
1753 return false;
1754 }
1755
1756 return true;
1757}
1758
1759bool
1760ucl_object_toboolean (const ucl_object_t *obj)
1761{
1762 bool result = false;
1763
1764 ucl_object_toboolean_safe (obj, &result);
1765 return result;
1766}
1767
1768bool
1769ucl_object_tostring_safe (const ucl_object_t *obj, const char **target)
1770{
1771 if (obj == NULL || target == NULL) {
1772 return false;
1773 }
1774
1775 switch (obj->type) {
1776 case UCL_STRING:
1777 *target = ucl_copy_value_trash (obj);
1778 break;
1779 default:
1780 return false;
1781 }
1782
1783 return true;
1784}
1785
1786const char *
1787ucl_object_tostring (const ucl_object_t *obj)
1788{
1789 const char *result = NULL;
1790
1791 ucl_object_tostring_safe (obj, &result);
1792 return result;
1793}
1794
1795const char *
1796ucl_object_tostring_forced (const ucl_object_t *obj)
1797{
1798 return ucl_copy_value_trash (obj);
1799}
1800
1801bool
1802ucl_object_tolstring_safe (const ucl_object_t *obj, const char **target, size_t *tlen)
1803{
1804 if (obj == NULL || target == NULL) {
1805 return false;
1806 }
1807 switch (obj->type) {
1808 case UCL_STRING:
1809 *target = obj->value.sv;
1810 if (tlen != NULL) {
1811 *tlen = obj->len;
1812 }
1813 break;
1814 default:
1815 return false;
1816 }
1817
1818 return true;
1819}
1820
1821const char *
1822ucl_object_tolstring (const ucl_object_t *obj, size_t *tlen)
1823{
1824 const char *result = NULL;
1825
1826 ucl_object_tolstring_safe (obj, &result, tlen);
1827 return result;
1828}
1829
1830const char *
1831ucl_object_key (const ucl_object_t *obj)
1832{
1833 return ucl_copy_key_trash (obj);
1834}
1835
1836const char *
1837ucl_object_keyl (const ucl_object_t *obj, size_t *len)
1838{
1839 if (len == NULL || obj == NULL) {
1840 return NULL;
1841 }
1842 *len = obj->keylen;
1843 return obj->key;
1844}
1845
1846ucl_object_t *
1847ucl_object_ref (const ucl_object_t *obj)
1848{
1849 ucl_object_t *res = NULL;
1850
1851 if (obj != NULL) {
1852 res = __DECONST (ucl_object_t *, obj);
1853#ifdef HAVE_ATOMIC_BUILTINS
1854 (void)__sync_add_and_fetch (&res->ref, 1);
1855#else
1856 res->ref ++;
1857#endif
1858 }
1859 return res;
1860}
1861
1862void
1863ucl_object_unref (ucl_object_t *obj)
1864{
1865 if (obj != NULL) {
1866#ifdef HAVE_ATOMIC_BUILTINS
1867 unsigned int rc = __sync_sub_and_fetch (&obj->ref, 1);
1868 if (rc == 0) {
1869#else
1870 if (--obj->ref == 0) {
1871#endif
1872 ucl_object_free_internal (obj, true, ucl_object_dtor_unref);
1873 }
1874 }
1875}
1876
1877int
1878ucl_object_compare (const ucl_object_t *o1, const ucl_object_t *o2)
1879{
1880 const ucl_object_t *it1, *it2;
1881 ucl_object_iter_t iter = NULL;
1882 int ret = 0;
1883
1884 if (o1->type != o2->type) {
1885 return (o1->type) - (o2->type);
1886 }
1887
1888 switch (o1->type) {
1889 case UCL_STRING:
1890 if (o1->len == o2->len) {
1891 ret = strcmp (ucl_object_tostring(o1), ucl_object_tostring(o2));
1892 }
1893 else {
1894 ret = o1->len - o2->len;
1895 }
1896 break;
1897 case UCL_FLOAT:
1898 case UCL_INT:
1899 case UCL_TIME:
1900 ret = ucl_object_todouble (o1) - ucl_object_todouble (o2);
1901 break;
1902 case UCL_BOOLEAN:
1903 ret = ucl_object_toboolean (o1) - ucl_object_toboolean (o2);
1904 break;
1905 case UCL_ARRAY:
1906 if (o1->len == o2->len) {
1907 it1 = o1->value.av;
1908 it2 = o2->value.av;
1909 /* Compare all elements in both arrays */
1910 while (it1 != NULL && it2 != NULL) {
1911 ret = ucl_object_compare (it1, it2);
1912 if (ret != 0) {
1913 break;
1914 }
1915 it1 = it1->next;
1916 it2 = it2->next;
1917 }
1918 }
1919 else {
1920 ret = o1->len - o2->len;
1921 }
1922 break;
1923 case UCL_OBJECT:
1924 if (o1->len == o2->len) {
1925 while ((it1 = ucl_iterate_object (o1, &iter, true)) != NULL) {
1926 it2 = ucl_object_find_key (o2, ucl_object_key (it1));
1927 if (it2 == NULL) {
1928 ret = 1;
1929 break;
1930 }
1931 ret = ucl_object_compare (it1, it2);
1932 if (ret != 0) {
1933 break;
1934 }
1935 }
1936 }
1937 else {
1938 ret = o1->len - o2->len;
1939 }
1940 break;
1941 default:
1942 ret = 0;
1943 break;
1944 }
1945
1946 return ret;
1947}
1948
1949void
1950ucl_object_array_sort (ucl_object_t *ar,
1951 int (*cmp)(const ucl_object_t *o1, const ucl_object_t *o2))
1952{
1953 if (cmp == NULL || ar == NULL || ar->type != UCL_ARRAY) {
1954 return;
1955 }
1956
1957 DL_SORT (ar->value.av, cmp);
1958}