summaryrefslogtreecommitdiff
path: root/jcnf/jcnf.c
diff options
context:
space:
mode:
Diffstat (limited to 'jcnf/jcnf.c')
-rw-r--r--jcnf/jcnf.c1248
1 files changed, 1248 insertions, 0 deletions
diff --git a/jcnf/jcnf.c b/jcnf/jcnf.c
new file mode 100644
index 0000000..c2fd4cc
--- /dev/null
+++ b/jcnf/jcnf.c
@@ -0,0 +1,1248 @@
+
+/*
+ * JSON based configuration format class.
+ */
+
+/*************************************************************************
+ Copyright 2008 Graeme W. Gill
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.
+
+ *************************************************************************/
+
+#define LOCK_RETRIES 5
+
+/* We convert JSON arrays to numerical sub paths on reading, */
+/* but they get converted back to maps on writing. */
+/* Paths are grouped under common paths on writing, */
+/* but aren't sorted. */
+
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#ifndef NT
+#include <sys/file.h>
+#endif
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <unistd.h>
+#include <time.h>
+
+#include "yajl/yajl_common.h"
+#include "yajl/yajl_gen.h"
+#include "yajl/yajl_parse.h"
+
+#include "jcnf.h"
+
+#define BUF_SIZE 2048
+
+/* - - - - - - - - - - - - - - - - */
+/* Utilities */
+
+/* Construct a string that represents the current key path */
+/* Return NULL on error (malloc fail) */
+/* Free the returned string when done */
+static char *cur_keypath(jcnf *p) {
+ char *ckey = NULL;
+ int i, len;
+
+ if (p->nrecd <= 0) {
+ return strdup("");
+ }
+ for (len = i = 0; i < p->nrecd; i++) {
+ if (p->recds[i].aix > -2) {
+ len += 3 + (int)log10((double)p->recds[p->nrecd-1].aix);
+ } else {
+ len += strlen(p->recds[i].key) + 1;
+ }
+ }
+
+ if ((ckey = malloc(len)) == NULL)
+ return NULL;
+
+ for (len = i = 0; i < p->nrecd; i++) {
+ int sl;
+
+ if (p->recds[i].aix > -2) {
+ char num[13];
+ sprintf(num, "%d",p->recds[i].aix);
+ sl = strlen(num);
+ memmove(ckey + len, num, sl);
+ } else {
+ sl = strlen(p->recds[i].key);
+ memmove(ckey + len, p->recds[i].key, sl);
+ }
+ len += sl;
+
+ if ((i+1) >= p->nrecd)
+ ckey[len] = '\000';
+ else
+ ckey[len] = '/';
+ len++;
+ }
+ return ckey;
+}
+
+/* Diagnostic - Print the value of a key */
+static jc_error jcnf_print_key(jcnf *p, int ix, FILE *fp) {
+ jc_key *kp;
+
+ if (ix < 0 || ix >= p->nkeys)
+ return jc_ix_oorange;
+
+ kp = p->keys[ix];
+
+ fprintf(fp,"Key '%s' has value",kp->key);
+
+ switch(kp->type) {
+ case jc_null: {
+ fprintf(fp," null");
+ break;
+ }
+ case jc_boolean: {
+ fprintf(fp," %s",*((int *)kp->data) ? "true" : "false");
+ break;
+ }
+ case jc_real: {
+ fprintf(fp," %lf",*((double *)kp->data));
+ break;
+ }
+ case jc_integer: {
+ fprintf(fp," %ld",*((long *)kp->data));
+ break;
+ }
+ case jc_string: {
+ fprintf(fp," '%s'",kp->data);
+ break;
+ }
+ default: {
+ fprintf(fp," unknown type %d",kp->type);
+ break;
+ }
+ }
+ if (kp->c_comment != NULL) {
+ fprintf(fp," C comment = '%s'",kp->c_comment);
+ }
+ if (kp->cpp_comment != NULL) {
+ fprintf(fp," C++ comment = '%s'",kp->cpp_comment);
+ }
+ fprintf(fp,"\n");
+ return jc_ok;
+}
+
+/* - - - - - - - - - - - - - - - - */
+/* Free keys contents */
+static void free_key_contents(jc_key *p) {
+ if (p->key != NULL) {
+ free(p->key);
+ p->key = NULL;
+ }
+ if (p->c_comment != NULL) {
+ free(p->c_comment);
+ p->c_comment = NULL;
+ }
+ if (p->cpp_comment != NULL) {
+ free(p->cpp_comment);
+ p->cpp_comment = NULL;
+ }
+ if (p->data != NULL) {
+ free(p->data);
+ p->data = NULL;
+ }
+ p->type = -1;
+}
+
+/* Free key and its contents */
+static void free_key(jc_key *p) {
+ free_key_contents(p);
+ free(p);
+}
+
+/* Set a keyvalues (internal) */
+/* All parameters are copied */
+/* return NZ on error */
+static jc_error jcnf_set_key_internal(
+ jcnf *p,
+ jc_key *kp, /* Pointer to key */
+ char *key, /* Key path name */
+ jc_type type,
+ void *data,
+ size_t dataSize, /* Data size (including string nul) */
+ char *comment /* C++ style comment */
+) {
+ free_key_contents(kp);
+
+ if ((kp->key = strdup(key)) == NULL)
+ return jc_malloc;
+ kp->type = type;
+
+ if (type != jc_null) {
+ if (type == jc_string && ((char *)data)[dataSize-1] != '\000')
+ return jc_string_not_terminated;
+ if ((kp->data = malloc(dataSize)) == NULL)
+ return jc_malloc;
+ kp->dataSize = dataSize;
+ memmove(kp->data, data, dataSize);
+ }
+
+ if (comment != NULL) {
+ if ((kp->cpp_comment = strdup(comment)) == NULL)
+ return jc_malloc;
+ }
+ return jc_ok;
+}
+
+/* Add a key value to the jcnf (internal) */
+/* All parameters are copied */
+/* return NZ on error */
+static jc_error jcnf_add_key_internal(
+ jcnf *p,
+ char *key, /* Key path name */
+ jc_type type,
+ void *data,
+ size_t dataSize, /* Data size (including string nul) */
+ char *comment
+) {
+ jc_error ev;
+ jc_key *kp;
+
+ if (key == NULL || (type != jc_null && (data == NULL || dataSize == 0)))
+ return jc_bad_addkey_params;
+
+ if (p->nkeys >= p->akeys) { /* Need more pointer space */
+ p->akeys = p->akeys ? 2 * p->akeys : 10;
+ if ((p->keys = realloc(p->keys, p->akeys * sizeof(jc_key*))) == NULL) {
+ return jc_malloc;
+ }
+ }
+ if ((kp = p->keys[p->nkeys] = calloc(1, sizeof(jc_key))) == NULL) {
+ return jc_malloc;
+ }
+ p->nkeys++;
+
+ if ((ev = jcnf_set_key_internal(p, kp, key, type, data, dataSize, comment)) != jc_ok)
+ return ev;
+ p->lk = kp;
+ return jc_ok;
+}
+
+/* Locate the index of the next key matching the key name, starting */
+/* at the given index. Update the index to the matching key. */
+/* Look for an exact match if exact != 0, or leading match if exact = 0 */
+/* Search backwards if bwd != 0 or forwards if bwd = 0 */
+/* Set *ix = -1 to begin search from the start/end for fwd/bwd. */
+/* Return jc_ix_oorange if no more match. */
+static jc_error jcnf_locate_key(
+ jcnf *p,
+ int *pix,
+ char *key,
+ int exact,
+ int bwd
+) {
+ int ix = *pix;
+ int sl;
+
+ if (ix == -1) {
+ if (bwd)
+ ix = p->nkeys-1;
+ else
+ ix = 0;
+ }
+
+ if (ix < 0 || ix >= p->nkeys)
+ return jc_ix_oorange;
+
+ if (key == NULL)
+ return jc_no_keyname;
+
+ sl = strlen(key);
+
+ /* We're doing a simple linear search */
+ for (; ix >= 0 && ix < p->nkeys; ix += bwd ? -1 : 1) {
+ if (exact) {
+ if (strcmp(key, p->keys[ix]->key) == 0)
+ break;
+ } else {
+ if (strncmp(key, p->keys[ix]->key, sl) == 0)
+ break;
+ }
+ }
+
+ if (ix < 0 || ix >= p->nkeys)
+ return jc_ix_oorange;
+
+ *pix = ix;
+ return jc_ok;
+}
+
+/* Retrieve a keys information. Return pointers may be NULL. */
+/* If ix >= 0, return the key of the given index. */
+/* If ix == -1, return the first from the beginning exactly matching key name. */
+/* jc_ix_oorange is returned when past end. */
+/* (Do not modify anything returned) */
+static jc_error jcnf_get_key(
+ jcnf *p,
+ int ix,
+ char **key,
+ jc_type *type,
+ unsigned char **data,
+ size_t *dataSize, /* Data size (including string nul) */
+ char **comment
+) {
+ jc_error ev;
+
+ if (ix == -1) {
+ if (key == NULL || *key == NULL)
+ return jc_no_keyname;
+ if ((ev = jcnf_locate_key(p, &ix, *key, 1, 0)) != jc_ok)
+ return ev;
+ } else if (ix < 0 || ix >= p->nkeys)
+ return jc_ix_oorange;
+
+ if (key != NULL)
+ *key = p->keys[ix]->key;
+ if (type != NULL)
+ *type = p->keys[ix]->type;
+ if (data != NULL)
+ *data = p->keys[ix]->data;
+ if (dataSize != NULL)
+ *dataSize = p->keys[ix]->dataSize;
+ if (comment != NULL)
+ *comment = p->keys[ix]->cpp_comment;
+
+ return jc_ok;
+}
+
+/* Set a keys information. */
+/* If ix >= 0, set the key of the given index. */
+/* jc_ix_oorange is returned when past end. */
+/* If ix == -1, overwrite an existing key with the same name, */
+/* or add a new key with that name at the end if there is no existing key. */
+static jc_error jcnf_set_key(
+ jcnf *p,
+ int ix,
+ char *key,
+ jc_type type,
+ unsigned char *data,
+ size_t dataSize, /* Data size (including string nul) */
+ char *comment
+) {
+ jc_error ev;
+
+ if (ix == -1) {
+ if (key == NULL)
+ return jc_no_keyname;
+ if ((ev = jcnf_locate_key(p, &ix, key, 1, 0)) != jc_ok) {
+ if (ev != jc_ix_oorange)
+ return ev;
+ if (p->modify == 0)
+ return jc_update_nomod;
+ p->modified = 1;
+ return jcnf_add_key_internal(p, key, type, data, dataSize, comment);
+ }
+ } else if (ix < 0 || ix >= p->nkeys)
+ return jc_ix_oorange;
+
+ if (p->modify == 0)
+ return jc_update_nomod;
+ p->modified = 1;
+ return jcnf_set_key_internal(p, p->keys[ix], key, type, data, dataSize, comment);
+}
+
+/* Add a key value to the jcnf at the end, irrespective of whether there is */
+/* an existing key with that name. */
+static jc_error jcnf_add_key(
+ jcnf *p,
+ char *key,
+ jc_type type,
+ unsigned char *data,
+ size_t dataSize, /* Data size (including string nul) */
+ char *comment
+) {
+ jc_error ev;
+ if (p->modify == 0)
+ return jc_update_nomod;
+ if ((ev = jcnf_add_key_internal(p,key,type,data,dataSize,comment)) == jc_ok) {
+ p->modified = 1;
+ }
+ return ev;
+}
+
+/* Delete a key. */
+/* If ix >= 0, delete the key of the given index. */
+/* jc_ix_oorange is returned when past end. */
+/* If ix == -1, delete the key with the given name. */
+static jc_error jcnf_delete_key(
+ jcnf *p,
+ int ix,
+ char *key
+) {
+ jc_error ev;
+
+ if (ix == -1) {
+ if (key == NULL)
+ return jc_no_keyname;
+ if ((ev = jcnf_locate_key(p, &ix, key, 1, 0)) != jc_ok)
+ return ev;
+ } else if (ix < 0 || ix >= p->nkeys)
+ return jc_ix_oorange;
+
+ if (p->modify == 0)
+ return jc_update_nomod;
+ free_key_contents(p->keys[ix]);
+
+ if ((ix+1) < p->nkeys) {
+ memmove(p->keys+ix, p->keys+ix+1,sizeof(jc_key *) * p->nkeys-ix-1);
+ }
+ p->nkeys--;
+ p->modified = 1;
+
+ return jc_ok;
+}
+
+/* - - - - - - - - - - - - - - - - */
+/* yajl parser callbacks */
+
+static int jcnf_yajl_null(void *ctx) {
+ jcnf *p = (jcnf *)ctx;
+ char *t1;
+
+// printf("null\n");
+
+ /* If current level is an array, bump the index */
+ if (p->nrecd > 0 && p->recds[p->nrecd-1].aix > -2)
+ p->recds[p->nrecd-1].aix++;
+ if ((t1 = cur_keypath(p)) == NULL)
+ return 0;
+
+ if (jcnf_add_key_internal(p, t1, jc_null, NULL, 0, NULL) != jc_ok) {
+ free(t1);
+ return 0;
+ }
+ free(t1);
+
+ return 1;
+}
+
+static int jcnf_yajl_boolean(void * ctx, int boolVal) {
+ jcnf *p = (jcnf *)ctx;
+ char *t1;
+
+// printf("bool: %s\n", boolVal ? "true" : "false");
+
+ /* If current level is an array, bump the index */
+ if (p->nrecd > 0 && p->recds[p->nrecd-1].aix > -2)
+ p->recds[p->nrecd-1].aix++;
+ if ((t1 = cur_keypath(p)) == NULL)
+ return 0;
+
+ if (jcnf_add_key_internal(p, t1, jc_boolean, (void *)&boolVal, sizeof(int), NULL) != jc_ok) {
+ free(t1);
+ return 0;
+ }
+ free(t1);
+
+ return 1;
+}
+
+static int jcnf_yajl_integer(void *ctx, long integerVal) {
+ jcnf *p = (jcnf *)ctx;
+ char *t1;
+
+// printf("integer: %lld\n", integerVal);
+
+ /* If current level is an array, bump the index */
+ if (p->nrecd > 0 && p->recds[p->nrecd-1].aix > -2)
+ p->recds[p->nrecd-1].aix++;
+ if ((t1 = cur_keypath(p)) == NULL)
+ return 0;
+
+ if (jcnf_add_key_internal(p, t1, jc_integer, (void *)&integerVal, sizeof(long), NULL) != jc_ok) {
+ free(t1);
+ return 0;
+ }
+ free(t1);
+
+ return 1;
+}
+
+static int jcnf_yajl_double(void *ctx, double doubleVal) {
+ jcnf *p = (jcnf *)ctx;
+ char *t1;
+
+// printf("double: %lf\n", doubleVal);
+
+ /* If current level is an array, bump the index */
+ if (p->nrecd > 0 && p->recds[p->nrecd-1].aix > -2)
+ p->recds[p->nrecd-1].aix++;
+ if ((t1 = cur_keypath(p)) == NULL)
+ return 0;
+
+ if (jcnf_add_key_internal(p, t1, jc_real, (void *)&doubleVal, sizeof(double), NULL) != jc_ok) {
+ free(t1);
+ return 0;
+ }
+ free(t1);
+
+ return 1;
+}
+
+static int jcnf_yajl_string(void *ctx, const unsigned char *stringVal,
+ unsigned int stringLen) {
+ jcnf *p = (jcnf *)ctx;
+ char *t1, *t2;
+
+// printf("string: '");
+// fwrite(stringVal, 1, stringLen, stdout);
+// printf("'\n");
+
+ /* If current level is an array, bump the index */
+ if (p->nrecd > 0 && p->recds[p->nrecd-1].aix > -2)
+ p->recds[p->nrecd-1].aix++;
+ if ((t1 = cur_keypath(p)) == NULL)
+ return 0;
+
+ if ((t2 = malloc(stringLen + 1)) == NULL) /* Room to add implicit nul */
+ return 0;
+ memmove(t2, stringVal, stringLen);
+ t2[stringLen] = 0;
+
+ if (jcnf_add_key_internal(p, t1, jc_string, (void *)t2, stringLen+1, NULL) != jc_ok) {
+ free(t2);
+ free(t1);
+ return 0;
+ }
+ free(t2);
+ free(t1);
+
+ return 1;
+}
+
+static int jcnf_yajl_c_comment(void *ctx, const unsigned char * stringVal,
+ unsigned int stringLen) {
+ jcnf *p = (jcnf *)ctx;
+
+// printf("c_comment: '");
+// fwrite(stringVal, 1, stringLen, stdout);
+// printf("'\n");
+
+ if (p->lk != NULL && p->lk->c_comment == NULL) {
+ char *t1;
+ if ((t1 = malloc(stringLen + 1)) == NULL)
+ return 0;
+ memmove(t1, stringVal, stringLen);
+ t1[stringLen] = 0;
+
+ p->lk->c_comment = t1;
+ }
+
+ return 1;
+}
+
+static int jcnf_yajl_cpp_comment(void *ctx, const unsigned char * stringVal,
+ unsigned int stringLen) {
+ jcnf *p = (jcnf *)ctx;
+
+// printf("cpp_comment: '");
+// fwrite(stringVal, 1, stringLen, stdout);
+// printf("'\n");
+
+ if (p->lk != NULL && p->lk->cpp_comment == NULL) {
+ char *t1;
+ if ((t1 = malloc(stringLen + 1)) == NULL)
+ return 0;
+ memmove(t1, stringVal, stringLen);
+ t1[stringLen] = 0;
+
+ p->lk->cpp_comment = t1;
+ }
+
+ return 1;
+}
+
+static int jcnf_yajl_start_map(void *ctx) {
+ jcnf *p = (jcnf *)ctx;
+
+ /* Start another recursion level */
+ if (p->nrecd >= p->arecd) {
+ p->arecd *= 2;
+ if ((p->recds = (jc_recd *)realloc(p->recds, p->arecd * sizeof(jc_recd))) == NULL) {
+ /* realloc failed */
+ return 0;
+ }
+ }
+
+ /* If current level is an array, bump the index */
+ if (p->nrecd > 0 && p->recds[p->nrecd-1].aix > -2)
+ p->recds[p->nrecd-1].aix++;
+
+ /* Move to new level */
+ p->recds[p->nrecd].key = NULL;
+ p->recds[p->nrecd].aix = -2;
+ p->nrecd++;
+
+#ifdef NEVER
+ printf("map open '{'\n");
+#endif
+
+ return 1;
+}
+
+static int jcnf_yajl_map_key(void *ctx, const unsigned char * stringVal,
+ unsigned int stringLen) {
+ jcnf *p = (jcnf *)ctx;
+ int i;
+
+ if (stringLen == 0) {
+ /* Zero length key */
+ return 0;
+ }
+
+ if (p->recds[p->nrecd-1].key != NULL) {
+ free(p->recds[p->nrecd-1].key);
+ p->recds[p->nrecd-1].key = NULL;
+ p->recds[p->nrecd-1].aix = -2;
+ }
+ if ((p->recds[p->nrecd-1].key = malloc(stringLen + 1)) == NULL)
+ return 0;
+
+ p->recds[p->nrecd-1].key[stringLen] = 0;
+ memmove(p->recds[p->nrecd-1].key, stringVal, stringLen);
+
+#ifdef NEVER
+ {
+ char *tt;
+
+ printf("Added path = '%s'\n", p->recds[p->nrecd-1].key);
+ if ((tt = cur_keypath(p)) != NULL) {
+ printf("Current path = '%s'\n",tt);
+ free(tt);
+ }
+ }
+#endif
+
+ return 1;
+}
+
+static int jcnf_yajl_end_map(void *ctx) {
+ jcnf *p = (jcnf *)ctx;
+
+ if (p->nrecd == 0) {
+ /* End of map without start of map */
+ return 0;
+ }
+ p->nrecd--;
+
+#ifdef NEVER
+ {
+ char *tt;
+ printf("map close '}'\n");
+ if ((tt = cur_keypath(p)) != NULL)
+ printf("Current path = '%s'\n",tt);
+ free(tt);
+ }
+#endif
+
+ return 1;
+}
+
+static int jcnf_yajl_start_array(void *ctx) {
+ jcnf *p = (jcnf *)ctx;
+
+#ifdef NEVER
+ printf("array open '['\n");
+#endif
+
+ /* Start another recursion level */
+ if (p->nrecd >= p->arecd) {
+ p->arecd *= 2;
+ if ((p->recds = (jc_recd *)realloc(p->recds, p->arecd * sizeof(jc_recd))) == NULL) {
+ /* realloc failed */
+ return 0;
+ }
+ }
+
+ /* If current level is an array, bump the index */
+ if (p->nrecd > 0 && p->recds[p->nrecd-1].aix > -2)
+ p->recds[p->nrecd-1].aix++;
+
+ /* Move to new level */
+ p->recds[p->nrecd].key = NULL;
+ p->recds[p->nrecd].aix = -1;
+ p->nrecd++;
+
+ return 1;
+}
+
+static int jcnf_yajl_end_array(void *ctx) {
+ jcnf *p = (jcnf *)ctx;
+
+#ifdef NEVER
+ printf("array close ']'\n");
+#endif
+ if (p->nrecd == 0) {
+ /* End of map without start of map */
+ return 0;
+ }
+ p->nrecd--;
+
+ return 1;
+}
+
+static yajl_callbacks callbacks = {
+ jcnf_yajl_null,
+ jcnf_yajl_boolean,
+ jcnf_yajl_integer,
+ jcnf_yajl_double,
+ NULL, /* number */
+ jcnf_yajl_string,
+ jcnf_yajl_c_comment,
+ jcnf_yajl_cpp_comment,
+ jcnf_yajl_start_map,
+ jcnf_yajl_map_key,
+ jcnf_yajl_end_map,
+ jcnf_yajl_start_array,
+ jcnf_yajl_end_array
+};
+
+/* - - - - - - - - - - - - - - - - */
+/* Lock the open fp */
+static jc_error jcnf_lock_file(jcnf *p) {
+#ifndef NT
+ int i, fh;
+ int lop;
+
+ fh = fileno(p->fp);
+
+ if (p->modify) {
+ lop = LOCK_EX | LOCK_NB;
+ } else {
+ lop = LOCK_SH | LOCK_NB;
+ }
+
+ for (i = 0; i < LOCK_RETRIES; i++) {
+ if (flock(fh, lop) == 0)
+ break;
+ sleep(1);
+ }
+ if (i >= LOCK_RETRIES)
+ return jc_locked;
+#endif
+ p->locked = 1;
+
+ return jc_ok;
+}
+
+/* Read a file into the object. */
+/* (Doesn't do locking) */
+/* Return NZ on error */
+static jc_error jcnf_read(
+ jcnf *p
+) {
+ jc_error ev;
+ yajl_handle hand;
+ yajl_parser_config cfg = { 0, 1 }; /* Validate UTF8 strings ? */
+ unsigned char buf[BUF_SIZE];
+ struct stat sbuf;
+
+ cfg.allowComments = 1;
+
+ if ((p->fp = fopen(p->fname, p->modify ? "r+" : "r")) == NULL) {
+ if (!p->modify)
+ return jc_noexisting;
+
+ if ((p->fp = fopen(p->fname, "w")) == NULL)
+ return jc_write_open;
+ if ((ev = jcnf_lock_file(p)) != jc_ok)
+ return ev;
+ return jc_ok;
+ }
+
+ if ((ev = jcnf_lock_file(p)) != jc_ok)
+ return ev;
+
+ hand = yajl_alloc(&callbacks, &cfg, NULL, (void *)p);
+
+ /* Parse the file */
+ for(;;) {
+ size_t rd;
+
+ rd = fread(buf, 1, BUF_SIZE, p->fp);
+
+ if (rd == 0) {
+ if (!feof(p->fp)) {
+ fprintf(stderr, "error reading from '%s'\n", p->fname);
+ return jc_read_fail;
+ }
+ break;
+ } else {
+ yajl_status stat;
+
+ /* read file data, pass to parser */
+ stat = yajl_parse(hand, buf, rd);
+ if (stat != yajl_status_insufficient_data &&
+ stat != yajl_status_ok)
+ {
+ unsigned char * str = yajl_get_error(hand, 1, buf, rd);
+ fflush(stdout);
+ fprintf(stderr, "%s", (char *) str);
+ yajl_free_error(hand, str);
+ return jc_parse_fail;
+ }
+ }
+ }
+
+ /* Record some things about the file so that we can */
+ /* recognized if it's been modified */
+ if (stat(p->fname, &sbuf) != 0) {
+ return jc_stat;
+ }
+ p->rsize = sbuf.st_size;
+ p->rtime = time(NULL);
+
+ yajl_free(hand);
+
+ /* We're not modifying it, so close it */
+ if (!p->modify) {
+ fclose(p->fp);
+ p->fp = NULL;
+ p->locked = 0;
+ }
+
+ return jc_ok;
+}
+
+/* Write an object into a file */
+/* Unlock it & close it afterwards. */
+/* Return NZ on error */
+static jc_error jcnf_write(
+ jcnf *p
+) {
+ FILE *fp; /* For temporary file */
+ char *tname = NULL;
+ yajl_gen_config conf = { 1, " " };
+ yajl_gen g;
+ yajl_status stat;
+ const unsigned char * buf;
+ unsigned int len;
+ int clevel = 0; /* Current level */
+ char *pkey = ""; /* Previous key */
+ char *ckey; /* Current key */
+ int i;
+
+ if (!p->locked && p->fp != NULL) {
+ return jc_update_nomod;
+ }
+
+#ifndef NT
+ {
+ int fh;
+
+ if ((tname = malloc(strlen(p->fname) + 8)) == NULL)
+ return jc_malloc;
+
+ /* Create temporary file, open it and lock it LOCK_EX */
+ strcpy(tname, p->fname);
+ strcat(tname,"-XXXXXX");
+ if ((fh = mkstemp(tname)) == -1) {
+ free(tname);
+ return jc_write_open;
+ }
+ if (fchmod(fh, 0644) != 0) {
+ free(tname);
+ return jc_write_open;
+ }
+ if ((fp = fdopen(fh, "w")) == NULL) {
+ free(tname);
+ return jc_write_open;
+ }
+ }
+#else
+ /* Open a temporary file in the same directory to write to */
+ if ((tname = malloc(strlen(p->fname) + 8)) == NULL)
+ return jc_malloc;
+
+ if (tmpnam(tname) == NULL) {
+ free(tname);
+ return jc_write_open;
+ }
+ if ((fp = fopen(tname, "w")) == NULL) {
+ free(tname);
+ return jc_write_open;
+ }
+#endif
+
+ g = yajl_gen_alloc(&conf, NULL);
+
+ /* Generate the file */
+ for (i = 0; i < p->nkeys; i++, pkey = ckey) {
+ char *pc, *cc, *dc;
+ int nplev; /* Number of previous different levels */
+ int ndlev; /* Number of new different levels */
+ int same;
+
+ ckey = p->keys[i]->key;
+
+ /* See how many keys are not in common */
+ nplev = ndlev = 0;
+ same = 1;
+ for(pc = pkey, dc = cc = ckey; *pc != '\000' || *cc != '\000';) {
+
+//printf("~1 pc = '%c', cc = '%c', same = %d\n",*pc,*cc,same);
+ if (same == 0 || *pc != *cc) {
+ same = 0;
+ if (*cc == '/') {
+ ndlev++;
+//printf("~1 ndlev now %d\n",ndlev);
+ }
+ if (*pc == '/') {
+ nplev++;
+//printf("~1 ndlev now %d\n",ndlev);
+ }
+
+ } else {
+ if (*cc == '/') {
+ dc = cc+1;
+ }
+ }
+ if (*pc != '\000') {
+ pc++;
+ if (same == 0 && *pc == '\000') {
+ nplev++;
+//printf("~1 nplev now %d\n",nplev);
+ }
+ }
+ if (*cc != '\000') {
+ cc++;
+ if (same == 0 && *cc == '\000') {
+ ndlev++;
+//printf("~1 ndlev now %d\n",ndlev);
+ }
+ }
+ }
+//printf("~1 Prev = '%s'\n",pkey);
+//printf("~1 Curr = '%s'\n",ckey);
+//printf("~1 New = '%s'\n",dc);
+//printf("~1 Old different = %d, new different = %d\n\n",nplev,ndlev);
+
+ while(nplev > 0) {
+ if (nplev > 1)
+ yajl_gen_map_close(g);
+ nplev--;
+ clevel--;
+ }
+ while(ndlev > 0) {
+ yajl_gen_map_open(g);
+ for (cc = dc; *cc != '\000' && *cc != '/'; cc++)
+ ;
+ yajl_gen_string(g, dc, cc-dc);
+ if (*cc != '\000')
+ dc = cc + 1;
+ ndlev--;
+ clevel++;
+ }
+
+ switch(p->keys[i]->type) {
+//printf("~1 key %d = type %d\n",i,p->keys[i]->type);
+ case jc_null:
+ yajl_gen_null(g);
+ break;
+
+ case jc_boolean:
+ yajl_gen_bool(g, *((int *)p->keys[i]->data));
+ break;
+
+ case jc_real:
+ yajl_gen_double(g, *((double *)p->keys[i]->data));
+ break;
+
+ case jc_integer:
+ yajl_gen_integer(g, *((long *)p->keys[i]->data));
+ break;
+
+ case jc_string:
+ yajl_gen_string(g, (char *)p->keys[i]->data, p->keys[i]->dataSize-1);
+ break;
+
+ default: {
+ free(tname);
+ return jc_unknown_key_type;
+ }
+ }
+
+ if (p->keys[i]->cpp_comment != NULL) {
+ yajl_gen_cpp_comment(g, p->keys[i]->cpp_comment, strlen(p->keys[i]->cpp_comment));
+ }
+ if (p->keys[i]->c_comment != NULL) {
+ yajl_gen_c_comment(g, p->keys[i]->c_comment, strlen(p->keys[i]->c_comment), 1);
+ }
+
+#ifdef NEVER
+ yajl_gen_map_open(g);
+ yajl_gen_string(g, "test", strlen("test"));
+ yajl_gen_string(g, "test value", strlen("test value"));
+ yajl_gen_c_comment(g, " A comment ", strlen(" A comment "));
+ yajl_gen_map_close(g);
+#endif
+
+ /* Do some writing */
+ yajl_gen_get_buf(g, &buf, &len);
+ if (len >= BUF_SIZE) {
+ if (fwrite(buf, 1, len, fp) != len)
+ return jc_write_fail;
+ yajl_gen_clear(g);
+ }
+ }
+
+ while(clevel > 0) {
+ yajl_gen_map_close(g);
+ clevel--;
+ }
+
+ yajl_gen_get_buf(g, &buf, &len);
+ if (len > 0) {
+ if (fwrite(buf, 1, len, fp) != len)
+ return jc_write_fail;
+ yajl_gen_clear(g);
+ }
+ yajl_gen_free(g);
+ if (fflush(fp) != 0) {
+ free(tname);
+ return jc_write_close;
+ }
+
+#ifdef NT
+ /* MSWindows rename won't replace existing or open files. */
+ /* Lucky this is just for testing, as this leaves a window */
+ if (fp != NULL) {
+ fclose(fp);
+ fp = NULL;
+ }
+ if (p->fp != NULL) {
+ fclose(p->fp);
+ p->fp = NULL;
+ }
+ unlink(p->fname);
+#endif
+
+//printf("~1 about to rename '%s' to '%s'\n",tname,p->fname);
+ /* Now atomicaly rename the file to replace the file we read */
+ if (rename(tname, p->fname) != 0) {
+ free(tname);
+ return jc_write_close;
+ }
+
+//printf("~1 closing files\n");
+ /* Close our files and release the locks */
+ if (fp != NULL && fclose(fp) != 0) {
+ free(tname);
+ return jc_write_close;
+ }
+ if (p->fp != NULL && fclose(p->fp) != 0) {
+ free(tname);
+ return jc_write_close;
+ }
+ p->fp = NULL;
+ p->locked = 0;
+ p->modify = 0;
+
+ free(tname);
+ return jc_ok;
+}
+
+/* Switch from read only to update of the config. */
+static jc_error jcnf_enable_modify(jcnf *p) {
+ jc_error ev;
+ struct stat sbuf;
+
+ if (p->modify)
+ return jc_ok; /* Nothing to do */
+
+ /* We need to re-open the file and lock it for modification */
+ if ((p->fp = fopen(p->fname, "r+")) == NULL) {
+ return jc_changed;
+ }
+ p->modify = 1;
+
+ if ((ev = jcnf_lock_file(p)) != jc_ok) {
+ p->modify = 0;
+ fclose(p->fp);
+ p->fp = NULL;
+ return ev;
+ }
+
+ /* Check that it hasn't been modified since it was first read */
+ if (stat(p->fname, &sbuf) != 0) {
+ p->modify = 0;
+ fclose(p->fp);
+ p->fp = NULL;
+ return jc_stat;
+ }
+
+ if (sbuf.st_size != p->rsize
+ || sbuf.st_mtime > p->rtime) {
+ p->modify = 0;
+ fclose(p->fp);
+ p->fp = NULL;
+ return jc_changed;
+ }
+
+ return jc_ok;
+}
+
+
+/* Update the file that was opened for modification, and unlock it. */
+static jc_error jcnf_update(jcnf *p) {
+ jc_error ev;
+ struct stat sbuf;
+
+ if (p->modified) {
+ if (p->modify == 0 || p->locked == 0) {
+
+ return jc_update_nomod; /* File wasn't opened for modification */
+ }
+ if ((ev = jcnf_write(p)) != jc_ok) {
+ return ev;
+ }
+ p->modified = 0;
+ }
+ p->modify = 0;
+
+ return jc_ok;
+}
+
+/* free the object */
+static void jcnf_del(jcnf *p) {
+
+ if (p->fp)
+ fclose(p->fp);
+
+ if (p->keys != NULL) {
+ int i;
+ for (i = 0; i < p->nkeys; i++) {
+ free_key(p->keys[i]);
+ }
+ free(p->keys);
+ }
+
+ if (p->recds != NULL) {
+ int i;
+ for (i = 0; i < p->nrecd; i++) {
+ free(p->recds[i].key);
+ }
+ free(p->recds);
+ }
+
+ if (p->fname)
+ free(p->fname);
+
+ free(p);
+}
+
+/* Create a new jconf. */
+/* Return NULL on error */
+jcnf *new_jcnf(
+ jc_error *pev, /* return error code on error */
+ char *fname, /* Corresponding filename */
+ jc_mod modify, /* Flag, nz to open for modification */
+ jc_crte create /* Flag, nz to create if it doesn't exist (modify must be set) */
+) {
+ jcnf *p;
+ jc_error ev;
+
+ if ((p = (jcnf *) calloc(1, sizeof(jcnf))) == NULL) {
+ if (pev != NULL) *pev = jc_malloc;
+ return NULL;
+ }
+
+ p->arecd = 10;
+ if ((p->recds = (jc_recd *) calloc(p->arecd, sizeof(jc_recd))) == NULL) {
+ if (pev != NULL) *pev = jc_malloc;
+ p->del(p);
+ return NULL;
+ }
+
+ if ((p->fname = strdup(fname)) == NULL) {
+ if (pev != NULL) *pev = jc_malloc;
+ p->del(p);
+ return NULL;
+ }
+
+ p->modify = modify == jc_modify ? 1 : 0;
+ p->create = create == jc_create ? 1 : 0;
+
+ p->locate_key = jcnf_locate_key;
+ p->get_key = jcnf_get_key;
+ p->set_key = jcnf_set_key;
+ p->add_key = jcnf_add_key;
+ p->delete_key = jcnf_delete_key;
+ p->print_key = jcnf_print_key;
+
+ p->enable_modify = jcnf_enable_modify;
+ p->update = jcnf_update;
+ p->del = jcnf_del;
+
+ if ((ev = jcnf_read(p)) != jc_ok) {
+ if (ev != jc_noexisting) {
+ if (pev != NULL) *pev = ev;
+ p->del(p);
+ return NULL;
+ }
+ }
+
+ if (pev != NULL) *pev = jc_ok;
+
+ return p;
+}
+
+/* ------------------------------- */
+/* Return a pointer to the nth element of the key name. */
+/* Return null if it is out of range or malloc failed. */
+/* Free the returned value when done. */
+char *jc_get_nth_elem(char *path, int n) {
+ int i;
+ char *p1, *p2, *rv;
+
+ if (path == NULL)
+ return NULL;
+
+ p1 = path;
+ if (*p1 == '/')
+ p1++;
+
+ for (i = 0; *p1 != '\000'; p1 = p2 + 1, i++) {
+ if ((p2 = strchr(p1, '/')) == NULL)
+ p2 = p1 + strlen(p1);
+ if (i >= n) {
+ if ((rv = malloc(p2 - p1 + 1)) == NULL)
+ return NULL;
+ strncpy(rv, p1, p2 - p1);
+ rv[p2-p1] = '\000';
+ return rv;
+ }
+ if (*p2 == '\000')
+ break;
+ }
+ return NULL;
+}
+
+
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-20 04:05:08 +0000