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
  91 #include "utlist.h"
  92 #include "utstring.h"
  93 #include "uthash.h"
  94 #include "ucl.h"
  95 #include "ucl_hash.h"
  96 #include "xxhash.h"
  97
  98 #ifdef HAVE_OPENSSL
  99 #include <openssl/evp.h>
 100 #endif
 101
 102 #ifndef __DECONST
 103 #define __DECONST(type, var)    ((type)(uintptr_t)(const void *)(var))
 104 #endif
 105
 106 /**
 107  * @file rcl_internal.h
 108  * Internal structures and functions of UCL library
 109  */
 110
 111 #define UCL_MAX_RECURSION 16
 112 #define UCL_TRASH_KEY 0
 113 #define UCL_TRASH_VALUE 1
 114
 115 enum ucl_parser_state {
 116         UCL_STATE_INIT = 0,
 117         UCL_STATE_OBJECT,
 118         UCL_STATE_ARRAY,
 119         UCL_STATE_KEY,
 120         UCL_STATE_VALUE,
 121         UCL_STATE_AFTER_VALUE,
 122         UCL_STATE_ARRAY_VALUE,
 123         UCL_STATE_SCOMMENT,
 124         UCL_STATE_MCOMMENT,
 125         UCL_STATE_MACRO_NAME,
 126         UCL_STATE_MACRO,
 127         UCL_STATE_ERROR
 128 };
 129
 130 enum ucl_character_type {
 131         UCL_CHARACTER_DENIED = 0,
 132         UCL_CHARACTER_KEY = 1,
 133         UCL_CHARACTER_KEY_START = 1 << 1,
 134         UCL_CHARACTER_WHITESPACE = 1 << 2,
 135         UCL_CHARACTER_WHITESPACE_UNSAFE = 1 << 3,
 136         UCL_CHARACTER_VALUE_END = 1 << 4,
 137         UCL_CHARACTER_VALUE_STR = 1 << 5,
 138         UCL_CHARACTER_VALUE_DIGIT = 1 << 6,
 139         UCL_CHARACTER_VALUE_DIGIT_START = 1 << 7,
 140         UCL_CHARACTER_ESCAPE = 1 << 8,
 141         UCL_CHARACTER_KEY_SEP = 1 << 9,
 142         UCL_CHARACTER_JSON_UNSAFE = 1 << 10,
 143         UCL_CHARACTER_UCL_UNSAFE = 1 << 11
 144 };
 145
 146 struct ucl_macro {
 147         char *name;
 148         ucl_macro_handler handler;
 149         void* ud;
 150         UT_hash_handle hh;
 151 };
 152
 153 struct ucl_stack {
 154         ucl_object_t *obj;
 155         struct ucl_stack *next;
 156         int level;
 157 };
 158
 159 struct ucl_chunk {
 160         const unsigned char *begin;
 161         const unsigned char *end;
 162         const unsigned char *pos;
 163         size_t remain;
 164         unsigned int line;
 165         unsigned int column;
 166         struct ucl_chunk *next;
 167 };
 168
 169 #ifdef HAVE_OPENSSL
 170 struct ucl_pubkey {
 171         EVP_PKEY *key;
 172         struct ucl_pubkey *next;
 173 };
 174 #else
 175 struct ucl_pubkey {
 176         struct ucl_pubkey *next;
 177 };
 178 #endif
 179
 180 struct ucl_variable {
 181         char *var;
 182         char *value;
 183         size_t var_len;
 184         size_t value_len;
 185         struct ucl_variable *next;
 186 };
 187
 188 struct ucl_parser {
 189         enum ucl_parser_state state;
 190         enum ucl_parser_state prev_state;
 191         unsigned int recursion;
 192         int flags;
 193         ucl_object_t *top_obj;
 194         ucl_object_t *cur_obj;
 195         struct ucl_macro *macroes;
 196         struct ucl_stack *stack;
 197         struct ucl_chunk *chunks;
 198         struct ucl_pubkey *keys;
 199         struct ucl_variable *variables;
 200         ucl_variable_handler var_handler;
 201         void *var_data;
 202         UT_string *err;
 203 };
 204
 205 /**
 206  * Unescape json string inplace
 207  * @param str
 208  */
 209 size_t ucl_unescape_json_string (char *str, size_t len);
 210
 211 /**
 212  * Handle include macro
 213  * @param data include data
 214  * @param len length of data
 215  * @param ud user data
 216  * @param err error ptr
 217  * @return
 218  */
 219 bool ucl_include_handler (const unsigned char *data, size_t len, void* ud);
 220
 221 bool ucl_try_include_handler (const unsigned char *data, size_t len, void* ud);
 222
 223 /**
 224  * Handle includes macro
 225  * @param data include data
 226  * @param len length of data
 227  * @param ud user data
 228  * @param err error ptr
 229  * @return
 230  */
 231 bool ucl_includes_handler (const unsigned char *data, size_t len, void* ud);
 232
 233 size_t ucl_strlcpy (char *dst, const char *src, size_t siz);
 234 size_t ucl_strlcpy_unsafe (char *dst, const char *src, size_t siz);
 235 size_t ucl_strlcpy_tolower (char *dst, const char *src, size_t siz);
 236
 237
 238 #ifdef __GNUC__
 239 static inline void
 240 ucl_create_err (UT_string **err, const char *fmt, ...)
 241 __attribute__ (( format( printf, 2, 3) ));
 242 #endif
 243
 244 static inline void
 245 ucl_create_err (UT_string **err, const char *fmt, ...)
 246
 247 {
 248         if (*err == NULL) {
 249                 utstring_new (*err);
 250                 va_list ap;
 251                 va_start (ap, fmt);
 252                 utstring_printf_va (*err, fmt, ap);
 253                 va_end (ap);
 254         }
 255 }
 256
 257 /**
 258  * Check whether a given string contains a boolean value
 259  * @param obj object to set
 260  * @param start start of a string
 261  * @param len length of a string
 262  * @return true if a string is a boolean value
 263  */
 264 static inline bool
 265 ucl_maybe_parse_boolean (ucl_object_t *obj, const unsigned char *start, size_t len)
 266 {
 267         const unsigned char *p = start;
 268         bool ret = false, val = false;
 269
 270         if (len == 5) {
 271                 if ((p[0] == 'f' || p[0] == 'F') && strncasecmp (p, "false", 5) == 0) {
 272                         ret = true;
 273                         val = false;
 274                 }
 275         }
 276         else if (len == 4) {
 277                 if ((p[0] == 't' || p[0] == 'T') && strncasecmp (p, "true", 4) == 0) {
 278                         ret = true;
 279                         val = true;
 280                 }
 281         }
 282         else if (len == 3) {
 283                 if ((p[0] == 'y' || p[0] == 'Y') && strncasecmp (p, "yes", 3) == 0) {
 284                         ret = true;
 285                         val = true;
 286                 }
 287                 else if ((p[0] == 'o' || p[0] == 'O') && strncasecmp (p, "off", 3) == 0) {
 288                         ret = true;
 289                         val = false;
 290                 }
 291         }
 292         else if (len == 2) {
 293                 if ((p[0] == 'n' || p[0] == 'N') && strncasecmp (p, "no", 2) == 0) {
 294                         ret = true;
 295                         val = false;
 296                 }
 297                 else if ((p[0] == 'o' || p[0] == 'O') && strncasecmp (p, "on", 2) == 0) {
 298                         ret = true;
 299                         val = true;
 300                 }
 301         }
 302
 303         if (ret) {
 304                 obj->type = UCL_BOOLEAN;
 305                 obj->value.iv = val;
 306         }
 307
 308         return ret;
 309 }
 310
 311 /**
 312  * Check numeric string
 313  * @param obj object to set if a string is numeric
 314  * @param start start of string
 315  * @param end end of string
 316  * @param pos position where parsing has stopped
 317  * @param allow_double allow parsing of floating point values
 318  * @return 0 if string is numeric and error code (EINVAL or ERANGE) in case of conversion error
 319  */
 320 int ucl_maybe_parse_number (ucl_object_t *obj,
 321                 const char *start, const char *end, const char **pos,
 322                 bool allow_double, bool number_bytes, bool allow_time);
 323
 324
 325 static inline const ucl_object_t *
 326 ucl_hash_search_obj (ucl_hash_t* hashlin, ucl_object_t *obj)
 327 {
 328         return (const ucl_object_t *)ucl_hash_search (hashlin, obj->key, obj->keylen);
 329 }
 330
 331 static inline ucl_hash_t *
 332 ucl_hash_insert_object (ucl_hash_t *hashlin, const ucl_object_t *obj) UCL_WARN_UNUSED_RESULT;
 333
 334 static inline ucl_hash_t *
 335 ucl_hash_insert_object (ucl_hash_t *hashlin, const ucl_object_t *obj)
 336 {
 337         if (hashlin == NULL) {
 338                 hashlin = ucl_hash_create ();
 339         }
 340         ucl_hash_insert (hashlin, obj, obj->key, obj->keylen);
 341
 342         return hashlin;
 343 }
 344
 345 /**
 346  * Emit a single object to string
 347  * @param obj
 348  * @return
 349  */
 350 unsigned char * ucl_object_emit_single_json (const ucl_object_t *obj);
 351
 352 #endif /* UCL_INTERNAL_H_ */