contrib/libucl/src/ucl_internal.h

   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
   9  *         notice, this list of conditions and the following disclaimer in the
  10  *         documentation and/or other materials provided with the distribution.
  11  *
  12  * THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY
  13  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  14  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  15  * DISCLAIMED. IN NO EVENT SHALL AUTHOR BE LIABLE FOR ANY
  16  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  17  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  18  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  19  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  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 #ifndef UCL_INTERNAL_H_
  25 #define UCL_INTERNAL_H_
  26
  27 #ifdef HAVE_CONFIG_H
  28 #include "config.h"
  29 #else
  30 /* Help embedded builds */
  31 #define HAVE_SYS_TYPES_H
  32 #define HAVE_SYS_MMAN_H
  33 #define HAVE_SYS_STAT_H
  34 #define HAVE_SYS_PARAM_H
  35 #define HAVE_LIMITS_H
  36 #define HAVE_FCNTL_H
  37 #define HAVE_ERRNO_H
  38 #define HAVE_UNISTD_H
  39 #define HAVE_CTYPE_H
  40 #define HAVE_STDIO_H
  41 #define HAVE_STRING_H
  42 #define HAVE_FLOAT_H
  43 #define HAVE_LIBGEN_H
  44 #define HAVE_MATH_H
  45 #define HAVE_STDBOOL_H
  46 #define HAVE_STDINT_H
  47 #define HAVE_STDARG_H
  48 #ifndef _WIN32
  49 # define HAVE_REGEX_H
  50 #endif
  51 #endif
  52
  53 #ifdef HAVE_SYS_TYPES_H
  54 #include <sys/types.h>
  55 #endif
  56
  57 #ifdef HAVE_SYS_MMAN_H
  58 # ifndef _WIN32
  59 #  include <sys/mman.h>
  60 # endif
  61 #endif
  62 #ifdef HAVE_SYS_STAT_H
  63 #include <sys/stat.h>
  64 #endif
  65 #ifdef HAVE_SYS_PARAM_H
  66 #include <sys/param.h>
  67 #endif
  68
  69 #ifdef HAVE_LIMITS_H
  70 #include <limits.h>
  71 #endif
  72 #ifdef HAVE_FCNTL_H
  73 #include <fcntl.h>
  74 #endif
  75 #ifdef HAVE_ERRNO_H
  76 #include <errno.h>
  77 #endif
  78 #ifdef HAVE_UNISTD_H
  79 #include <unistd.h>
  80 #endif
  81 #ifdef HAVE_CTYPE_H
  82 #include <ctype.h>
  83 #endif
  84 #ifdef HAVE_STDIO_H
  85 #include <stdio.h>
  86 #endif
  87 #ifdef HAVE_STRING_H
  88 #include <string.h>
  89 #endif
  90 #ifdef HAVE_STRINGS_H
  91 #include <strings.h>
  92 #endif
  93
  94 #include "utlist.h"
  95 #include "utstring.h"
  96 #include "uthash.h"
  97 #include "ucl.h"
  98 #include "ucl_hash.h"
  99
 100 #ifdef HAVE_OPENSSL
 101 #include <openssl/evp.h>
 102 #endif
 103
 104 #ifndef __DECONST
 105 #define __DECONST(type, var)    ((type)(uintptr_t)(const void *)(var))
 106 #endif
 107
 108 /**
 109  * @file rcl_internal.h
 110  * Internal structures and functions of UCL library
 111  */
 112
 113 #define UCL_MAX_RECURSION 16
 114 #define UCL_TRASH_KEY 0
 115 #define UCL_TRASH_VALUE 1
 116
 117 enum ucl_parser_state {
 118         UCL_STATE_INIT = 0,
 119         UCL_STATE_OBJECT,
 120         UCL_STATE_ARRAY,
 121         UCL_STATE_KEY,
 122         UCL_STATE_VALUE,
 123         UCL_STATE_AFTER_VALUE,
 124         UCL_STATE_ARRAY_VALUE,
 125         UCL_STATE_SCOMMENT,
 126         UCL_STATE_MCOMMENT,
 127         UCL_STATE_MACRO_NAME,
 128         UCL_STATE_MACRO,
 129         UCL_STATE_ERROR
 130 };
 131
 132 enum ucl_character_type {
 133         UCL_CHARACTER_DENIED = (1 << 0),
 134         UCL_CHARACTER_KEY = (1 << 1),
 135         UCL_CHARACTER_KEY_START = (1 << 2),
 136         UCL_CHARACTER_WHITESPACE = (1 << 3),
 137         UCL_CHARACTER_WHITESPACE_UNSAFE = (1 << 4),
 138         UCL_CHARACTER_VALUE_END = (1 << 5),
 139         UCL_CHARACTER_VALUE_STR = (1 << 6),
 140         UCL_CHARACTER_VALUE_DIGIT = (1 << 7),
 141         UCL_CHARACTER_VALUE_DIGIT_START = (1 << 8),
 142         UCL_CHARACTER_ESCAPE = (1 << 9),
 143         UCL_CHARACTER_KEY_SEP = (1 << 10),
 144         UCL_CHARACTER_JSON_UNSAFE = (1 << 11),
 145         UCL_CHARACTER_UCL_UNSAFE = (1 << 12)
 146 };
 147
 148 struct ucl_macro {
 149         char *name;
 150         union {
 151                 ucl_macro_handler handler;
 152                 ucl_context_macro_handler context_handler;
 153         } h;
 154         void* ud;
 155         bool is_context;
 156         UT_hash_handle hh;
 157 };
 158
 159 struct ucl_stack {
 160         ucl_object_t *obj;
 161         struct ucl_stack *next;
 162         uint64_t level;
 163 };
 164
 165 struct ucl_chunk {
 166         const unsigned char *begin;
 167         const unsigned char *end;
 168         const unsigned char *pos;
 169         size_t remain;
 170         unsigned int line;
 171         unsigned int column;
 172         unsigned priority;
 173         enum ucl_duplicate_strategy strategy;
 174         enum ucl_parse_type parse_type;
 175         struct ucl_chunk *next;
 176 };
 177
 178 #ifdef HAVE_OPENSSL
 179 struct ucl_pubkey {
 180         EVP_PKEY *key;
 181         struct ucl_pubkey *next;
 182 };
 183 #else
 184 struct ucl_pubkey {
 185         struct ucl_pubkey *next;
 186 };
 187 #endif
 188
 189 struct ucl_variable {
 190         char *var;
 191         char *value;
 192         size_t var_len;
 193         size_t value_len;
 194         struct ucl_variable *prev, *next;
 195 };
 196
 197 struct ucl_parser {
 198         enum ucl_parser_state state;
 199         enum ucl_parser_state prev_state;
 200         unsigned int recursion;
 201         int flags;
 202         unsigned default_priority;
 203         int err_code;
 204         ucl_object_t *top_obj;
 205         ucl_object_t *cur_obj;
 206         ucl_object_t *trash_objs;
 207         ucl_object_t *includepaths;
 208         char *cur_file;
 209         struct ucl_macro *macroes;
 210         struct ucl_stack *stack;
 211         struct ucl_chunk *chunks;
 212         struct ucl_pubkey *keys;
 213         struct ucl_variable *variables;
 214         ucl_variable_handler var_handler;
 215         void *var_data;
 216         ucl_object_t *comments;
 217         ucl_object_t *last_comment;
 218         UT_string *err;
 219 };
 220
 221 struct ucl_object_userdata {
 222         ucl_object_t obj;
 223         ucl_userdata_dtor dtor;
 224         ucl_userdata_emitter emitter;
 225 };
 226
 227 /**
 228  * Unescape json string inplace
 229  * @param str
 230  */
 231 size_t ucl_unescape_json_string (char *str, size_t len);
 232
 233 /**
 234  * Handle include macro
 235  * @param data include data
 236  * @param len length of data
 237  * @param args UCL object representing arguments to the macro
 238  * @param ud user data
 239  * @return
 240  */
 241 bool ucl_include_handler (const unsigned char *data, size_t len,
 242                 const ucl_object_t *args, void* ud);
 243
 244 /**
 245  * Handle tryinclude macro
 246  * @param data include data
 247  * @param len length of data
 248  * @param args UCL object representing arguments to the macro
 249  * @param ud user data
 250  * @return
 251  */
 252 bool ucl_try_include_handler (const unsigned char *data, size_t len,
 253                 const ucl_object_t *args, void* ud);
 254
 255 /**
 256  * Handle includes macro
 257  * @param data include data
 258  * @param len length of data
 259  * @param args UCL object representing arguments to the macro
 260  * @param ud user data
 261  * @return
 262  */
 263 bool ucl_includes_handler (const unsigned char *data, size_t len,
 264                 const ucl_object_t *args, void* ud);
 265
 266 /**
 267  * Handle priority macro
 268  * @param data include data
 269  * @param len length of data
 270  * @param args UCL object representing arguments to the macro
 271  * @param ud user data
 272  * @return
 273  */
 274 bool ucl_priority_handler (const unsigned char *data, size_t len,
 275                 const ucl_object_t *args, void* ud);
 276
 277 /**
 278  * Handle load macro
 279  * @param data include data
 280  * @param len length of data
 281  * @param args UCL object representing arguments to the macro
 282  * @param ud user data
 283  * @return
 284  */
 285 bool ucl_load_handler (const unsigned char *data, size_t len,
 286                 const ucl_object_t *args, void* ud);
 287 /**
 288  * Handle inherit macro
 289  * @param data include data
 290  * @param len length of data
 291  * @param args UCL object representing arguments to the macro
 292  * @param ctx the current context object
 293  * @param ud user data
 294  * @return
 295  */
 296 bool ucl_inherit_handler (const unsigned char *data, size_t len,
 297                 const ucl_object_t *args, const ucl_object_t *ctx, void* ud);
 298
 299 size_t ucl_strlcpy (char *dst, const char *src, size_t siz);
 300 size_t ucl_strlcpy_unsafe (char *dst, const char *src, size_t siz);
 301 size_t ucl_strlcpy_tolower (char *dst, const char *src, size_t siz);
 302
 303 char *ucl_strnstr (const char *s, const char *find, int len);
 304 char *ucl_strncasestr (const char *s, const char *find, int len);
 305
 306 #ifdef __GNUC__
 307 static inline void
 308 ucl_create_err (UT_string **err, const char *fmt, ...)
 309 __attribute__ (( format( printf, 2, 3) ));
 310 #endif
 311
 312 #undef UCL_FATAL_ERRORS
 313
 314 static inline void
 315 ucl_create_err (UT_string **err, const char *fmt, ...)
 316 {
 317         if (*err == NULL) {
 318                 utstring_new (*err);
 319                 va_list ap;
 320                 va_start (ap, fmt);
 321                 utstring_printf_va (*err, fmt, ap);
 322                 va_end (ap);
 323         }
 324
 325 #ifdef UCL_FATAL_ERRORS
 326         assert (0);
 327 #endif
 328 }
 329
 330 /**
 331  * Check whether a given string contains a boolean value
 332  * @param obj object to set
 333  * @param start start of a string
 334  * @param len length of a string
 335  * @return true if a string is a boolean value
 336  */
 337 static inline bool
 338 ucl_maybe_parse_boolean (ucl_object_t *obj, const unsigned char *start, size_t len)
 339 {
 340         const char *p = (const char *)start;
 341         bool ret = false, val = false;
 342
 343         if (len == 5) {
 344                 if ((p[0] == 'f' || p[0] == 'F') && strncasecmp (p, "false", 5) == 0) {
 345                         ret = true;
 346                         val = false;
 347                 }
 348         }
 349         else if (len == 4) {
 350                 if ((p[0] == 't' || p[0] == 'T') && strncasecmp (p, "true", 4) == 0) {
 351                         ret = true;
 352                         val = true;
 353                 }
 354         }
 355         else if (len == 3) {
 356                 if ((p[0] == 'y' || p[0] == 'Y') && strncasecmp (p, "yes", 3) == 0) {
 357                         ret = true;
 358                         val = true;
 359                 }
 360                 else if ((p[0] == 'o' || p[0] == 'O') && strncasecmp (p, "off", 3) == 0) {
 361                         ret = true;
 362                         val = false;
 363                 }
 364         }
 365         else if (len == 2) {
 366                 if ((p[0] == 'n' || p[0] == 'N') && strncasecmp (p, "no", 2) == 0) {
 367                         ret = true;
 368                         val = false;
 369                 }
 370                 else if ((p[0] == 'o' || p[0] == 'O') && strncasecmp (p, "on", 2) == 0) {
 371                         ret = true;
 372                         val = true;
 373                 }
 374         }
 375
 376         if (ret && obj != NULL) {
 377                 obj->type = UCL_BOOLEAN;
 378                 obj->value.iv = val;
 379         }
 380
 381         return ret;
 382 }
 383
 384 /**
 385  * Check numeric string
 386  * @param obj object to set if a string is numeric
 387  * @param start start of string
 388  * @param end end of string
 389  * @param pos position where parsing has stopped
 390  * @param allow_double allow parsing of floating point values
 391  * @return 0 if string is numeric and error code (EINVAL or ERANGE) in case of conversion error
 392  */
 393 int ucl_maybe_parse_number (ucl_object_t *obj,
 394                 const char *start, const char *end, const char **pos,
 395                 bool allow_double, bool number_bytes, bool allow_time);
 396
 397
 398 static inline const ucl_object_t *
 399 ucl_hash_search_obj (ucl_hash_t* hashlin, ucl_object_t *obj)
 400 {
 401         return (const ucl_object_t *)ucl_hash_search (hashlin, obj->key, obj->keylen);
 402 }
 403
 404 static inline ucl_hash_t * ucl_hash_insert_object (ucl_hash_t *hashlin,
 405                 const ucl_object_t *obj,
 406                 bool ignore_case) UCL_WARN_UNUSED_RESULT;
 407
 408 static inline ucl_hash_t *
 409 ucl_hash_insert_object (ucl_hash_t *hashlin,
 410                 const ucl_object_t *obj,
 411                 bool ignore_case)
 412 {
 413         if (hashlin == NULL) {
 414                 hashlin = ucl_hash_create (ignore_case);
 415         }
 416         ucl_hash_insert (hashlin, obj, obj->key, obj->keylen);
 417
 418         return hashlin;
 419 }
 420
 421 /**
 422  * Get standard emitter context for a specified emit_type
 423  * @param emit_type type of emitter
 424  * @return context or NULL if input is invalid
 425  */
 426 const struct ucl_emitter_context *
 427 ucl_emit_get_standard_context (enum ucl_emitter emit_type);
 428
 429 /**
 430  * Serialize string as JSON string
 431  * @param str string to emit
 432  * @param buf target buffer
 433  */
 434 void ucl_elt_string_write_json (const char *str, size_t size,
 435                 struct ucl_emitter_context *ctx);
 436
 437 /**
 438  * Write multiline string using `EOD` as string terminator
 439  * @param str
 440  * @param size
 441  * @param ctx
 442  */
 443 void ucl_elt_string_write_multiline (const char *str, size_t size,
 444                 struct ucl_emitter_context *ctx);
 445
 446 /**
 447  * Emit a single object to string
 448  * @param obj
 449  * @return
 450  */
 451 unsigned char * ucl_object_emit_single_json (const ucl_object_t *obj);
 452
 453 /**
 454  * Check whether a specified string is long and should be likely printed in
 455  * multiline mode
 456  * @param obj
 457  * @return
 458  */
 459 bool ucl_maybe_long_string (const ucl_object_t *obj);
 460
 461 /**
 462  * Print integer to the msgpack output
 463  * @param ctx
 464  * @param val
 465  */
 466 void ucl_emitter_print_int_msgpack (struct ucl_emitter_context *ctx,
 467                 int64_t val);
 468 /**
 469  * Print integer to the msgpack output
 470  * @param ctx
 471  * @param val
 472  */
 473 void ucl_emitter_print_double_msgpack (struct ucl_emitter_context *ctx,
 474                 double val);
 475 /**
 476  * Print double to the msgpack output
 477  * @param ctx
 478  * @param val
 479  */
 480 void ucl_emitter_print_bool_msgpack (struct ucl_emitter_context *ctx,
 481                 bool val);
 482 /**
 483  * Print string to the msgpack output
 484  * @param ctx
 485  * @param s
 486  * @param len
 487  */
 488 void ucl_emitter_print_string_msgpack (struct ucl_emitter_context *ctx,
 489                 const char *s, size_t len);
 490
 491 /**
 492  * Print binary string to the msgpack output
 493  * @param ctx
 494  * @param s
 495  * @param len
 496  */
 497 void ucl_emitter_print_binary_string_msgpack (struct ucl_emitter_context *ctx,
 498                 const char *s, size_t len);
 499
 500 /**
 501  * Print array preamble for msgpack
 502  * @param ctx
 503  * @param len
 504  */
 505 void ucl_emitter_print_array_msgpack (struct ucl_emitter_context *ctx,
 506                 size_t len);
 507
 508 /**
 509  * Print object preamble for msgpack
 510  * @param ctx
 511  * @param len
 512  */
 513 void ucl_emitter_print_object_msgpack (struct ucl_emitter_context *ctx,
 514                 size_t len);
 515 /**
 516  * Print NULL to the msgpack output
 517  * @param ctx
 518  */
 519 void ucl_emitter_print_null_msgpack (struct ucl_emitter_context *ctx);
 520 /**
 521  * Print object's key if needed to the msgpack output
 522  * @param print_key
 523  * @param ctx
 524  * @param obj
 525  */
 526 void ucl_emitter_print_key_msgpack (bool print_key,
 527                 struct ucl_emitter_context *ctx,
 528                 const ucl_object_t *obj);
 529
 530 /**
 531  * Fetch URL into a buffer
 532  * @param url url to fetch
 533  * @param buf pointer to buffer (must be freed by callee)
 534  * @param buflen pointer to buffer length
 535  * @param err pointer to error argument
 536  * @param must_exist fail if cannot find a url
 537  */
 538 bool ucl_fetch_url (const unsigned char *url,
 539                 unsigned char **buf,
 540                 size_t *buflen,
 541                 UT_string **err,
 542                 bool must_exist);
 543
 544 /**
 545  * Fetch a file and save results to the memory buffer
 546  * @param filename filename to fetch
 547  * @param len length of filename
 548  * @param buf target buffer
 549  * @param buflen target length
 550  * @return
 551  */
 552 bool ucl_fetch_file (const unsigned char *filename,
 553                 unsigned char **buf,
 554                 size_t *buflen,
 555                 UT_string **err,
 556                 bool must_exist);
 557
 558 /**
 559  * Add new element to an object using the current merge strategy and priority
 560  * @param parser
 561  * @param nobj
 562  * @return
 563  */
 564 bool ucl_parser_process_object_element (struct ucl_parser *parser,
 565                 ucl_object_t *nobj);
 566
 567 /**
 568  * Parse msgpack chunk
 569  * @param parser
 570  * @return
 571  */
 572 bool ucl_parse_msgpack (struct ucl_parser *parser);
 573
 574 bool ucl_parse_csexp (struct ucl_parser *parser);
 575
 576 #endif /* UCL_INTERNAL_H_ */