#ifdef HAVE_ENDIAN_H
#include <endian.h>
- #else
+ #else
#ifdef HAVE_SYS_ENDIAN_H
#include <sys/endian.h>
#else
#ifdef HAVE_MACHINE_ENDIAN_H
#include <machine/endian.h>
#else
- #define LITTLE_ENDIAN 1234
- #define BIG_ENDIAN 4321
+ #define LITTLE_ENDIAN 1234
+ #define BIG_ENDIAN 4321
#if defined(i386) || defined(__i386) || defined(__amd64) || \
defined(BIT_ZERO_ON_RIGHT) || defined(__x86__)
#define BYTE_ORDER LITTLE_ENDIAN
#endif
-
+
#if defined(__sparc) || defined(__sparc__) || defined(__powerpc__)
#define BYTE_ORDER BIG_ENDIAN
#endif
-
+
#endif /* HAVE_MACHINE_ENDIAN_H */
#endif /* HAVE_SYS_ENDIAN_H */
#endif /* HAVE_ENDIAN_H */
-
+
#if !defined(BYTE_ORDER)
# error "Undefined or unknown BYTE_ORDER"
#endif
-
+
#ifdef _MSC_VER
# define RSPAMD_PACKED(name) \
__pragma(pack(push, 1)) struct name __pragma(pack(pop))
# define NBYTES(nbits) (((nbits) + BITSPERBYTE - 1) / BITSPERBYTE)
#endif
+extern uint64_t ottery_rand_uint64(void);
+#define UCL_RANDOM_FUNCTION ottery_rand_uint64()
#endif
* Basic flags for an object
*/
typedef enum ucl_object_flags {
- UCL_OBJECT_ALLOCATED_KEY = 0x1, /**< An object has key allocated internally */
- UCL_OBJECT_ALLOCATED_VALUE = 0x2, /**< An object has a string value allocated internally */
- UCL_OBJECT_NEED_KEY_ESCAPE = 0x4, /**< The key of an object need to be escaped on output */
- UCL_OBJECT_EPHEMERAL = 0x8, /**< Temporary object that does not need to be freed really */
- UCL_OBJECT_MULTILINE = 0x10, /**< String should be displayed as multiline string */
- UCL_OBJECT_MULTIVALUE = 0x20 /**< Object is a key with multiple values */
+ UCL_OBJECT_ALLOCATED_KEY = (1 << 0), /**< An object has key allocated internally */
+ UCL_OBJECT_ALLOCATED_VALUE = (1 << 1), /**< An object has a string value allocated internally */
+ UCL_OBJECT_NEED_KEY_ESCAPE = (1 << 2), /**< The key of an object need to be escaped on output */
+ UCL_OBJECT_EPHEMERAL = (1 << 3), /**< Temporary object that does not need to be freed really */
+ UCL_OBJECT_MULTILINE = (1 << 4), /**< String should be displayed as multiline string */
+ UCL_OBJECT_MULTIVALUE = (1 << 5), /**< Object is a key with multiple values */
+ UCL_OBJECT_INHERITED = (1 << 6) /**< Object has been inherited from another */
} ucl_object_flags_t;
/**
const ucl_object_t *arguments,
void* ud);
+/**
+ * Context dependent macro handler for a parser
+ * @param data the content of macro
+ * @param len the length of content
+ * @param arguments arguments object
+ * @param context previously parsed context
+ * @param ud opaque user data
+ * @param err error pointer
+ * @return true if macro has been parsed
+ */
+typedef bool (*ucl_context_macro_handler) (const unsigned char *data, size_t len,
+ const ucl_object_t *arguments,
+ const ucl_object_t *context,
+ void* ud);
+
/* Opaque parser */
struct ucl_parser;
* @param handler handler (it is called immediately after macro is parsed)
* @param ud opaque user data for a handler
*/
-UCL_EXTERN void ucl_parser_register_macro (struct ucl_parser *parser, const char *macro,
+UCL_EXTERN void ucl_parser_register_macro (struct ucl_parser *parser,
+ const char *macro,
ucl_macro_handler handler, void* ud);
+/**
+ * Register new context dependent handler for a macro
+ * @param parser parser object
+ * @param macro macro name (without leading dot)
+ * @param handler handler (it is called immediately after macro is parsed)
+ * @param ud opaque user data for a handler
+ */
+UCL_EXTERN void ucl_parser_register_context_macro (struct ucl_parser *parser,
+ const char *macro,
+ ucl_context_macro_handler handler,
+ void* ud);
+
/**
* Handler to detect unregistered variables
* @param data variable data
static uint64_t seed;
if (seed == 0) {
+#ifdef UCL_RANDOM_FUNCTION
+ seed = UCL_RANDOM_FUNCTION;
+#else
/* Not very random but can be useful for our purposes */
seed = time (NULL);
+#endif
}
return seed;
0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
};
-#if (defined(WORD_BIT) && WORD_BIT == 64) || (defined(__WORDSIZE) && __WORDSIZE == 64)
+#if (defined(WORD_BIT) && WORD_BIT == 64) || \
+ (defined(__WORDSIZE) && __WORDSIZE == 64) || \
+ defined(__x86_64__) || \
+ defined(__amd64__)
+#define UCL64_BIT_HASH 1
+#endif
+
+#ifdef UCL64_BIT_HASH
static inline uint32_t
ucl_hash_func (const ucl_object_t *o)
{
KHASH_INIT (ucl_hash_node, const ucl_object_t *, struct ucl_hash_elt, 1,
ucl_hash_func, ucl_hash_equal)
-#if (defined(WORD_BIT) && WORD_BIT == 64) || (defined(__WORDSIZE) && __WORDSIZE == 64)
+#ifdef UCL64_BIT_HASH
static inline uint32_t
ucl_hash_caseless_func (const ucl_object_t *o)
{
struct ucl_macro {
char *name;
- ucl_macro_handler handler;
+ union {
+ ucl_macro_handler handler;
+ ucl_context_macro_handler context_handler;
+ } h;
void* ud;
+ bool is_context;
UT_hash_handle hh;
};
*/
bool ucl_load_handler (const unsigned char *data, size_t len,
const ucl_object_t *args, void* ud);
+/**
+ * Handle inherit macro
+ * @param data include data
+ * @param len length of data
+ * @param args UCL object representing arguments to the macro
+ * @param ctx the current context object
+ * @param ud user data
+ * @return
+ */
+bool ucl_inherit_handler (const unsigned char *data, size_t len,
+ const ucl_object_t *args, const ucl_object_t *ctx, void* ud);
size_t ucl_strlcpy (char *dst, const char *src, size_t siz);
size_t ucl_strlcpy_unsafe (char *dst, const char *src, size_t siz);
*/
unsigned priold = ucl_object_get_priority (tobj),
prinew = ucl_object_get_priority (nobj);
+
+ /* Special case for inherited objects */
+ if (tobj->flags & UCL_OBJECT_INHERITED) {
+ prinew = priold + 1;
+ }
+
if (priold == prinew) {
ucl_parser_append_elt (parser, container, tobj, nobj);
}
macro_start, macro_len);
parser->state = parser->prev_state;
if (macro_escaped == NULL) {
- ret = macro->handler (macro_start, macro_len, macro_args,
- macro->ud);
+ if (macro->is_context) {
+ ret = macro->h.context_handler (macro_start, macro_len,
+ macro_args,
+ parser->top_obj,
+ macro->ud);
+ }
+ else {
+ ret = macro->h.handler (macro_start, macro_len, macro_args,
+ macro->ud);
+ }
}
else {
- ret = macro->handler (macro_escaped, macro_len, macro_args,
+ if (macro->is_context) {
+ ret = macro->h.context_handler (macro_escaped, macro_len,
+ macro_args,
+ parser->top_obj,
+ macro->ud);
+ }
+ else {
+ ret = macro->h.handler (macro_escaped, macro_len, macro_args,
macro->ud);
+ }
+
UCL_FREE (macro_len + 1, macro_escaped);
}
ucl_parser_register_macro (new, "includes", ucl_includes_handler, new);
ucl_parser_register_macro (new, "priority", ucl_priority_handler, new);
ucl_parser_register_macro (new, "load", ucl_load_handler, new);
+ ucl_parser_register_context_macro (new, "inherit", ucl_inherit_handler, new);
new->flags = flags;
new->includepaths = NULL;
if (macro == NULL || handler == NULL) {
return;
}
+
+ new = UCL_ALLOC (sizeof (struct ucl_macro));
+ if (new == NULL) {
+ return;
+ }
+
+ memset (new, 0, sizeof (struct ucl_macro));
+ new->h.handler = handler;
+ new->name = strdup (macro);
+ new->ud = ud;
+ HASH_ADD_KEYPTR (hh, parser->macroes, new->name, strlen (new->name), new);
+}
+
+void
+ucl_parser_register_context_macro (struct ucl_parser *parser, const char *macro,
+ ucl_context_macro_handler handler, void* ud)
+{
+ struct ucl_macro *new;
+
+ if (macro == NULL || handler == NULL) {
+ return;
+ }
+
new = UCL_ALLOC (sizeof (struct ucl_macro));
if (new == NULL) {
return;
}
+
memset (new, 0, sizeof (struct ucl_macro));
- new->handler = handler;
+ new->h.context_handler = handler;
new->name = strdup (macro);
new->ud = ud;
+ new->is_context = true;
HASH_ADD_KEYPTR (hh, parser->macroes, new->name, strlen (new->name), new);
}
return false;
}
+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;
+
+ parent = ucl_object_find_keyl (ctx, data, len);
+
+ /* Some sanity checks */
+ if (parent == NULL || ucl_object_type (parent) != UCL_OBJECT) {
+ ucl_create_err (&parser->err, "Unable to find inherited object %*.s",
+ (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;
+
+ if (args && (cur = ucl_object_find_key (args, "replace")) != NULL) {
+ replace = ucl_object_toboolean (cur);
+ }
+
+ while ((cur = ucl_iterate_object (parent, &it, true))) {
+ /* We do not replace existing keys */
+ if (!replace && ucl_object_find_keyl (target, cur->key, cur->keylen)) {
+ 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;
+}
+
bool
ucl_parser_set_filevars (struct ucl_parser *parser, const char *filename, bool need_expand)
{
projects / rspamd.git / commitdiff