Copyright: 2003-2013 Troy D. Hanson http://troydhanson.github.com/uthash/
License: BSD-1-Clause
-Files: src/json/*
-Copyright: 2009 Petri Lehtinen <petri@digip.org>
-License: Expat
-
Files: conf/lua/regexp/*
Copyright: 2000-2012 The Apache Software Foundation
License: Apache-2.0
ENDMACRO(AddModules MLIST WLIST)
# Contrib software
-ADD_SUBDIRECTORY(json)
ADD_SUBDIRECTORY(cdb)
ADD_SUBDIRECTORY(ucl/cmake)
SET(SLAVE_BUILD 1)
ENDIF(GLIB_COMPAT)
-INSTALL(TARGETS rspamd RUNTIME DESTINATION bin)
\ No newline at end of file
+INSTALL(TARGETS rspamd RUNTIME DESTINATION bin)
+++ /dev/null
-# Json support makefile
-SET(JSONSRC dump.c
- hashtable.c
- load.c
- strbuffer.c
- utf.c
- value.c)
-
-ADD_LIBRARY(rspamd-json ${LINK_TYPE} ${JSONSRC})
-TARGET_LINK_LIBRARIES(rspamd-json rspamd-util)
-SET_TARGET_PROPERTIES(rspamd-json PROPERTIES VERSION ${RSPAMD_VERSION})
-SET_TARGET_PROPERTIES(rspamd-json PROPERTIES COMPILE_FLAGS "-DRSPAMD_LIB")
-IF(NO_SHARED MATCHES "OFF")
- INSTALL(TARGETS rspamd-json
- LIBRARY DESTINATION ${LIBDIR}
- PUBLIC_HEADER DESTINATION ${INCLUDEDIR})
-ENDIF(NO_SHARED MATCHES "OFF")
+++ /dev/null
-/*
- * Copyright (c) 2009 Petri Lehtinen <petri@digip.org>
- *
- * Jansson is free software; you can redistribute it and/or modify
- * it under the terms of the MIT license. See LICENSE for details.
- */
-
-#include "jansson.h"
-#include "strbuffer.h"
-
-typedef int (*dump_func) (const char *buffer, int size, void *data);
-
-struct string {
- char *buffer;
- int length;
- int size;
-};
-
-static int
-dump_to_strbuffer (const char *buffer, int size, void *data)
-{
- return strbuffer_append_bytes ((strbuffer_t *) data, buffer, size);
-}
-
-static int
-dump_to_file (const char *buffer, int size, void *data)
-{
- FILE *dest = (FILE *) data;
- if (fwrite (buffer, size, 1, dest) != 1)
- return -1;
- return 0;
-}
-
-/* 256 spaces (the maximum indentation size) */
-static char whitespace[] =
- " ";
-
-static int
-dump_indent (uint32_t flags, int depth, dump_func dump, void *data)
-{
- if (JSON_INDENT (flags) > 0) {
- int i, ws_count = JSON_INDENT (flags);
-
- if (dump ("\n", 1, data))
- return -1;
-
- for (i = 0; i < depth; i++) {
- if (dump (whitespace, ws_count, data))
- return -1;
- }
- }
- return 0;
-}
-
-static int
-dump_string (const char *str, dump_func dump, void *data)
-{
- const char *end;
-
- if (dump ("\"", 1, data))
- return -1;
-
- end = str;
- while (1) {
- const char *text;
- char seq[7];
- int length;
-
- while (*end && *end != '\\' && *end != '"' && (*end < 0 || *end > 0x1F))
- end++;
-
- if (end != str) {
- if (dump (str, end - str, data))
- return -1;
- }
-
- if (!*end)
- break;
-
- /* handle \, ", and control codes */
- length = 2;
- switch (*end) {
- case '\\':
- text = "\\\\";
- break;
- case '\"':
- text = "\\\"";
- break;
- case '\b':
- text = "\\b";
- break;
- case '\f':
- text = "\\f";
- break;
- case '\n':
- text = "\\n";
- break;
- case '\r':
- text = "\\r";
- break;
- case '\t':
- text = "\\t";
- break;
- default:
- {
- sprintf (seq, "\\u00%02x", *end);
- text = seq;
- length = 6;
- break;
- }
- }
-
- if (dump (text, length, data))
- return -1;
-
- end++;
- str = end;
- }
-
- return dump ("\"", 1, data);
-}
-
-static int
-do_dump (const json_t * json, uint32_t flags, int depth, dump_func dump, void *data)
-{
- switch (json_typeof (json)) {
- case JSON_NULL:
- return dump ("null", 4, data);
-
- case JSON_TRUE:
- return dump ("true", 4, data);
-
- case JSON_FALSE:
- return dump ("false", 5, data);
-
- case JSON_INTEGER:
- {
- char *buffer;
- int size, ret;
-
- size = asprintf (&buffer, "%d", json_integer_value (json));
- if (size == -1)
- return -1;
-
- ret = dump (buffer, size, data);
- free (buffer);
- return ret;
- }
-
- case JSON_REAL:
- {
- char *buffer;
- int size, ret;
-
- size = asprintf (&buffer, "%.17f", json_real_value (json));
- if (size == -1)
- return -1;
-
- ret = dump (buffer, size, data);
- free (buffer);
- return ret;
- }
-
- case JSON_STRING:
- return dump_string (json_string_value (json), dump, data);
-
- case JSON_ARRAY:
- {
- int i;
- int n = json_array_size (json);
-
- if (dump ("[", 1, data))
- return -1;
- if (n == 0)
- return dump ("]", 1, data);
- if (dump_indent (flags, depth + 1, dump, data))
- return -1;
-
- for (i = 0; i < n; ++i) {
- if (do_dump (json_array_get (json, i), flags, depth + 1, dump, data))
- return -1;
-
- if (i < n - 1) {
- if (dump (",", 1, data) || dump_indent (flags, depth + 1, dump, data))
- return -1;
- }
- else {
- if (dump_indent (flags, depth, dump, data))
- return -1;
- }
- }
- return dump ("]", 1, data);
- }
-
- case JSON_OBJECT:
- {
- void *iter = json_object_iter ((json_t *) json);
-
- if (dump ("{", 1, data))
- return -1;
- if (!iter)
- return dump ("}", 1, data);
- if (dump_indent (flags, depth + 1, dump, data))
- return -1;
-
- while (iter) {
- void *next = json_object_iter_next ((json_t *) json, iter);
-
- dump_string (json_object_iter_key (iter), dump, data);
- if (dump (": ", 2, data) || do_dump (json_object_iter_value (iter), flags, depth + 1, dump, data))
- return -1;
-
- if (next) {
- if (dump (",", 1, data) || dump_indent (flags, depth + 1, dump, data))
- return -1;
- }
- else {
- if (dump_indent (flags, depth, dump, data))
- return -1;
- }
-
- iter = next;
- }
- return dump ("}", 1, data);
- }
-
- default:
- /* not reached */
- return -1;
- }
-}
-
-
-char *
-json_dumps (const json_t * json, uint32_t flags)
-{
- strbuffer_t strbuff;
- char *result;
-
- if (!json_is_array (json) && !json_is_object (json))
- return NULL;
-
- if (strbuffer_init (&strbuff))
- return NULL;
-
- if (do_dump (json, flags, 0, dump_to_strbuffer, (void *)&strbuff))
- return NULL;
-
- if (dump_to_strbuffer ("\n", 1, (void *)&strbuff))
- return NULL;
-
- result = strdup (strbuffer_value (&strbuff));
- strbuffer_close (&strbuff);
-
- return result;
-}
-
-int
-json_dumpf (const json_t * json, FILE * output, uint32_t flags)
-{
- if (!json_is_array (json) && !json_is_object (json))
- return -1;
-
- if (do_dump (json, flags, 0, dump_to_file, (void *)output))
- return -1;
- return dump_to_file ("\n", 1, (void *)output);
-}
-
-int
-json_dump_file (const json_t * json, const char *path, uint32_t flags)
-{
- int result;
-
- FILE *output = fopen (path, "w");
- if (!output)
- return -1;
-
- result = json_dumpf (json, output, flags);
-
- fclose (output);
- return result;
-}
+++ /dev/null
-/*
- * Copyright (c) 2009 Petri Lehtinen <petri@digip.org>
- *
- * This library is free software; you can redistribute it and/or modify
- * it under the terms of the MIT license. See LICENSE for details.
- */
-
-#include "config.h"
-#include "hashtable.h"
-
-typedef struct hashtable_list list_t;
-typedef struct hashtable_pair pair_t;
-typedef struct hashtable_bucket bucket_t;
-
-#define container_of(ptr_, type_, member_) \
- ((type_ *)((char *)ptr_ - (size_t)&((type_ *)0)->member_))
-
-#define list_to_pair(list_) container_of(list_, pair_t, list)
-
-static inline void
-list_init (list_t * list)
-{
- list->next = list;
- list->prev = list;
-}
-
-static inline void
-list_insert (list_t * list, list_t * node)
-{
- node->next = list;
- node->prev = list->prev;
- list->prev->next = node;
- list->prev = node;
-}
-
-static inline void
-list_remove (list_t * list)
-{
- list->prev->next = list->next;
- list->next->prev = list->prev;
-}
-
-static inline int
-bucket_is_empty (hashtable_t * hashtable, bucket_t * bucket)
-{
- return bucket->first == &hashtable->list && bucket->first == bucket->last;
-}
-
-static void
-insert_to_bucket (hashtable_t * hashtable, bucket_t * bucket, list_t * list)
-{
- if (bucket_is_empty (hashtable, bucket)) {
- list_insert (&hashtable->list, list);
- bucket->first = bucket->last = list;
- }
- else {
- list_insert (bucket->first, list);
- bucket->first = list;
- }
-}
-
-static unsigned int primes[] = {
- 5, 13, 23, 53, 97, 193, 389, 769, 1543, 3079, 6151, 12289, 24593,
- 49157, 98317, 196613, 393241, 786433, 1572869, 3145739, 6291469,
- 12582917, 25165843, 50331653, 100663319, 201326611, 402653189,
- 805306457, 1610612741
-};
-
-static const unsigned int num_primes = sizeof (primes) / sizeof (unsigned int);
-
-static inline unsigned int
-num_buckets (hashtable_t * hashtable)
-{
- return primes[hashtable->num_buckets];
-}
-
-
-static pair_t *
-hashtable_find_pair (hashtable_t * hashtable, bucket_t * bucket, const void *key, unsigned int hash)
-{
- list_t *list;
- pair_t *pair;
-
- if (bucket_is_empty (hashtable, bucket))
- return NULL;
-
- list = bucket->first;
- while (1) {
- pair = list_to_pair (list);
- if (pair->hash == hash && hashtable->cmp_keys (pair->key, key))
- return pair;
-
- if (list == bucket->last)
- break;
-
- list = list->next;
- }
-
- return NULL;
-}
-
-/* returns 0 on success, -1 if key was not found */
-static int
-hashtable_do_del (hashtable_t * hashtable, const void *key, unsigned int hash)
-{
- pair_t *pair;
- bucket_t *bucket;
- unsigned int index;
-
- index = hash % num_buckets (hashtable);
- bucket = &hashtable->buckets[index];
-
- pair = hashtable_find_pair (hashtable, bucket, key, hash);
- if (!pair)
- return -1;
-
- if (&pair->list == bucket->first && &pair->list == bucket->last)
- bucket->first = bucket->last = &hashtable->list;
-
- else if (&pair->list == bucket->first)
- bucket->first = pair->list.next;
-
- else if (&pair->list == bucket->last)
- bucket->last = pair->list.prev;
-
- list_remove (&pair->list);
-
- if (hashtable->free_key)
- hashtable->free_key (pair->key);
- if (hashtable->free_value)
- hashtable->free_value (pair->value);
-
- g_free (pair);
- hashtable->size--;
-
- return 0;
-}
-
-static int
-hashtable_do_rehash (hashtable_t * hashtable)
-{
- list_t *list, *next;
- pair_t *pair;
- unsigned int i, index, new_size;
-
- g_free (hashtable->buckets);
-
- hashtable->num_buckets++;
- new_size = num_buckets (hashtable);
-
- hashtable->buckets = g_malloc (new_size * sizeof (bucket_t));
- if (!hashtable->buckets)
- return -1;
-
- for (i = 0; i < num_buckets (hashtable); i++) {
- hashtable->buckets[i].first = hashtable->buckets[i].last = &hashtable->list;
- }
-
- list = hashtable->list.next;
- list_init (&hashtable->list);
-
- for (; list != &hashtable->list; list = next) {
- next = list->next;
- pair = list_to_pair (list);
- index = pair->hash % new_size;
- insert_to_bucket (hashtable, &hashtable->buckets[index], &pair->list);
- }
-
- return 0;
-}
-
-
-hashtable_t *
-hashtable_create (key_hash_fn hash_key, key_cmp_fn cmp_keys, free_fn free_key, free_fn free_value)
-{
- hashtable_t *hashtable = g_malloc (sizeof (hashtable_t));
- if (!hashtable)
- return NULL;
-
- if (hashtable_init (hashtable, hash_key, cmp_keys, free_key, free_value)) {
- g_free (hashtable);
- return NULL;
- }
-
- return hashtable;
-}
-
-void
-hashtable_destroy (hashtable_t * hashtable)
-{
- hashtable_close (hashtable);
- g_free (hashtable);
-}
-
-int
-hashtable_init (hashtable_t * hashtable, key_hash_fn hash_key, key_cmp_fn cmp_keys, free_fn free_key, free_fn free_value)
-{
- unsigned int i;
-
- hashtable->size = 0;
- hashtable->num_buckets = 0; /* index to primes[] */
- hashtable->buckets = g_malloc (num_buckets (hashtable) * sizeof (bucket_t));
- if (!hashtable->buckets)
- return -1;
-
- list_init (&hashtable->list);
-
- hashtable->hash_key = hash_key;
- hashtable->cmp_keys = cmp_keys;
- hashtable->free_key = free_key;
- hashtable->free_value = free_value;
-
- for (i = 0; i < num_buckets (hashtable); i++) {
- hashtable->buckets[i].first = hashtable->buckets[i].last = &hashtable->list;
- }
-
- return 0;
-}
-
-void
-hashtable_close (hashtable_t * hashtable)
-{
- list_t *list, *next;
- pair_t *pair;
- for (list = hashtable->list.next; list != &hashtable->list; list = next) {
- next = list->next;
- pair = list_to_pair (list);
- if (hashtable->free_key)
- hashtable->free_key (pair->key);
- if (hashtable->free_value)
- hashtable->free_value (pair->value);
- g_free (pair);
- }
-
- g_free (hashtable->buckets);
-}
-
-int
-hashtable_set (hashtable_t * hashtable, void *key, void *value)
-{
- pair_t *pair;
- bucket_t *bucket;
- unsigned int hash, index;
-
- hash = hashtable->hash_key (key);
-
- /* if the key already exists, delete it */
- hashtable_do_del (hashtable, key, hash);
-
- /* rehash if the load ratio exceeds 1 */
- if (hashtable->size >= num_buckets (hashtable))
- if (hashtable_do_rehash (hashtable))
- return -1;
-
- pair = g_malloc (sizeof (pair_t));
- if (!pair)
- return -1;
-
- pair->key = key;
- pair->value = value;
- pair->hash = hash;
- list_init (&pair->list);
-
- index = hash % num_buckets (hashtable);
- bucket = &hashtable->buckets[index];
-
- insert_to_bucket (hashtable, bucket, &pair->list);
-
- hashtable->size++;
- return 0;
-}
-
-void *
-hashtable_get (hashtable_t * hashtable, const void *key)
-{
- pair_t *pair;
- unsigned int hash;
- bucket_t *bucket;
-
- hash = hashtable->hash_key (key);
- bucket = &hashtable->buckets[hash % num_buckets (hashtable)];
-
- pair = hashtable_find_pair (hashtable, bucket, key, hash);
- if (!pair)
- return NULL;
-
- return pair->value;
-}
-
-int
-hashtable_del (hashtable_t * hashtable, const void *key)
-{
- unsigned int hash = hashtable->hash_key (key);
- return hashtable_do_del (hashtable, key, hash);
-}
-
-void *
-hashtable_iter (hashtable_t * hashtable)
-{
- return hashtable_iter_next (hashtable, &hashtable->list);
-}
-
-void *
-hashtable_iter_next (hashtable_t * hashtable, void *iter)
-{
- list_t *list = (list_t *) iter;
- if (list->next == &hashtable->list)
- return NULL;
- return list->next;
-}
-
-void *
-hashtable_iter_key (void *iter)
-{
- pair_t *pair = list_to_pair ((list_t *) iter);
- return pair->key;
-}
-
-void *
-hashtable_iter_value (void *iter)
-{
- pair_t *pair = list_to_pair ((list_t *) iter);
- return pair->value;
-}
+++ /dev/null
-/*
- * Copyright (c) 2009 Petri Lehtinen <petri@digip.org>
- *
- * This library is free software; you can redistribute it and/or modify
- * it under the terms of the MIT license. See LICENSE for details.
- */
-
-#ifndef HASHTABLE_H
-#define HASHTABLE_H
-
-#include "config.h"
-
-typedef unsigned int (*key_hash_fn)(const void *key);
-typedef int (*key_cmp_fn)(const void *key1, const void *key2);
-typedef void (*free_fn)(void *key);
-
-struct hashtable_list {
- struct hashtable_list *prev;
- struct hashtable_list *next;
-};
-
-struct hashtable_pair {
- void *key;
- void *value;
- unsigned int hash;
- struct hashtable_list list;
-};
-
-struct hashtable_bucket {
- struct hashtable_list *first;
- struct hashtable_list *last;
-};
-
-typedef struct hashtable {
- unsigned int size;
- struct hashtable_bucket *buckets;
- unsigned int num_buckets; /* index to primes[] */
- struct hashtable_list list;
-
- key_hash_fn hash_key;
- key_cmp_fn cmp_keys; /* returns non-zero for equal keys */
- free_fn free_key;
- free_fn free_value;
-} hashtable_t;
-
-/**
- * hashtable_create - Create a hashtable object
- *
- * @hash_key: The key hashing function
- * @cmp_keys: The key compare function. Returns non-zero for equal and
- * zero for unequal unequal keys
- * @free_key: If non-NULL, called for a key that is no longer referenced.
- * @free_value: If non-NULL, called for a value that is no longer referenced.
- *
- * Returns a new hashtable object that should be freed with
- * hashtable_destroy when it's no longer used, or NULL on failure (out
- * of memory).
- */
-hashtable_t *hashtable_create(key_hash_fn hash_key, key_cmp_fn cmp_keys,
- free_fn free_key, free_fn free_value);
-
-/**
- * hashtable_destroy - Destroy a hashtable object
- *
- * @hashtable: The hashtable
- *
- * Destroys a hashtable created with hashtable_create().
- */
-void hashtable_destroy(hashtable_t *hashtable);
-
-/**
- * hashtable_init - Initialize a hashtable object
- *
- * @hashtable: The (statically allocated) hashtable object
- * @hash_key: The key hashing function
- * @cmp_keys: The key compare function. Returns non-zero for equal and
- * zero for unequal unequal keys
- * @free_key: If non-NULL, called for a key that is no longer referenced.
- * @free_value: If non-NULL, called for a value that is no longer referenced.
- *
- * Initializes a statically allocated hashtable object. The object
- * should be cleared with hashtable_close when it's no longer used.
- *
- * Returns 0 on success, -1 on error (out of memory).
- */
-int hashtable_init(hashtable_t *hashtable,
- key_hash_fn hash_key, key_cmp_fn cmp_keys,
- free_fn free_key, free_fn free_value);
-
-/**
- * hashtable_close - Release all resources used by a hashtable object
- *
- * @hashtable: The hashtable
- *
- * Destroys a statically allocated hashtable object.
- */
-void hashtable_close(hashtable_t *hashtable);
-
-/**
- * hashtable_set - Add/modify value in hashtable
- *
- * @hashtable: The hashtable object
- * @key: The key
- * @value: The value
- *
- * If a value with the given key already exists, its value is replaced
- * with the new value.
- *
- * Key and value are "stealed" in the sense that hashtable frees them
- * automatically when they are no longer used. The freeing is
- * accomplished by calling free_key and free_value functions that were
- * supplied to hashtable_new. In case one or both of the free
- * functions is NULL, the corresponding item is not "stealed".
- *
- * Returns 0 on success, -1 on failure (out of memory).
- */
-int hashtable_set(hashtable_t *hashtable, void *key, void *value);
-
-/**
- * hashtable_get - Get a value associated with a key
- *
- * @hashtable: The hashtable object
- * @key: The key
- *
- * Returns value if it is found, or NULL otherwise.
- */
-void *hashtable_get(hashtable_t *hashtable, const void *key);
-
-/**
- * hashtable_del - Remove a value from the hashtable
- *
- * @hashtable: The hashtable object
- * @key: The key
- *
- * Returns 0 on success, or -1 if the key was not found.
- */
-int hashtable_del(hashtable_t *hashtable, const void *key);
-
-/**
- * hashtable_iter - Iterate over hashtable
- *
- * @hashtable: The hashtable object
- *
- * Returns an opaque iterator to the first element in the hashtable.
- * The iterator should be passed to hashtable_iter_* functions.
- * The hashtable items are not iterated over in any particular order.
- *
- * There's no need to free the iterator in any way. The iterator is
- * valid as long as the item that is referenced by the iterator is not
- * deleted. Other values may be added or deleted. In particular,
- * hashtable_iter_next() may be called on an iterator, and after that
- * the key/value pair pointed by the old iterator may be deleted.
- */
-void *hashtable_iter(hashtable_t *hashtable);
-
-/**
- * hashtable_iter_next - Advance an iterator
- *
- * @hashtable: The hashtable object
- * @iter: The iterator
- *
- * Returns a new iterator pointing to the next element in the
- * hashtable or NULL if the whole hastable has been iterated over.
- */
-void *hashtable_iter_next(hashtable_t *hashtable, void *iter);
-
-/**
- * hashtable_iter_key - Retrieve the key pointed by an iterator
- *
- * @iter: The iterator
- */
-void *hashtable_iter_key(void *iter);
-
-/**
- * hashtable_iter_value - Retrieve the value pointed by an iterator
- *
- * @iter: The iterator
- */
-void *hashtable_iter_value(void *iter);
-
-#endif
+++ /dev/null
-/*
- * Copyright (c) 2009 Petri Lehtinen <petri@digip.org>
- *
- * Jansson is free software; you can redistribute it and/or modify
- * it under the terms of the MIT license. See LICENSE for details.
- */
-
-#ifndef JANSSON_H
-#define JANSSON_H
-
-#include "config.h"
-
-/* types */
-
-typedef enum {
- JSON_OBJECT,
- JSON_ARRAY,
- JSON_STRING,
- JSON_INTEGER,
- JSON_REAL,
- JSON_TRUE,
- JSON_FALSE,
- JSON_NULL
-} json_type;
-
-typedef struct {
- json_type type;
- unsigned long refcount;
-} json_t;
-
-#define json_typeof(json) ((json)->type)
-#define json_is_object(json) (json && json_typeof(json) == JSON_OBJECT)
-#define json_is_array(json) (json && json_typeof(json) == JSON_ARRAY)
-#define json_is_string(json) (json && json_typeof(json) == JSON_STRING)
-#define json_is_integer(json) (json && json_typeof(json) == JSON_INTEGER)
-#define json_is_real(json) (json && json_typeof(json) == JSON_REAL)
-#define json_is_number(json) (json_is_integer(json) || json_is_real(json))
-#define json_is_true(json) (json && json_typeof(json) == JSON_TRUE)
-#define json_is_false(json) (json && json_typeof(json) == JSON_FALSE)
-#define json_is_boolean(json) (json_is_true(json) || json_is_false(json))
-#define json_is_null(json) (json && json_typeof(json) == JSON_NULL)
-
-/* construction, destruction, reference counting */
-
-json_t *json_object(void);
-json_t *json_array(void);
-json_t *json_string(const char *value);
-json_t *json_integer(int value);
-json_t *json_real(double value);
-json_t *json_true(void);
-json_t *json_false(void);
-json_t *json_null(void);
-
-static inline json_t *json_incref(json_t *json)
-{
- if(json)
- ++json->refcount;
- return json;
-}
-
-/* do not call json_delete directly */
-void json_delete(json_t *json);
-
-static inline void json_decref(json_t *json)
-{
- if(json && --json->refcount == 0)
- json_delete(json);
-}
-
-
-/* getters, setters, manipulation */
-
-json_t *json_object_get(const json_t *object, const char *key);
-int json_object_set_new(json_t *object, const char *key, json_t *value);
-int json_object_del(json_t *object, const char *key);
-void *json_object_iter(json_t *object);
-void *json_object_iter_next(json_t *object, void *iter);
-const char *json_object_iter_key(void *iter);
-json_t *json_object_iter_value(void *iter);
-
-static inline
-int json_object_set(json_t *object, const char *key, json_t *value)
-{
- return json_object_set_new(object, key, json_incref(value));
-}
-
-unsigned int json_array_size(const json_t *array);
-json_t *json_array_get(const json_t *array, unsigned int index);
-int json_array_set_new(json_t *array, unsigned int index, json_t *value);
-int json_array_append_new(json_t *array, json_t *value);
-
-static inline
-int json_array_set(json_t *array, unsigned int index, json_t *value)
-{
- return json_array_set_new(array, index, json_incref(value));
-}
-
-static inline
-int json_array_append(json_t *array, json_t *value)
-{
- return json_array_append_new(array, json_incref(value));
-}
-
-
-const char *json_string_value(const json_t *json);
-int json_integer_value(const json_t *json);
-double json_real_value(const json_t *json);
-double json_number_value(const json_t *json);
-
-
-/* loading, printing */
-
-#define JSON_ERROR_TEXT_LENGTH 160
-
-typedef struct {
- char text[JSON_ERROR_TEXT_LENGTH];
- int line;
-} json_error_t;
-
-json_t *json_loads(const char *input, json_error_t *error);
-json_t *json_loadf(FILE *input, json_error_t *error);
-json_t *json_load_file(const char *path, json_error_t *error);
-json_t *json_load_evbuffer(struct evbuffer *evb, json_error_t *error);
-
-#define JSON_INDENT(n) (n & 0xFF)
-
-char *json_dumps(const json_t *json, uint32_t flags);
-int json_dumpf(const json_t *json, FILE *output, uint32_t flags);
-int json_dump_file(const json_t *json, const char *path, uint32_t flags);
-
-#endif
+++ /dev/null
-/*
- * Copyright (c) 2009 Petri Lehtinen <petri@digip.org>
- *
- * Jansson is free software; you can redistribute it and/or modify
- * it under the terms of the MIT license. See LICENSE for details.
- */
-
-#ifndef JANSSON_PRIVATE_H
-#define JANSSON_PRIVATE_H
-
-int json_object_set_nocheck(json_t *json, const char *key, json_t *value);
-json_t *json_string_nocheck(const char *value);
-
-
-#endif
+++ /dev/null
-/*
- * Copyright (c) 2009 Petri Lehtinen <petri@digip.org>
- *
- * Jansson is free software; you can redistribute it and/or modify
- * it under the terms of the MIT license. See LICENSE for details.
- */
-
-#include "jansson.h"
-#include "jansson_private.h"
-#include "strbuffer.h"
-#include "utf.h"
-
-#define TOKEN_INVALID -1
-#define TOKEN_EOF 0
-#define TOKEN_STRING 256
-#define TOKEN_INTEGER 257
-#define TOKEN_REAL 258
-#define TOKEN_TRUE 259
-#define TOKEN_FALSE 260
-#define TOKEN_NULL 261
-
-/* read one byte from stream, return EOF on end of file */
-typedef int (*get_func) (void *data);
-
-/* return non-zero if end of file has been reached */
-typedef int (*eof_func) (void *data);
-
-typedef struct {
- get_func get;
- eof_func eof;
- void *data;
- int stream_pos;
- char buffer[5];
- int buffer_pos;
-} stream_t;
-
-
-typedef struct {
- stream_t stream;
- strbuffer_t saved_text;
- int token;
- int line, column;
- union {
- char *string;
- int integer;
- double real;
- } value;
-} lex_t;
-
-
-/*** error reporting ***/
-
-static void
-error_init (json_error_t * error)
-{
- if (error) {
- error->text[0] = '\0';
- error->line = -1;
- }
-}
-
-static void
-error_set (json_error_t * error, const lex_t * lex, const char *msg, ...)
-{
- va_list ap;
- char text[JSON_ERROR_TEXT_LENGTH];
-
- if (!error || error->text[0] != '\0') {
- /* error already set */
- return;
- }
-
- va_start (ap, msg);
- vsnprintf (text, JSON_ERROR_TEXT_LENGTH, msg, ap);
- va_end (ap);
-
- if (lex) {
- const char *saved_text = strbuffer_value (&lex->saved_text);
- error->line = lex->line;
- if (saved_text && saved_text[0]) {
- if (lex->saved_text.length <= 20) {
- snprintf (error->text, JSON_ERROR_TEXT_LENGTH, "%s near '%s'", text, saved_text);
- }
- else
- snprintf (error->text, JSON_ERROR_TEXT_LENGTH, "%s", text);
- }
- else {
- snprintf (error->text, JSON_ERROR_TEXT_LENGTH, "%s near end of file", text);
- }
- }
- else {
- error->line = -1;
- snprintf (error->text, JSON_ERROR_TEXT_LENGTH, "%s", text);
- }
-}
-
-
-/*** lexical analyzer ***/
-
-void
-stream_init (stream_t * stream, get_func get, eof_func eof, void *data)
-{
- stream->get = get;
- stream->eof = eof;
- stream->data = data;
- stream->stream_pos = 0;
- stream->buffer[0] = '\0';
- stream->buffer_pos = 0;
-}
-
-static char
-stream_get (stream_t * stream, json_error_t * error)
-{
- char c;
-
- if (!stream->buffer[stream->buffer_pos]) {
- stream->buffer[0] = stream->get (stream->data);
- stream->buffer_pos = 0;
-
- c = stream->buffer[0];
-
- if (c == EOF && stream->eof (stream->data))
- return EOF;
-
- if (c < 0) {
- /* multi-byte UTF-8 sequence */
- int i, count;
-
- count = utf8_check_first (c);
- if (!count)
- goto out;
-
- g_assert (count >= 2);
-
- for (i = 1; i < count; i++)
- stream->buffer[i] = stream->get (stream->data);
-
- if (!utf8_check_full (stream->buffer, count))
- goto out;
-
- stream->stream_pos += count;
- stream->buffer[count] = '\0';
- }
- else {
- stream->buffer[1] = '\0';
- stream->stream_pos++;
- }
- }
-
- return stream->buffer[stream->buffer_pos++];
-
- out:
- error_set (error, NULL, "unable to decode byte 0x%x at position %d", (unsigned char)c, stream->stream_pos);
-
- stream->buffer[0] = EOF;
- stream->buffer[1] = '\0';
- stream->buffer_pos = 1;
-
- return EOF;
-}
-
-static void
-stream_unget (stream_t * stream, char c)
-{
- g_assert (stream->buffer_pos > 0);
- stream->buffer_pos--;
- g_assert (stream->buffer[stream->buffer_pos] == c);
-}
-
-
-static int
-lex_get (lex_t * lex, json_error_t * error)
-{
- return stream_get (&lex->stream, error);
-}
-
-static int
-lex_eof (lex_t * lex)
-{
- return lex->stream.eof (lex->stream.data);
-}
-
-static void
-lex_save (lex_t * lex, char c)
-{
- strbuffer_append_byte (&lex->saved_text, c);
-}
-
-static int
-lex_get_save (lex_t * lex, json_error_t * error)
-{
- char c = stream_get (&lex->stream, error);
- lex_save (lex, c);
- return c;
-}
-
-static void
-lex_unget_unsave (lex_t * lex, char c)
-{
- char d;
- stream_unget (&lex->stream, c);
- d = strbuffer_pop (&lex->saved_text);
- g_assert (c == d);
-}
-
-static void
-lex_save_cached (lex_t * lex)
-{
- while (lex->stream.buffer[lex->stream.buffer_pos] != '\0') {
- lex_save (lex, lex->stream.buffer[lex->stream.buffer_pos]);
- lex->stream.buffer_pos++;
- }
-}
-
-/* assumes that str points to 'u' plus at least 4 valid hex digits */
-static int
-decode_unicode_escape (const char *str)
-{
- int i;
- int value = 0;
-
- g_assert (str[0] == 'u');
-
- for (i = 1; i <= 4; i++) {
- char c = str[i];
- value <<= 4;
- if (g_ascii_isdigit (c))
- value += c - '0';
- else if (g_ascii_islower (c))
- value += c - 'a' + 10;
- else if (g_ascii_isupper (c))
- value += c - 'A' + 10;
- else
- g_assert (0);
- }
-
- return value;
-}
-
-static void
-lex_scan_string (lex_t * lex, json_error_t * error)
-{
- char c;
- const char *p;
- char *t;
- int i;
-
- lex->value.string = NULL;
- lex->token = TOKEN_INVALID;
-
- /* skip the " */
- c = lex_get_save (lex, error);
-
- while (c != '"') {
- if (c == EOF) {
- if (lex_eof (lex))
- error_set (error, lex, "premature end of input");
- goto out;
- }
-
- else if (0 <= c && c <= 0x1F) {
- /* control character */
- lex_unget_unsave (lex, c);
- if (c == '\n')
- error_set (error, lex, "unexpected newline", c);
- else
- error_set (error, lex, "control character 0x%x", c);
- goto out;
- }
-
- else if (c == '\\') {
- c = lex_get_save (lex, error);
- if (c == 'u') {
- c = lex_get_save (lex, error);
- for (i = 0; i < 4; i++) {
- if (!g_ascii_isxdigit (c)) {
- lex_unget_unsave (lex, c);
- error_set (error, lex, "invalid escape");
- goto out;
- }
- c = lex_get_save (lex, error);
- }
- }
- else if (c == '"' || c == '\\' || c == '/' || c == 'b' || c == 'f' || c == 'n' || c == 'r' || c == 't')
- c = lex_get_save (lex, error);
- else {
- lex_unget_unsave (lex, c);
- error_set (error, lex, "invalid escape");
- goto out;
- }
- }
- else
- c = lex_get_save (lex, error);
- }
-
- /* the actual value is at most of the same length as the source
- string, because:
- - shortcut escapes (e.g. "\t") (length 2) are converted to 1 byte
- - a single \uXXXX escape (length 6) is converted to at most 3 bytes
- - two \uXXXX escapes (length 12) forming an UTF-16 surrogate pair
- are converted to 4 bytes
- */
- lex->value.string = g_malloc (lex->saved_text.length + 1);
- if (!lex->value.string) {
- /* this is not very nice, since TOKEN_INVALID is returned */
- goto out;
- }
-
- /* the target */
- t = lex->value.string;
-
- /* + 1 to skip the " */
- p = strbuffer_value (&lex->saved_text) + 1;
-
- while (*p != '"') {
- if (*p == '\\') {
- p++;
- if (*p == 'u') {
- char buffer[4];
- int length;
- int value;
-
- value = decode_unicode_escape (p);
- p += 5;
-
- if (0xD800 <= value && value <= 0xDBFF) {
- /* surrogate pair */
- if (*p == '\\' && *(p + 1) == 'u') {
- int value2 = decode_unicode_escape (++p);
- p += 5;
-
- if (0xDC00 <= value2 && value2 <= 0xDFFF) {
- /* valid second surrogate */
- value = ((value - 0xD800) << 10) + (value2 - 0xDC00) + 0x10000;
- }
- else {
- /* invalid second surrogate */
- error_set (error, lex, "invalid Unicode '\\u%04X\\u%04X'", value, value2);
- goto out;
- }
- }
- else {
- /* no second surrogate */
- error_set (error, lex, "invalid Unicode '\\u%04X'", value);
- goto out;
- }
- }
- else if (0xDC00 <= value && value <= 0xDFFF) {
- error_set (error, lex, "invalid Unicode '\\u%04X'", value);
- goto out;
- }
- else if (value == 0) {
- error_set (error, lex, "\\u0000 is not allowed");
- goto out;
- }
-
- if (utf8_encode (value, buffer, &length))
- g_assert (0);
-
- memcpy (t, buffer, length);
- t += length;
- }
- else {
- switch (*p) {
- case '"':
- case '\\':
- case '/':
- *t = *p;
- break;
- case 'b':
- *t = '\b';
- break;
- case 'f':
- *t = '\f';
- break;
- case 'n':
- *t = '\n';
- break;
- case 'r':
- *t = '\r';
- break;
- case 't':
- *t = '\t';
- break;
- default:
- g_assert (0);
- }
- t++;
- p++;
- }
- }
- else
- *(t++) = *(p++);
- }
- *t = '\0';
- lex->token = TOKEN_STRING;
- return;
-
- out:
- g_free (lex->value.string);
-}
-
-static void
-lex_scan_number (lex_t * lex, char c, json_error_t * error)
-{
- const char *saved_text;
- char *end;
-
- lex->token = TOKEN_INVALID;
-
- if (c == '-')
- c = lex_get_save (lex, error);
-
- if (c == '0') {
- c = lex_get_save (lex, error);
- if (g_ascii_isdigit (c)) {
- lex_unget_unsave (lex, c);
- goto out;
- }
- }
- else { /* c != '0' */
-
- c = lex_get_save (lex, error);
- while (g_ascii_isdigit (c))
- c = lex_get_save (lex, error);
- }
-
- if (c != '.' && c != 'E' && c != 'e') {
- lex_unget_unsave (lex, c);
- lex->token = TOKEN_INTEGER;
-
- saved_text = strbuffer_value (&lex->saved_text);
- lex->value.integer = strtol (saved_text, &end, 10);
- g_assert (end == saved_text + lex->saved_text.length);
-
- return;
- }
-
- if (c == '.') {
- c = lex_get (lex, error);
- if (!g_ascii_isdigit (c))
- goto out;
- lex_save (lex, c);
-
- c = lex_get_save (lex, error);
- while (g_ascii_isdigit (c))
- c = lex_get_save (lex, error);
- }
-
- if (c == 'E' || c == 'e') {
- c = lex_get_save (lex, error);
- if (c == '+' || c == '-')
- c = lex_get_save (lex, error);
-
- if (!g_ascii_isdigit (c)) {
- lex_unget_unsave (lex, c);
- goto out;
- }
-
- c = lex_get_save (lex, error);
- while (g_ascii_isdigit (c))
- c = lex_get_save (lex, error);
- }
-
- lex_unget_unsave (lex, c);
- lex->token = TOKEN_REAL;
-
- saved_text = strbuffer_value (&lex->saved_text);
- lex->value.real = strtod (saved_text, &end);
- g_assert (end == saved_text + lex->saved_text.length);
-
- out:
- return;
-}
-
-static int
-lex_scan (lex_t * lex, json_error_t * error)
-{
- char c;
-
- strbuffer_clear (&lex->saved_text);
-
- if (lex->token == TOKEN_STRING) {
- g_free (lex->value.string);
- lex->value.string = NULL;
- }
-
- c = lex_get (lex, error);
- while (c == ' ' || c == '\t' || c == '\n' || c == '\r') {
- if (c == '\n')
- lex->line++;
-
- c = lex_get (lex, error);
- }
-
- if (c == EOF) {
- if (lex_eof (lex))
- lex->token = TOKEN_EOF;
- else
- lex->token = TOKEN_INVALID;
- goto out;
- }
-
- lex_save (lex, c);
-
- if (c == '{' || c == '}' || c == '[' || c == ']' || c == ':' || c == ',')
- lex->token = c;
-
- else if (c == '"')
- lex_scan_string (lex, error);
-
- else if (g_ascii_isdigit (c) || c == '-')
- lex_scan_number (lex, c, error);
-
- else if (g_ascii_isupper (c) || g_ascii_islower (c)) {
- /* eat up the whole identifier for clearer error messages */
- const char *saved_text;
-
- c = lex_get_save (lex, error);
- while (g_ascii_isupper (c) || g_ascii_islower (c))
- c = lex_get_save (lex, error);
- lex_unget_unsave (lex, c);
-
- saved_text = strbuffer_value (&lex->saved_text);
-
- if (strcmp (saved_text, "true") == 0)
- lex->token = TOKEN_TRUE;
- else if (strcmp (saved_text, "false") == 0)
- lex->token = TOKEN_FALSE;
- else if (strcmp (saved_text, "null") == 0)
- lex->token = TOKEN_NULL;
- else
- lex->token = TOKEN_INVALID;
- }
-
- else {
- /* save the rest of the input UTF-8 sequence to get an error
- message of valid UTF-8 */
- lex_save_cached (lex);
- lex->token = TOKEN_INVALID;
- }
-
- out:
- return lex->token;
-}
-
-static char *
-lex_steal_string (lex_t * lex)
-{
- char *result = NULL;
- if (lex->token == TOKEN_STRING) {
- result = lex->value.string;
- lex->value.string = NULL;
- }
- return result;
-}
-
-static int
-lex_init (lex_t * lex, get_func get, eof_func eof, void *data)
-{
- stream_init (&lex->stream, get, eof, data);
- if (strbuffer_init (&lex->saved_text))
- return -1;
-
- lex->token = TOKEN_INVALID;
- lex->line = 1;
-
- return 0;
-}
-
-static void
-lex_close (lex_t * lex)
-{
- if (lex->token == TOKEN_STRING)
- g_free (lex->value.string);
- strbuffer_close (&lex->saved_text);
-}
-
-
-/*** parser ***/
-
-static json_t *parse_value (lex_t * lex, json_error_t * error);
-
-static json_t *
-parse_object (lex_t * lex, json_error_t * error)
-{
- json_t *object = json_object ();
- if (!object)
- return NULL;
-
- lex_scan (lex, error);
- if (lex->token == '}')
- return object;
-
- while (1) {
- char *key;
- json_t *value;
-
- if (lex->token != TOKEN_STRING) {
- error_set (error, lex, "string or '}' expected");
- goto error;
- }
-
- key = lex_steal_string (lex);
- if (!key)
- return NULL;
-
- lex_scan (lex, error);
- if (lex->token != ':') {
- g_free (key);
- error_set (error, lex, "':' expected");
- goto error;
- }
-
- lex_scan (lex, error);
- value = parse_value (lex, error);
- if (!value) {
- g_free (key);
- goto error;
- }
-
- if (json_object_set_nocheck (object, key, value)) {
- g_free (key);
- json_decref (value);
- goto error;
- }
-
- json_decref (value);
- g_free (key);
-
- lex_scan (lex, error);
- if (lex->token != ',')
- break;
-
- lex_scan (lex, error);
- }
-
- if (lex->token != '}') {
- error_set (error, lex, "'}' expected");
- goto error;
- }
-
- return object;
-
- error:
- json_decref (object);
- return NULL;
-}
-
-static json_t *
-parse_array (lex_t * lex, json_error_t * error)
-{
- json_t *array = json_array ();
- if (!array)
- return NULL;
-
- lex_scan (lex, error);
- if (lex->token == ']')
- return array;
-
- while (lex->token) {
- json_t *elem = parse_value (lex, error);
- if (!elem)
- goto error;
-
- if (json_array_append (array, elem)) {
- json_decref (elem);
- goto error;
- }
- json_decref (elem);
-
- lex_scan (lex, error);
- if (lex->token != ',')
- break;
-
- lex_scan (lex, error);
- }
-
- if (lex->token != ']') {
- error_set (error, lex, "']' expected");
- goto error;
- }
-
- return array;
-
- error:
- json_decref (array);
- return NULL;
-}
-
-static json_t *
-parse_value (lex_t * lex, json_error_t * error)
-{
- json_t *json;
-
- switch (lex->token) {
- case TOKEN_STRING:{
- json = json_string_nocheck (lex->value.string);
- break;
- }
-
- case TOKEN_INTEGER:{
- json = json_integer (lex->value.integer);
- break;
- }
-
- case TOKEN_REAL:{
- json = json_real (lex->value.real);
- break;
- }
-
- case TOKEN_TRUE:
- json = json_true ();
- break;
-
- case TOKEN_FALSE:
- json = json_false ();
- break;
-
- case TOKEN_NULL:
- json = json_null ();
- break;
-
- case '{':
- json = parse_object (lex, error);
- break;
-
- case '[':
- json = parse_array (lex, error);
- break;
-
- case TOKEN_INVALID:
- error_set (error, lex, "invalid token");
- return NULL;
-
- default:
- error_set (error, lex, "unexpected token");
- return NULL;
- }
-
- if (!json)
- return NULL;
-
- return json;
-}
-
-json_t *
-parse_json (lex_t * lex, json_error_t * error)
-{
- error_init (error);
-
- lex_scan (lex, error);
- if (lex->token != '[' && lex->token != '{') {
- error_set (error, lex, "'[' or '{' expected");
- return NULL;
- }
-
- return parse_value (lex, error);
-}
-
-typedef struct {
- const char *data;
- int pos;
-} string_data_t;
-
-static int
-string_get (void *data)
-{
- char c;
- string_data_t *stream = (string_data_t *) data;
- c = stream->data[stream->pos];
- if (c == '\0')
- return EOF;
- else {
- stream->pos++;
- return c;
- }
-}
-
-static int
-string_eof (void *data)
-{
- string_data_t *stream = (string_data_t *) data;
- return (stream->data[stream->pos] == '\0');
-}
-
-json_t *
-json_loads (const char *string, json_error_t * error)
-{
- lex_t lex;
- json_t *result;
-
- string_data_t stream_data = {
- .data = string,
- .pos = 0
- };
-
- if (string == NULL || *string == '\0') {
- error_set (error, NULL, "empty stream");
- return NULL;
- }
-
- if (lex_init (&lex, string_get, string_eof, (void *)&stream_data))
- return NULL;
-
- result = parse_json (&lex, error);
- if (!result)
- goto out;
-
- lex_scan (&lex, error);
- if (lex.token != TOKEN_EOF) {
- error_set (error, &lex, "end of file expected");
- json_decref (result);
- result = NULL;
- }
-
- out:
- lex_close (&lex);
- return result;
-}
-
-json_t *
-json_loadf (FILE * input, json_error_t * error)
-{
- lex_t lex;
- json_t *result;
-
- if (lex_init (&lex, (get_func) fgetc, (eof_func) feof, input))
- return NULL;
-
- result = parse_json (&lex, error);
- if (!result)
- goto out;
-
- lex_scan (&lex, error);
- if (lex.token != TOKEN_EOF) {
- error_set (error, &lex, "end of file expected");
- json_decref (result);
- result = NULL;
- }
-
- out:
- lex_close (&lex);
- return result;
-}
-
-json_t *
-json_load_file (const char *path, json_error_t * error)
-{
- json_t *result;
- FILE *fp;
-
- fp = fopen (path, "r");
- if (!fp) {
- error_set (error, NULL, "unable to open %s: %s", path, strerror (errno));
- return NULL;
- }
-
- result = json_loadf (fp, error);
-
- fclose (fp);
- return result;
-}
-
-
-typedef struct evbuffer_data_s {
- const char *data;
- gsize len;
- guint pos;
-} evbuffer_data_t;
-
-
-static int
-evbuffer_get (void *data)
-{
- evbuffer_data_t *stream = (evbuffer_data_t *) data;
-
- if (stream->pos >= stream->len) {
- return EOF;
- }
-
- return *(stream->data + stream->pos++);
-}
-
-static int
-evbuffer_eof (void *data)
-{
- evbuffer_data_t *stream = (evbuffer_data_t *) data;
-
- return stream->pos >= stream->len;
-}
-
-json_t *
-json_load_evbuffer (struct evbuffer *evb, json_error_t *error)
-{
- evbuffer_data_t stream_data;
- lex_t lex;
- json_t *result;
-
- if (evb == NULL || EVBUFFER_LENGTH (evb) == 0) {
- error_set (error, NULL, "empty stream");
- return NULL;
- }
-
- stream_data.data = EVBUFFER_DATA (evb);
- stream_data.pos = 0;
- stream_data.len = EVBUFFER_LENGTH (evb);
-
- if (lex_init (&lex, evbuffer_get, evbuffer_eof, (void *)&stream_data))
- return NULL;
-
- result = parse_json (&lex, error);
- if (!result)
- goto out;
-
- lex_scan (&lex, error);
- if (lex.token != TOKEN_EOF) {
- error_set (error, &lex, "end of file expected");
- json_decref (result);
- result = NULL;
- }
-
- out:
- lex_close (&lex);
- return result;
-}
+++ /dev/null
-/*
- * Copyright (c) 2009 Petri Lehtinen <petri@digip.org>
- *
- * Jansson is free software; you can redistribute it and/or modify
- * it under the terms of the MIT license. See LICENSE for details.
- */
-
-#include "config.h"
-#include "strbuffer.h"
-#include "util.h"
-
-#define STRBUFFER_MIN_SIZE 16
-#define STRBUFFER_FACTOR 2
-
-int
-strbuffer_init (strbuffer_t * strbuff)
-{
- strbuff->size = STRBUFFER_MIN_SIZE;
- strbuff->length = 0;
-
- strbuff->value = g_malloc (strbuff->size);
- if (!strbuff->value)
- return -1;
-
- /* initialize to empty */
- strbuff->value[0] = '\0';
- return 0;
-}
-
-void
-strbuffer_close (strbuffer_t * strbuff)
-{
- g_free (strbuff->value);
- strbuff->size = 0;
- strbuff->length = 0;
- strbuff->value = NULL;
-}
-
-void
-strbuffer_clear (strbuffer_t * strbuff)
-{
- strbuff->length = 0;
- strbuff->value[0] = '\0';
-}
-
-const char *
-strbuffer_value (const strbuffer_t * strbuff)
-{
- return strbuff->value;
-}
-
-char *
-strbuffer_steal_value (strbuffer_t * strbuff)
-{
- char *result = strbuff->value;
- strbuffer_init (strbuff);
- return result;
-}
-
-int
-strbuffer_append (strbuffer_t * strbuff, const char *string)
-{
- return strbuffer_append_bytes (strbuff, string, strlen (string));
-}
-
-int
-strbuffer_append_byte (strbuffer_t * strbuff, char byte)
-{
- return strbuffer_append_bytes (strbuff, &byte, 1);
-}
-
-int
-strbuffer_append_bytes (strbuffer_t * strbuff, const char *data, int size)
-{
- if (strbuff->length + size >= strbuff->size) {
- strbuff->size = max (strbuff->size * STRBUFFER_FACTOR, strbuff->length + size + 1);
-
- strbuff->value = g_realloc (strbuff->value, strbuff->size);
- if (!strbuff->value)
- return -1;
- }
-
- memcpy (strbuff->value + strbuff->length, data, size);
- strbuff->length += size;
- strbuff->value[strbuff->length] = '\0';
-
- return 0;
-}
-
-char
-strbuffer_pop (strbuffer_t * strbuff)
-{
- if (strbuff->length > 0) {
- char c = strbuff->value[--strbuff->length];
- strbuff->value[strbuff->length] = '\0';
- return c;
- }
- else
- return '\0';
-}
+++ /dev/null
-/*
- * Copyright (c) 2009 Petri Lehtinen <petri@digip.org>
- *
- * Jansson is free software; you can redistribute it and/or modify
- * it under the terms of the MIT license. See LICENSE for details.
- */
-
-#ifndef STRBUFFER_H
-#define STRBUFFER_H
-
-typedef struct {
- char *value;
- int length; /* bytes used */
- int size; /* bytes allocated */
-} strbuffer_t;
-
-int strbuffer_init(strbuffer_t *strbuff);
-void strbuffer_close(strbuffer_t *strbuff);
-
-void strbuffer_clear(strbuffer_t *strbuff);
-
-const char *strbuffer_value(const strbuffer_t *strbuff);
-char *strbuffer_steal_value(strbuffer_t *strbuff);
-
-int strbuffer_append(strbuffer_t *strbuff, const char *string);
-int strbuffer_append_byte(strbuffer_t *strbuff, char byte);
-int strbuffer_append_bytes(strbuffer_t *strbuff, const char *data, int size);
-
-char strbuffer_pop(strbuffer_t *strbuff);
-
-#endif
+++ /dev/null
-/*
- * Copyright (c) 2009 Petri Lehtinen <petri@digip.org>
- *
- * Jansson is free software; you can redistribute it and/or modify
- * it under the terms of the MIT license. See LICENSE for details.
- */
-
-#include "config.h"
-
-int
-utf8_encode (int codepoint, char *buffer, int *size)
-{
- if (codepoint < 0)
- return -1;
- else if (codepoint < 0x80) {
- buffer[0] = (char)codepoint;
- *size = 1;
- }
- else if (codepoint < 0x800) {
- buffer[0] = 0xC0 + ((codepoint & 0x7C0) >> 6);
- buffer[1] = 0x80 + ((codepoint & 0x03F));
- *size = 2;
- }
- else if (codepoint < 0x10000) {
- buffer[0] = 0xE0 + ((codepoint & 0xF000) >> 12);
- buffer[1] = 0x80 + ((codepoint & 0x0FC0) >> 6);
- buffer[2] = 0x80 + ((codepoint & 0x003F));
- *size = 3;
- }
- else if (codepoint <= 0x10FFFF) {
- buffer[0] = 0xF0 + ((codepoint & 0x1C0000) >> 18);
- buffer[1] = 0x80 + ((codepoint & 0x03F000) >> 12);
- buffer[2] = 0x80 + ((codepoint & 0x000FC0) >> 6);
- buffer[3] = 0x80 + ((codepoint & 0x00003F));
- *size = 4;
- }
- else
- return -1;
-
- return 0;
-}
-
-int
-utf8_check_first (char byte)
-{
- unsigned char u = (unsigned char)byte;
-
- if (u < 0x80)
- return 1;
-
- if (0x80 <= u && u <= 0xBF) {
- /* second, third or fourth byte of a multi-byte
- sequence, i.e. a "continuation byte" */
- return 0;
- }
- else if (u == 0xC0 || u == 0xC1) {
- /* overlong encoding of an ASCII byte */
- return 0;
- }
- else if (0xC2 <= u && u <= 0xDF) {
- /* 2-byte sequence */
- return 2;
- }
-
- else if (0xE0 <= u && u <= 0xEF) {
- /* 3-byte sequence */
- return 3;
- }
- else if (0xF0 <= u && u <= 0xF4) {
- /* 4-byte sequence */
- return 4;
- }
- else { /* u >= 0xF5 */
- /* Restricted (start of 4-, 5- or 6-byte sequence) or invalid
- UTF-8 */
- return 0;
- }
-}
-
-int
-utf8_check_full (const char *buffer, int size)
-{
- int i, value = 0;
- unsigned char u = (unsigned char)buffer[0];
-
- if (size == 2) {
- value = u & 0x1F;
- }
- else if (size == 3) {
- value = u & 0xF;
- }
- else if (size == 4) {
- value = u & 0x7;
- }
- else
- return 0;
-
- for (i = 1; i < size; i++) {
- u = (unsigned char)buffer[i];
-
- if (u < 0x80 || u > 0xBF) {
- /* not a continuation byte */
- return 0;
- }
-
- value = (value << 6) + (u & 0x3F);
- }
-
- if (value > 0x10FFFF) {
- /* not in Unicode range */
- return 0;
- }
-
- else if (0xD800 <= value && value <= 0xDFFF) {
- /* invalid code point (UTF-16 surrogate halves) */
- return 0;
- }
-
- else if ((size == 2 && value < 0x80) || (size == 3 && value < 0x800) || (size == 4 && value < 0x10000)) {
- /* overlong encoding */
- return 0;
- }
-
- return 1;
-}
-
-int
-utf8_check_string (const char *string, int length)
-{
- int i;
-
- if (length == -1)
- length = strlen (string);
-
- for (i = 0; i < length; i++) {
- int count = utf8_check_first (string[i]);
- if (count == 0)
- return 0;
- else if (count > 1) {
- if (i + count > length)
- return 0;
-
- if (!utf8_check_full (&string[i], count))
- return 0;
-
- i += count - 1;
- }
- }
-
- return 1;
-}
+++ /dev/null
-/*
- * Copyright (c) 2009 Petri Lehtinen <petri@digip.org>
- *
- * Jansson is free software; you can redistribute it and/or modify
- * it under the terms of the MIT license. See LICENSE for details.
- */
-
-#ifndef UTF_H
-#define UTF_H
-
-int utf8_encode(int codepoint, char *buffer, int *size);
-
-int utf8_check_first(char byte);
-int utf8_check_full(const char *buffer, int size);
-
-int utf8_check_string(const char *string, int length);
-
-#endif
+++ /dev/null
-/*
- * Copyright (c) 2009 Petri Lehtinen <petri@digip.org>
- *
- * Jansson is free software; you can redistribute it and/or modify
- * it under the terms of the MIT license. See LICENSE for details.
- */
-
-#ifndef UTIL_H
-#define UTIL_H
-
-#define max(a, b) ((a) > (b) ? (a) : (b))
-
-#endif
+++ /dev/null
-/*
- * Copyright (c) 2009 Petri Lehtinen <petri@digip.org>
- *
- * Jansson is free software; you can redistribute it and/or modify
- * it under the terms of the MIT license. See LICENSE for details.
- */
-
-
-#include "jansson.h"
-#include "hashtable.h"
-#include "jansson_private.h"
-#include "utf.h"
-#include "util.h"
-
-#define container_of(ptr_, type_, member_) \
- ((type_ *)((char *)ptr_ - (size_t)&((type_ *)0)->member_))
-
-typedef struct {
- json_t json;
- hashtable_t hashtable;
-} json_object_t;
-
-typedef struct {
- json_t json;
- unsigned int size;
- unsigned int entries;
- json_t **table;
-} json_array_t;
-
-typedef struct {
- json_t json;
- char *value;
-} json_string_t;
-
-typedef struct {
- json_t json;
- double value;
-} json_real_t;
-
-typedef struct {
- json_t json;
- int value;
-} json_integer_t;
-
-#define json_to_object(json_) container_of(json_, json_object_t, json)
-#define json_to_array(json_) container_of(json_, json_array_t, json)
-#define json_to_string(json_) container_of(json_, json_string_t, json)
-#define json_to_real(json_) container_of(json_, json_real_t, json)
-#define json_to_integer(json_) container_of(json_, json_integer_t, json)
-
-static inline void
-json_init (json_t * json, json_type type)
-{
- json->type = type;
- json->refcount = 1;
-}
-
-
-/*** object ***/
-
-static unsigned int
-hash_string (const void *key)
-{
- const char *str = (const char *)key;
- unsigned int hash = 5381;
- unsigned int c;
-
- while ((c = (unsigned int)*str)) {
- hash = ((hash << 5) + hash) + c;
- str++;
- }
-
- return hash;
-}
-
-static int
-string_equal (const void *key1, const void *key2)
-{
- return strcmp ((const char *)key1, (const char *)key2) == 0;
-}
-
-static void
-value_decref (void *value)
-{
- json_decref ((json_t *) value);
-}
-
-json_t *
-json_object (void)
-{
- json_object_t *object = g_malloc (sizeof (json_object_t));
- if (!object)
- return NULL;
- json_init (&object->json, JSON_OBJECT);
-
- if (hashtable_init (&object->hashtable, hash_string, string_equal, g_free, value_decref)) {
- g_free (object);
- return NULL;
- }
- return &object->json;
-}
-
-static void
-json_delete_object (json_object_t * object)
-{
- hashtable_close (&object->hashtable);
- g_free (object);
-}
-
-json_t *
-json_object_get (const json_t * json, const char *key)
-{
- json_object_t *object;
-
- if (!json_is_object (json))
- return NULL;
-
- object = json_to_object (json);
- return hashtable_get (&object->hashtable, key);
-}
-
-int
-json_object_set_new_nocheck (json_t * json, const char *key, json_t * value)
-{
- json_object_t *object;
-
- if (!key || !value)
- return -1;
-
- if (!json_is_object (json)) {
- json_decref (value);
- return -1;
- }
- object = json_to_object (json);
-
- if (hashtable_set (&object->hashtable, strdup (key), value)) {
- json_decref (value);
- return -1;
- }
-
- return 0;
-}
-
-int
-json_object_set_nocheck (json_t * json, const char *key, json_t * value)
-{
- return json_object_set_new_nocheck (json, key, json_incref (value));
-}
-
-int
-json_object_set_new (json_t * json, const char *key, json_t * value)
-{
- if (!utf8_check_string (key, -1)) {
- json_decref (value);
- return -1;
- }
-
- return json_object_set_new_nocheck (json, key, value);
-}
-
-int
-json_object_del (json_t * json, const char *key)
-{
- json_object_t *object;
-
- if (!json_is_object (json))
- return -1;
-
- object = json_to_object (json);
- return hashtable_del (&object->hashtable, key);
-}
-
-void *
-json_object_iter (json_t * json)
-{
- json_object_t *object;
-
- if (!json_is_object (json))
- return NULL;
-
- object = json_to_object (json);
- return hashtable_iter (&object->hashtable);
-}
-
-void *
-json_object_iter_next (json_t * json, void *iter)
-{
- json_object_t *object;
-
- if (!json_is_object (json) || iter == NULL)
- return NULL;
-
- object = json_to_object (json);
- return hashtable_iter_next (&object->hashtable, iter);
-}
-
-const char *
-json_object_iter_key (void *iter)
-{
- if (!iter)
- return NULL;
-
- return (const char *)hashtable_iter_key (iter);
-}
-
-json_t *
-json_object_iter_value (void *iter)
-{
- if (!iter)
- return NULL;
-
- return (json_t *) hashtable_iter_value (iter);
-}
-
-
-/*** array ***/
-
-json_t *
-json_array (void)
-{
- json_array_t *array = g_malloc (sizeof (json_array_t));
- if (!array)
- return NULL;
- json_init (&array->json, JSON_ARRAY);
-
- array->entries = 0;
- array->size = 0;
- array->table = NULL;
-
- return &array->json;
-}
-
-static void
-json_delete_array (json_array_t * array)
-{
- unsigned int i;
-
- for (i = 0; i < array->entries; i++)
- json_decref (array->table[i]);
-
- g_free (array->table);
- g_free (array);
-}
-
-unsigned int
-json_array_size (const json_t * json)
-{
- if (!json_is_array (json))
- return 0;
-
- return json_to_array (json)->entries;
-}
-
-json_t *
-json_array_get (const json_t * json, unsigned int index)
-{
- json_array_t *array;
- if (!json_is_array (json))
- return NULL;
- array = json_to_array (json);
-
- if (index >= array->entries)
- return NULL;
-
- return array->table[index];
-}
-
-int
-json_array_set_new (json_t * json, unsigned int index, json_t * value)
-{
- json_array_t *array;
-
- if (!value)
- return -1;
-
- if (!json_is_array (json)) {
- json_decref (value);
- return -1;
- }
- array = json_to_array (json);
-
- if (index >= array->entries) {
- json_decref (value);
- return -1;
- }
-
- json_decref (array->table[index]);
- array->table[index] = value;
-
- return 0;
-}
-
-int
-json_array_append_new (json_t * json, json_t * value)
-{
- json_array_t *array;
-
- if (!value)
- return -1;
-
- if (!json_is_array (json)) {
- json_decref (value);
- return -1;
- }
- array = json_to_array (json);
-
- if (array->entries == array->size) {
- array->size = max (8, array->size * 2);
- array->table = realloc (array->table, array->size * sizeof (json_t *));
- if (!array->table) {
- json_decref (value);
- return -1;
- }
- }
-
- array->table[array->entries] = value;
- array->entries++;
-
- return 0;
-}
-
-
-/*** string ***/
-
-json_t *
-json_string_nocheck (const char *value)
-{
- json_string_t *string;
-
- if (!value)
- return NULL;
-
- string = g_malloc (sizeof (json_string_t));
- if (!string)
- return NULL;
- json_init (&string->json, JSON_STRING);
-
- string->value = strdup (value);
- if (!string->value) {
- g_free (string);
- return NULL;
- }
-
- return &string->json;
-}
-
-json_t *
-json_string (const char *value)
-{
- if (!value || !utf8_check_string (value, -1))
- return NULL;
-
- return json_string_nocheck (value);
-}
-
-const char *
-json_string_value (const json_t * json)
-{
- if (!json_is_string (json))
- return NULL;
-
- return json_to_string (json)->value;
-}
-
-static void
-json_delete_string (json_string_t * string)
-{
- g_free (string->value);
- g_free (string);
-}
-
-
-/*** integer ***/
-
-json_t *
-json_integer (int value)
-{
- json_integer_t *integer = g_malloc (sizeof (json_integer_t));
- if (!integer)
- return NULL;
- json_init (&integer->json, JSON_INTEGER);
-
- integer->value = value;
- return &integer->json;
-}
-
-int
-json_integer_value (const json_t * json)
-{
- if (!json_is_integer (json))
- return 0;
-
- return json_to_integer (json)->value;
-}
-
-static void
-json_delete_integer (json_integer_t * integer)
-{
- g_free (integer);
-}
-
-
-/*** real ***/
-
-json_t *
-json_real (double value)
-{
- json_real_t *real = g_malloc (sizeof (json_real_t));
- if (!real)
- return NULL;
- json_init (&real->json, JSON_REAL);
-
- real->value = value;
- return &real->json;
-}
-
-double
-json_real_value (const json_t * json)
-{
- if (!json_is_real (json))
- return 0;
-
- return json_to_real (json)->value;
-}
-
-static void
-json_delete_real (json_real_t * real)
-{
- g_free (real);
-}
-
-
-/*** number ***/
-
-double
-json_number_value (const json_t * json)
-{
- if (json_is_integer (json))
- return json_integer_value (json);
- else if (json_is_real (json))
- return json_real_value (json);
- else
- return 0.0;
-}
-
-
-/*** simple values ***/
-
-json_t *
-json_true (void)
-{
- static json_t the_true = {
- .type = JSON_TRUE,
- .refcount = 1
- };
- return json_incref (&the_true);
-}
-
-
-json_t *
-json_false (void)
-{
- static json_t the_false = {
- .type = JSON_FALSE,
- .refcount = 1
- };
- return json_incref (&the_false);
-}
-
-
-json_t *
-json_null (void)
-{
- static json_t the_null = {
- .type = JSON_NULL,
- .refcount = 1
- };
- return json_incref (&the_null);
-}
-
-
-/*** deletion ***/
-
-void
-json_delete (json_t * json)
-{
- if (json_is_object (json))
- json_delete_object (json_to_object (json));
-
- else if (json_is_array (json))
- json_delete_array (json_to_array (json));
-
- else if (json_is_string (json))
- json_delete_string (json_to_string (json));
-
- else if (json_is_integer (json))
- json_delete_integer (json_to_integer (json));
-
- else if (json_is_real (json))
- json_delete_real (json_to_real (json));
-
- /* json_delete is not called for true, false or null */
-}
ENDIF(NOT DEBIAN_BUILD)
SET_TARGET_PROPERTIES(rspamd-server PROPERTIES LINKER_LANGUAGE C COMPILE_FLAGS "-DRSPAMD_LIB")
TARGET_LINK_LIBRARIES(rspamd-server rspamd-lua)
-TARGET_LINK_LIBRARIES(rspamd-server rspamd-json)
TARGET_LINK_LIBRARIES(rspamd-server rspamd-cdb)
TARGET_LINK_LIBRARIES(rspamd-server rspamd-util)
TARGET_LINK_LIBRARIES(rspamd-server rdns)
INSTALL(TARGETS rspamd-server
LIBRARY DESTINATION ${LIBDIR}
PUBLIC_HEADER DESTINATION ${INCLUDEDIR})
-ENDIF(NO_SHARED MATCHES "OFF")
\ No newline at end of file
+ENDIF(NO_SHARED MATCHES "OFF")
projects / thirdparty / rspamd.git / commitdiff
