SUBDIR= external libpkg pkg

.include <bsd.subdir.mk>

SUBDIR= cjson tinycdb

.include <bsd.subdir.mk>

LIB=    cjson

INTERNALLIB=

SRCS=   cJSON.c

WARNS?= 6

WFORMAT?=   1

CFLAGS+= -fPIC

NO_MAN=true

.include <bsd.lib.mk>

/*

  Copyright (c) 2009 Dave Gamble

  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.

*/

// cJSON

// JSON parser in C.

#include <string.h>

#include <stdio.h>

#include <math.h>

#include <stdlib.h>

#include <float.h>

#include <limits.h>

#include <ctype.h>

#include "cJSON.h"

static int cJSON_strcasecmp(const char *s1,const char *s2)

{

	if (!s1) return (s1==s2)?0:1;if (!s2) return 1;

	for(; tolower(*s1) == tolower(*s2); ++s1, ++s2)	if(*s1 == 0)	return 0;

	return tolower(*(const unsigned char *)s1) - tolower(*(const unsigned char *)s2);

}

static void *(*cJSON_malloc)(size_t sz) = malloc;

static void (*cJSON_free)(void *ptr) = free;

static char* cJSON_strdup(const char* str)

{

      size_t len;

      char* copy;

      len = strlen(str) + 1;

      if (!(copy = (char*)cJSON_malloc(len))) return 0;

      memcpy(copy,str,len);

      return copy;

}

void cJSON_InitHooks(cJSON_Hooks* hooks)

{

    if (!hooks) { /* Reset hooks */

        cJSON_malloc = malloc;

        cJSON_free = free;

        return;

    }

	cJSON_malloc = (hooks->malloc_fn)?hooks->malloc_fn:malloc;

	cJSON_free	 = (hooks->free_fn)?hooks->free_fn:free;

}

// Internal constructor.

static cJSON *cJSON_New_Item(void)

{

	cJSON* node = (cJSON*)cJSON_malloc(sizeof(cJSON));

	if (node) memset(node,0,sizeof(cJSON));

	return node;

}

// Delete a cJSON structure.

void cJSON_Delete(cJSON *c)

{

	cJSON *next;

	while (c)

	{

		next=c->next;

		if (!(c->type&cJSON_IsReference) && c->child) cJSON_Delete(c->child);

		if (!(c->type&cJSON_IsReference) && c->valuestring) cJSON_free(c->valuestring);

		if (c->string) cJSON_free(c->string);

		cJSON_free(c);

		c=next;

	}

}

// Parse the input text to generate a number, and populate the result into item.

static const char *parse_number(cJSON *item,const char *num)

{

	double n=0,sign=1,scale=0;int subscale=0,signsubscale=1;

	// Could use sscanf for this?

	if (*num=='-') sign=-1,num++;	// Has sign?

	if (*num=='0') num++;			// is zero

	if (*num>='1' && *num<='9')	do	n=(n*10.0)+(*num++ -'0');	while (*num>='0' && *num<='9');	// Number?

	if (*num=='.') {num++;		do	n=(n*10.0)+(*num++ -'0'),scale--; while (*num>='0' && *num<='9');}	// Fractional part?

	if (*num=='e' || *num=='E')		// Exponent?

	{	num++;if (*num=='+') num++;	else if (*num=='-') signsubscale=-1,num++;		// With sign?

		while (*num>='0' && *num<='9') subscale=(subscale*10)+(*num++ - '0');	// Number?

	}

	n=sign*n*pow(10.0,(scale+subscale*signsubscale));	// number = +/- number.fraction * 10^+/- exponent

	item->valuedouble=n;

	item->valueint=(int)n;

	item->type=cJSON_Number;

	return num;

}

// Render the number nicely from the given item into a string.

static char *print_number(cJSON *item)

{

	char *str;

	double d=item->valuedouble;

	if (fabs(((double)item->valueint)-d)<=DBL_EPSILON && d<=INT_MAX && d>=INT_MIN)

	{

		str=(char*)cJSON_malloc(21);	// 2^64+1 can be represented in 21 chars.

		sprintf(str,"%d",item->valueint);

	}

	else

	{

		str=(char*)cJSON_malloc(64);	// This is a nice tradeoff.

		if (fabs(floor(d)-d)<=DBL_EPSILON)			sprintf(str,"%.0f",d);

		else if (fabs(d)<1.0e-6 || fabs(d)>1.0e9)	sprintf(str,"%e",d);

		else										sprintf(str,"%f",d);

	}

	return str;

}

// Parse the input text into an unescaped cstring, and populate item.

static const char firstByteMark[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };

static const char *parse_string(cJSON *item,const char *str)

{

	const char *ptr=str+1;char *ptr2;char *out;int len=0;unsigned uc;

	if (*str!='\"') return 0;	// not a string!

	while (*ptr!='\"' && (unsigned char)*ptr>31 && ++len) if (*ptr++ == '\\') ptr++;	// Skip escaped quotes.

	out=(char*)cJSON_malloc(len+1);	// This is how long we need for the string, roughly.

	if (!out) return 0;

	ptr=str+1;ptr2=out;

	while (*ptr!='\"' && (unsigned char)*ptr>31)

	{

		if (*ptr!='\\') *ptr2++=*ptr++;

		else

		{

			ptr++;

			switch (*ptr)

			{

				case 'b': *ptr2++='\b';	break;

				case 'f': *ptr2++='\f';	break;

				case 'n': *ptr2++='\n';	break;

				case 'r': *ptr2++='\r';	break;

				case 't': *ptr2++='\t';	break;

				case 'u':	 // transcode utf16 to utf8. DOES NOT SUPPORT SURROGATE PAIRS CORRECTLY.

					sscanf(ptr+1,"%4x",&uc);	// get the unicode char.

					len=3;if (uc<0x80) len=1;else if (uc<0x800) len=2;ptr2+=len;

					switch (len) {

						case 3: *--ptr2 =((uc | 0x80) & 0xBF); uc >>= 6;

						case 2: *--ptr2 =((uc | 0x80) & 0xBF); uc >>= 6;

						case 1: *--ptr2 =(uc | firstByteMark[len]);

					}

					ptr2+=len;ptr+=4;

					break;

				default:  *ptr2++=*ptr; break;

			}

			ptr++;

		}

	}

	*ptr2=0;

	if (*ptr=='\"') ptr++;

	item->valuestring=out;

	item->type=cJSON_String;

	return ptr;

}

// Render the cstring provided to an escaped version that can be printed.

static char *print_string_ptr(const char *str)

{

	const char *ptr;char *ptr2,*out;int len=0;

	if (!str) return cJSON_strdup("");

	ptr=str;while (*ptr && ++len) {if ((unsigned char)*ptr<32 || *ptr=='\"' || *ptr=='\\') len++;ptr++;}

	out=(char*)cJSON_malloc(len+3);

	ptr2=out;ptr=str;

	*ptr2++='\"';

	while (*ptr)

	{

		if ((unsigned char)*ptr>31 && *ptr!='\"' && *ptr!='\\') *ptr2++=*ptr++;

		else

		{

			*ptr2++='\\';

			switch (*ptr++)

			{

				case '\\':	*ptr2++='\\';	break;

				case '\"':	*ptr2++='\"';	break;

				case '\b':	*ptr2++='b';	break;

				case '\f':	*ptr2++='f';	break;

				case '\n':	*ptr2++='n';	break;

				case '\r':	*ptr2++='r';	break;

				case '\t':	*ptr2++='t';	break;

				default: ptr2--;	break;	// eviscerate with prejudice.

			}

		}

	}

	*ptr2++='\"';*ptr2++=0;

	return out;

}

// Invote print_string_ptr (which is useful) on an item.

static char *print_string(cJSON *item)	{return print_string_ptr(item->valuestring);}

// Predeclare these prototypes.

static const char *parse_value(cJSON *item,const char *value);

static char *print_value(cJSON *item,int depth,int fmt);

static const char *parse_array(cJSON *item,const char *value);

static char *print_array(cJSON *item,int depth,int fmt);

static const char *parse_object(cJSON *item,const char *value);

static char *print_object(cJSON *item,int depth,int fmt);

// Utility to jump whitespace and cr/lf

static const char *skip(const char *in) {while (in && (unsigned char)*in<=32) in++; return in;}

// Parse an object - create a new root, and populate.

cJSON *cJSON_Parse(const char *value)

{

	cJSON *c=cJSON_New_Item();

	if (!c) return 0;       /* memory fail */

	if (!parse_value(c,skip(value))) {cJSON_Delete(c);return 0;}

	return c;

}

// Render a cJSON item/entity/structure to text.

char *cJSON_Print(cJSON *item)				{return print_value(item,0,1);}

char *cJSON_PrintUnformatted(cJSON *item)	{return print_value(item,0,0);}

// Parser core - when encountering text, process appropriately.

static const char *parse_value(cJSON *item,const char *value)

{

	if (!value)						return 0;	// Fail on null.

	if (!strncmp(value,"null",4))	{ item->type=cJSON_NULL;  return value+4; }

	if (!strncmp(value,"false",5))	{ item->type=cJSON_False; return value+5; }

	if (!strncmp(value,"true",4))	{ item->type=cJSON_True; item->valueint=1;	return value+4; }

	if (*value=='\"')				{ return parse_string(item,value); }

	if (*value=='-' || (*value>='0' && *value<='9'))	{ return parse_number(item,value); }

	if (*value=='[')				{ return parse_array(item,value); }

	if (*value=='{')				{ return parse_object(item,value); }

	return 0;	// failure.

}

// Render a value to text.

static char *print_value(cJSON *item,int depth,int fmt)

{

	char *out=0;

	if (!item) return 0;

	switch ((item->type)&255)

	{

		case cJSON_NULL:	out=cJSON_strdup("null");	break;

		case cJSON_False:	out=cJSON_strdup("false");break;

		case cJSON_True:	out=cJSON_strdup("true"); break;

		case cJSON_Number:	out=print_number(item);break;

		case cJSON_String:	out=print_string(item);break;

		case cJSON_Array:	out=print_array(item,depth,fmt);break;

		case cJSON_Object:	out=print_object(item,depth,fmt);break;

	}

	return out;

}

// Build an array from input text.

static const char *parse_array(cJSON *item,const char *value)

{

	cJSON *child;

	if (*value!='[')	return 0;	// not an array!

	item->type=cJSON_Array;

	value=skip(value+1);

	if (*value==']') return value+1;	// empty array.

	item->child=child=cJSON_New_Item();

	if (!item->child) return 0;		 // memory fail

	value=skip(parse_value(child,skip(value)));	// skip any spacing, get the value.

	if (!value) return 0;

	while (*value==',')

	{

		cJSON *new_item;

		if (!(new_item=cJSON_New_Item())) return 0; 	// memory fail

		child->next=new_item;new_item->prev=child;child=new_item;

		value=skip(parse_value(child,skip(value+1)));

		if (!value) return 0;	// memory fail

	}

	if (*value==']') return value+1;	// end of array

	return 0;	// malformed.

}

// Render an array to text

static char *print_array(cJSON *item,int depth,int fmt)

{

	char **entries;

	char *out=0,*ptr,*ret;int len=5;

	cJSON *child=item->child;

	int numentries=0,i=0,fail=0;

	// How many entries in the array?

	while (child) numentries++,child=child->next;

	// Allocate an array to hold the values for each

	entries=(char**)cJSON_malloc(numentries*sizeof(char*));

	if (!entries) return 0;

	memset(entries,0,numentries*sizeof(char*));

	// Retrieve all the results:

	child=item->child;

	while (child && !fail)

	{

		ret=print_value(child,depth+1,fmt);

		entries[i++]=ret;

		if (ret) len+=strlen(ret)+2+(fmt?1:0); else fail=1;

		child=child->next;

	}

	// If we didn't fail, try to malloc the output string

	if (!fail) out=cJSON_malloc(len);

	// If that fails, we fail.

	if (!out) fail=1;

	// Handle failure.

	if (fail)

	{

		for (i=0;i<numentries;i++) if (entries[i]) cJSON_free(entries[i]);

		cJSON_free(entries);

		return 0;

	}

	// Compose the output array.

	*out='[';

	ptr=out+1;*ptr=0;

	for (i=0;i<numentries;i++)

	{

		strcpy(ptr,entries[i]);ptr+=strlen(entries[i]);

		if (i!=numentries-1) {*ptr++=',';if(fmt)*ptr++=' ';*ptr=0;}

		cJSON_free(entries[i]);

	}

	cJSON_free(entries);

	*ptr++=']';*ptr++=0;

	return out;	

}

// Build an object from the text.

static const char *parse_object(cJSON *item,const char *value)

{

	cJSON *child;

	if (*value!='{')	return 0;	// not an object!

	item->type=cJSON_Object;

	value=skip(value+1);

	if (*value=='}') return value+1;	// empty array.

	item->child=child=cJSON_New_Item();

	value=skip(parse_string(child,skip(value)));

	if (!value) return 0;

	child->string=child->valuestring;child->valuestring=0;

	if (*value!=':') return 0;	// fail!

	value=skip(parse_value(child,skip(value+1)));	// skip any spacing, get the value.

	if (!value) return 0;

	while (*value==',')

	{

		cJSON *new_item;

		if (!(new_item=cJSON_New_Item()))	return 0; // memory fail

		child->next=new_item;new_item->prev=child;child=new_item;

		value=skip(parse_string(child,skip(value+1)));

		if (!value) return 0;

		child->string=child->valuestring;child->valuestring=0;

		if (*value!=':') return 0;	// fail!

		value=skip(parse_value(child,skip(value+1)));	// skip any spacing, get the value.		

		if (!value) return 0;

	}

	if (*value=='}') return value+1;	// end of array

	return 0;	// malformed.	

}

// Render an object to text.

static char *print_object(cJSON *item,int depth,int fmt)

{

	char **entries=0,**names=0;

	char *out=0,*ptr,*ret,*str;int len=7,i=0,j;

	cJSON *child=item->child;

	int numentries=0,fail=0;

	// Count the number of entries.

	while (child) numentries++,child=child->next;

	// Allocate space for the names and the objects

	entries=(char**)cJSON_malloc(numentries*sizeof(char*));

	if (!entries) return 0;

	names=(char**)cJSON_malloc(numentries*sizeof(char*));

	if (!names) {cJSON_free(entries);return 0;}

	memset(entries,0,sizeof(char*)*numentries);

	memset(names,0,sizeof(char*)*numentries);

	// Collect all the results into our arrays:

	child=item->child;depth++;if (fmt) len+=depth;

	while (child)

	{

		names[i]=str=print_string_ptr(child->string);

		entries[i++]=ret=print_value(child,depth,fmt);

		if (str && ret) len+=strlen(ret)+strlen(str)+2+(fmt?2+depth:0); else fail=1;

		child=child->next;

	}

	// Try to allocate the output string

	if (!fail) out=(char*)cJSON_malloc(len);

	if (!out) fail=1;

	// Handle failure

	if (fail)

	{

		for (i=0;i<numentries;i++) {if (names[i]) free(names[i]);if (entries[i]) free(entries[i]);}

		free(names);free(entries);

		return 0;

	}

	// Compose the output:

	*out='{';ptr=out+1;if (fmt)*ptr++='\n';*ptr=0;

	for (i=0;i<numentries;i++)

	{

		if (fmt) for (j=0;j<depth;j++) *ptr++='\t';

		strcpy(ptr,names[i]);ptr+=strlen(names[i]);

		*ptr++=':';if (fmt) *ptr++='\t';

		strcpy(ptr,entries[i]);ptr+=strlen(entries[i]);

		if (i!=numentries-1) *ptr++=',';

		if (fmt) *ptr++='\n';*ptr=0;

		cJSON_free(names[i]);cJSON_free(entries[i]);

	}

	cJSON_free(names);cJSON_free(entries);

	if (fmt) for (i=0;i<depth-1;i++) *ptr++='\t';

	*ptr++='}';*ptr++=0;

	return out;	

}

// Get Array size/item / object item.

int    cJSON_GetArraySize(cJSON *array)							{cJSON *c=array->child;int i=0;while(c)i++,c=c->next;return i;}

cJSON *cJSON_GetArrayItem(cJSON *array,int item)				{cJSON *c=array->child;  while (c && item>0) item--,c=c->next; return c;}

cJSON *cJSON_GetObjectItem(cJSON *object,const char *string)	{cJSON *c=object->child; while (c && cJSON_strcasecmp(c->string,string)) c=c->next; return c;}

// Utility for array list handling.

static void suffix_object(cJSON *prev,cJSON *item) {prev->next=item;item->prev=prev;}

// Utility for handling references.

static cJSON *create_reference(cJSON *item) {cJSON *ref=cJSON_New_Item();memcpy(ref,item,sizeof(cJSON));ref->string=0;ref->type|=cJSON_IsReference;ref->next=ref->prev=0;return ref;}

// Add item to array/object.

void   cJSON_AddItemToArray(cJSON *array, cJSON *item)						{cJSON *c=array->child;if (!c) {array->child=item;} else {while (c && c->next) c=c->next; suffix_object(c,item);}}

void   cJSON_AddItemToObject(cJSON *object,const char *string,cJSON *item)	{if (item->string) cJSON_free(item->string);item->string=cJSON_strdup(string);cJSON_AddItemToArray(object,item);}

void	cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item)						{cJSON_AddItemToArray(array,create_reference(item));}

void	cJSON_AddItemReferenceToObject(cJSON *object,const char *string,cJSON *item)	{cJSON_AddItemToObject(object,string,create_reference(item));}

cJSON *cJSON_DetachItemFromArray(cJSON *array,int which)			{cJSON *c=array->child;while (c && which>0) c=c->next,which--;if (!c) return 0;

	if (c->prev) c->prev->next=c->next;if (c->next) c->next->prev=c->prev;if (c==array->child) array->child=c->next;c->prev=c->next=0;return c;}

void   cJSON_DeleteItemFromArray(cJSON *array,int which)			{cJSON_Delete(cJSON_DetachItemFromArray(array,which));}

cJSON *cJSON_DetachItemFromObject(cJSON *object,const char *string) {int i=0;cJSON *c=object->child;while (c && cJSON_strcasecmp(c->string,string)) i++,c=c->next;if (c) return cJSON_DetachItemFromArray(object,i);return 0;}

void   cJSON_DeleteItemFromObject(cJSON *object,const char *string) {cJSON_Delete(cJSON_DetachItemFromObject(object,string));}

// Replace array/object items with new ones.

void   cJSON_ReplaceItemInArray(cJSON *array,int which,cJSON *newitem)		{cJSON *c=array->child;while (c && which>0) c=c->next,which--;if (!c) return;

	newitem->next=c->next;newitem->prev=c->prev;if (newitem->next) newitem->next->prev=newitem;

	if (c==array->child) array->child=newitem; else newitem->prev->next=newitem;c->next=c->prev=0;cJSON_Delete(c);}

void   cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem){int i=0;cJSON *c=object->child;while(c && cJSON_strcasecmp(c->string,string))i++,c=c->next;if(c){newitem->string=cJSON_strdup(string);cJSON_ReplaceItemInArray(object,i,newitem);}}

// Create basic types:

cJSON *cJSON_CreateNull()						{cJSON *item=cJSON_New_Item();item->type=cJSON_NULL;return item;}

cJSON *cJSON_CreateTrue()						{cJSON *item=cJSON_New_Item();item->type=cJSON_True;return item;}

cJSON *cJSON_CreateFalse()						{cJSON *item=cJSON_New_Item();item->type=cJSON_False;return item;}

cJSON *cJSON_CreateNumber(double num)			{cJSON *item=cJSON_New_Item();item->type=cJSON_Number;item->valuedouble=num;item->valueint=(int)num;return item;}

cJSON *cJSON_CreateString(const char *string)	{cJSON *item=cJSON_New_Item();item->type=cJSON_String;item->valuestring=cJSON_strdup(string);return item;}

cJSON *cJSON_CreateArray()						{cJSON *item=cJSON_New_Item();item->type=cJSON_Array;return item;}

cJSON *cJSON_CreateObject()						{cJSON *item=cJSON_New_Item();item->type=cJSON_Object;return item;}

// Create Arrays:

cJSON *cJSON_CreateIntArray(int *numbers,int count)				{int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;i<count;i++){n=cJSON_CreateNumber(numbers[i]);if(!i)a->child=n;else suffix_object(p,n);p=n;}return a;}

cJSON *cJSON_CreateFloatArray(float *numbers,int count)			{int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;i<count;i++){n=cJSON_CreateNumber(numbers[i]);if(!i)a->child=n;else suffix_object(p,n);p=n;}return a;}

cJSON *cJSON_CreateDoubleArray(double *numbers,int count)		{int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;i<count;i++){n=cJSON_CreateNumber(numbers[i]);if(!i)a->child=n;else suffix_object(p,n);p=n;}return a;}

cJSON *cJSON_CreateStringArray(const char **strings,int count)	{int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;i<count;i++){n=cJSON_CreateString(strings[i]);if(!i)a->child=n;else suffix_object(p,n);p=n;}return a;}

/*

  Copyright (c) 2009 Dave Gamble

  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.

*/

#ifndef cJSON__h

#define cJSON__h

#ifdef __cplusplus

extern "C"

{

#endif

// cJSON Types:

#define cJSON_False 0

#define cJSON_True 1

#define cJSON_NULL 2

#define cJSON_Number 3

#define cJSON_String 4

#define cJSON_Array 5

#define cJSON_Object 6

#define cJSON_IsReference 256

// The cJSON structure:

typedef struct cJSON {

	struct cJSON *next,*prev;	// next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem

	struct cJSON *child;		// An array or object item will have a child pointer pointing to a chain of the items in the array/object.

	int type;					// The type of the item, as above.

	char *valuestring;			// The item's string, if type==cJSON_String

	int valueint;				// The item's number, if type==cJSON_Number

	double valuedouble;			// The item's number, if type==cJSON_Number

	char *string;				// The item's name string, if this item is the child of, or is in the list of subitems of an object.

} cJSON;

typedef struct cJSON_Hooks {

      void *(*malloc_fn)(size_t sz);

      void (*free_fn)(void *ptr);

} cJSON_Hooks;

// Supply malloc, realloc and free functions to cJSON

extern void cJSON_InitHooks(cJSON_Hooks* hooks);

// Supply a block of JSON, and this returns a cJSON object you can interrogate. Call cJSON_Delete when finished.

extern cJSON *cJSON_Parse(const char *value);

// Render a cJSON entity to text for transfer/storage. Free the char* when finished.

extern char  *cJSON_Print(cJSON *item);

// Render a cJSON entity to text for transfer/storage without any formatting. Free the char* when finished.

extern char  *cJSON_PrintUnformatted(cJSON *item);

// Delete a cJSON entity and all subentities.

extern void   cJSON_Delete(cJSON *c);

// Returns the number of items in an array (or object).

extern int	  cJSON_GetArraySize(cJSON *array);

// Retrieve item number "item" from array "array". Returns NULL if unsuccessful.

extern cJSON *cJSON_GetArrayItem(cJSON *array,int item);

// Get item "string" from object. Case insensitive.

extern cJSON *cJSON_GetObjectItem(cJSON *object,const char *string);

// These calls create a cJSON item of the appropriate type.

extern cJSON *cJSON_CreateNull(void);

extern cJSON *cJSON_CreateTrue(void);

extern cJSON *cJSON_CreateFalse(void);

extern cJSON *cJSON_CreateNumber(double num);

extern cJSON *cJSON_CreateString(const char *string);

extern cJSON *cJSON_CreateArray(void);

extern cJSON *cJSON_CreateObject(void);

// These utilities create an Array of count items.

extern cJSON *cJSON_CreateIntArray(int *numbers,int count);

extern cJSON *cJSON_CreateFloatArray(float *numbers,int count);

extern cJSON *cJSON_CreateDoubleArray(double *numbers,int count);

extern cJSON *cJSON_CreateStringArray(const char **strings,int count);

// Append item to the specified array/object.

extern void cJSON_AddItemToArray(cJSON *array, cJSON *item);

extern void	cJSON_AddItemToObject(cJSON *object,const char *string,cJSON *item);

// Append reference to item to the specified array/object. Use this when you want to add an existing cJSON to a new cJSON, but don't want to corrupt your existing cJSON.

extern void cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item);

extern void	cJSON_AddItemReferenceToObject(cJSON *object,const char *string,cJSON *item);

// Remove/Detatch items from Arrays/Objects.

extern cJSON *cJSON_DetachItemFromArray(cJSON *array,int which);

extern void   cJSON_DeleteItemFromArray(cJSON *array,int which);

extern cJSON *cJSON_DetachItemFromObject(cJSON *object,const char *string);

extern void   cJSON_DeleteItemFromObject(cJSON *object,const char *string);

// Update array items.

extern void cJSON_ReplaceItemInArray(cJSON *array,int which,cJSON *newitem);

extern void cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem);

#define cJSON_AddNullToObject(object,name)	cJSON_AddItemToObject(object, name, cJSON_CreateNull())

#define cJSON_AddTrueToObject(object,name)	cJSON_AddItemToObject(object, name, cJSON_CreateTrue())

#define cJSON_AddFalseToObject(object,name)		cJSON_AddItemToObject(object, name, cJSON_CreateFalse())

#define cJSON_AddNumberToObject(object,name,n)	cJSON_AddItemToObject(object, name, cJSON_CreateNumber(n))

#define cJSON_AddStringToObject(object,name,s)	cJSON_AddItemToObject(object, name, cJSON_CreateString(s))

#ifdef __cplusplus

}

#endif

#endif

2006-06-29  Michael Tokarev  <mjt@corpit.ru>

	* see debian/changelog file for further changes.

2005-04-18  Michael Tokarev  <mjt@corpit.ru>

	* move cdb_make_find.c content into cdb_make_put.c

	* introduce CDB_PUT_REPLACE0 - zerofill old duplicates

	* allow usage of cdb.h in C++

2005-04-11  Michael Tokarev  <mjt@corpit.ru>

	* do not autogenerate files (cdb.h.in, cdb.3.in etc), but

	  use real files instead (only substituted VERSION and NAME)

	* finally fixed the `!fputs()' condition to be `fputs() < 0'

	  as it should be in cdb.c (misbehaves on *bsd)

	* kill cdbi_t usage in cdb_int.h

	* export _cdb_make_fullwrite() (was ewrite()) and _cdb_make_flush()

	  and use them in cdb_make.c as appropriate

	* almost completely rewrite _cdb_make_find() and friends:

	  - _cdb_make_find() now accepts new parameter, remove (bool), which,

	    if true, indicates all found records should be deleted from the

	    database.

	  - Call _cdb_make_find() with remove=0 from cdb_make_exists()

	  - Call _cdb_make_find() with appropriate arguments from

	    cdb_make_put(), and simplify the latter greatly (was too clumsy

	    anyway)

	* rename `flags' parameter in cdb_make_put() to be `mode' which is

	  more appropriate

	* change #if conditional in nss_cdb.c

	  from __GLIBC__ to __GNU_LIBRARY__

2003-11-04  Michael Tokarev  <mjt@corpit.ru>

	* added cdb_get() routine: tinycdb officially uses mmap.

	* added cdb_{get,read}{data,key}() macros to read and get

	  current data and key.

	* fixed bug in cdb_seek() - incorrect wrap, sometimes

	  cdb_seek()+cdb_bread() may return EIO instead of finding

	  correct record.

	* added some tweaks to Makefile to build position-independent

	  libcdb_pic.a and shared libcdb.so libraries.  Note that

	  using libcdb as shared library is probably not a good idea,

	  due to tiny size of the library.

	* added initial nss_cdb module.  Still not well-tested.

	  Probably will not build on non-GNU system.

	* adjusted tests.{ok,sh} for latest cdb utility modifications

	  (-a mode in query by default)

	* Victor Porton (porton at ex-code.com) provided a patch

	  to allow tinycdb to be built on win32 platform (cdb_init.c).

	  Completely untested.

2003-08-13  Michael Tokarev  <mjt@corpit.ru>

	* s/cdbi_t/unsigned/g.  No need to keep this type.

	* changed usage of cdb_findnext(): one need to pass

	  pointer to cdb structure to cdb_findnext() now,

	  and should use cdb_datapos(struct cdb_find *)

	  instead of cdb_datapos(struct cdb *)

	* added cdb_seqinit() and cdb_seqnext() routines for sequential

	  record enumeration

	* addded cdb_dend to the cdb structure: end of data

	  position.  Use that in cdb_seq*().

	* more strict checking: ensure data is within data section,

	  and hash tables are within hash section of a file.

	* cdb_make.c (cdb_make_start): zerofill cdb_make structure

	  to shut valgrind up (writing uninitialized data to file)

	* cdb.c (cmode): always open file in RDWR mode to allow

	  duplicate key detection

2002-12-08  Michael Tokarev  <mjt+cdb@corpit.ru>

	* version 0.73

	* de-Debianization.  Oh well... ;)

	* no code changes, just like in 0.72

2002-10-13  Michael Tokarev  <mjt+cdb@corpit.ru>

	* version 0.72

	* cleaned up debian packaging and made it actually work

	* no code changes

2002-07-22  Michael Tokarev <mjt+cdb@corpit.ru>

	* version 0.71

	* rearranged object files to not depend on ranlib on

	  systems that requires it (i.e. OpenBSD)

	* use ranlib but mark it's possible error as non-fatal

2001-12-10  Michael Tokarev <mjt+cdb@corpit.ru>

	* version 0.7a

	* converted to CVS, added two missing #include <stdlib.h> for

	  malloc declaration and spec target to the Makefile

2001-10-14  Michael Tokarev <mjt+cdb@corpit.ru>

	* version 0.7

	* added cdb_seek() and cdb_bread() routines as found

	  in freecdb/cdb-0.64

2001-07-26  Michael Tokarev <mjt+cdb@corpit.ru>

	* version 0.6

	* added another option, CDB_PUT_WARN, to cdb_make_put's flags

	  (to allow adding unconditionally but still warn about dups),

	  now cdb_make_put seems to be logically complete.

	* added and documented -r and -u options for cdb(1) command,

	  and made them consistent with -w and -e also.

	* reorganized cdb(1) manpage and added changes made to cdb

	  command.

	* added version references to manpages (and make them autogenerated

	  to simplify maintenance).

	* added cdb(5) manpage describing CDB file format.

2001-07-25  Michael Tokarev <mjt+cdb@corpit.ru>

	* version 0.5

	* added missing #include <sys/types.h> in cdb_init.c, thanks to

	  ppetru@ppetru.net (Petru Paler)

	* removed usage of pread() in cdb_make_find() and friends,

	  suggested by Liviu Daia <Liviu.Daia@imar.ro>

	* autogenerate tinycdb.spec file from template and debian/changelog

	* autogenerate cdb.h from cdb.h.in (substituting version)

2001-06-29  Michael Tokarev <mjt+cdb@corpit.ru>

	* version 0.4

	* added cdb_make_put() routine to conditionnaly add a record

	* split cdb library to more files (finer granularity)

	* added cdb_findinit() and cdb_findnext() routines

	* renamed cdbtool to cdb

	* simplified cdb utility (dropped various format spec, changed

	  options parsing) and a manpage

	* added small note and copyright to every file in package

	* added some testsuite (make test)

2001-05-27  Michael Tokarev <mjt+cdb@corpit.ru>

	* version 0.3

	* Initial Release.

LIB=	cdb

INTERNALLIB=

SRCS= cdb_init.c cdb_find.c cdb_findnext.c cdb_seq.c cdb_seek.c \

      cdb_unpack.c \

      cdb_make_add.c cdb_make_put.c cdb_make.c cdb_hash.c

CFLAGS+=-fPIC

WARNS?=6

WFORMAT?=1

NO_MAN=true

.include <bsd.lib.mk>

#! /usr/bin/make -rf

# $Id: Makefile,v 1.28 2009-01-31 17:12:21 mjt Exp $

# make file for tinycdb package

#

# This file is a part of tinycdb package by Michael Tokarev, mjt@corpit.ru.

# Public domain.

VERSION = 0.77

prefix=/usr/local

exec_prefix=$(prefix)

bindir=$(exec_prefix)/bin

libdir=$(exec_prefix)/lib

syslibdir=$(libdir)

sysconfdir=/etc

includedir=$(prefix)/include

mandir=$(prefix)/man

NSSCDB_DIR = $(sysconfdir)

DESTDIR=

CC = cc

CFLAGS = -O

AR = ar

ARFLAGS = rv

RANLIB = ranlib

NSS_CDB = libnss_cdb.so.2

LIBBASE = libcdb

LIB = $(LIBBASE).a

PICLIB = $(LIBBASE)_pic.a

SHAREDLIB = $(LIBBASE).so.1

SOLIB = $(LIBBASE).so

CDB_USELIB = $(LIB)

NSS_USELIB = $(PICLIB)

LIBMAP = $(LIBBASE).map

INSTALLPROG = cdb

# The following assumes GNU CC/LD -

# used for building shared libraries only

CFLAGS_PIC = -fPIC

CFLAGS_SHARED = -shared

CFLAGS_SONAME = -Wl,--soname=

CFLAGS_VSCRIPT = -Wl,--version-script=

CP = cp

LIB_SRCS = cdb_init.c cdb_find.c cdb_findnext.c cdb_seq.c cdb_seek.c \

 cdb_unpack.c \

 cdb_make_add.c cdb_make_put.c cdb_make.c cdb_hash.c

NSS_SRCS = nss_cdb.c nss_cdb-passwd.c nss_cdb-group.c nss_cdb-spwd.c

NSSMAP = nss_cdb.map

DISTFILES = Makefile cdb.h cdb_int.h $(LIB_SRCS) cdb.c \

 $(NSS_SRCS) nss_cdb.h nss_cdb-Makefile \

 cdb.3 cdb.1 cdb.5 \

 tinycdb.spec tests.sh tests.ok \

 $(LIBMAP) $(NSSMAP) \

 ChangeLog NEWS

DEBIANFILES = debian/control debian/rules debian/copyright debian/changelog

all: static

static: staticlib cdb

staticlib: $(LIB)

nss: $(NSS_CDB)

piclib: $(PICLIB)

sharedlib: $(SHAREDLIB)

shared: sharedlib cdb-shared

LIB_OBJS = $(LIB_SRCS:.c=.o)

LIB_OBJS_PIC = $(LIB_SRCS:.c=.lo)

NSS_OBJS = $(NSS_SRCS:.c=.lo)

$(LIB): $(LIB_OBJS)

	-rm -f $@

	$(AR) $(ARFLAGS) $@ $(LIB_OBJS)

	-$(RANLIB) $@

$(PICLIB): $(LIB_OBJS_PIC)

	-rm -f $@

	$(AR) $(ARFLAGS) $@ $(LIB_OBJS_PIC)

	-$(RANLIB) $@

$(SHAREDLIB): $(LIB_OBJS_PIC) $(LIBMAP)

	-rm -f $(SOLIB)

	ln -s $@ $(SOLIB)

	$(CC) $(CFLAGS) $(CFLAGS_SHARED) -o $@ \

	 $(CFLAGS_SONAME)$(SHAREDLIB) $(CFLAGS_VSCRIPT)$(LIBMAP) \

	 $(LIB_OBJS_PIC)

cdb: cdb.o $(CDB_USELIB)

	$(CC) $(CFLAGS) -o $@ cdb.o $(CDB_USELIB)

cdb-shared: cdb.o $(SHAREDLIB)

	$(CC) $(CFLAGS) -o $@ cdb.o $(SHAREDLIB)

$(NSS_CDB): $(NSS_OBJS) $(NSS_USELIB) $(NSSMAP)

	$(CC) $(CFLAGS) $(CFLAGS_SHARED) -o $@ \

	 $(CFLAGS_SONAME)$@ $(CFLAGS_VSCRIPT)$(NSSMAP) \

	 $(NSS_OBJS) $(NSS_USELIB)

.SUFFIXES:

.SUFFIXES: .c .o .lo

.c.o:

	$(CC) $(CFLAGS) -c $<

.c.lo:

	$(CC) $(CFLAGS) $(CFLAGS_PIC) -c -o $@ -DNSSCDB_DIR=\"$(NSSCDB_DIR)\" $<

cdb.o: cdb.h

$(LIB_OBJS) $(LIB_OBJS_PIC): cdb_int.h cdb.h

$(NSS_OBJS): nss_cdb.h cdb.h

clean:

	-rm -f *.o *.lo core *~ tests.out tests-shared.ok

realclean distclean:

	-rm -f *.o *.lo core *~ $(LIBBASE)[._][aps]* $(NSS_CDB)* cdb cdb-shared

test tests check: cdb

	sh ./tests.sh ./cdb > tests.out 2>&1

	diff tests.ok tests.out

	@echo All tests passed

test-shared tests-shared check-shared: cdb-shared

	sed 's/^cdb: /cdb-shared: /' <tests.ok >tests-shared.ok

	LD_LIBRARY_PATH=. sh ./tests.sh ./cdb-shared > tests.out 2>&1

	diff tests-shared.ok tests.out

	rm -f tests-shared.ok

	@echo All tests passed

do_install = \

 while [ "$$1" ] ; do \

   if [ .$$4 = .- ]; then f=$$1; else f=$$4; fi; \

   d=$(DESTDIR)$$3 ; echo installing $$1 to $$d/$$f; \

   [ -d $$d ] || mkdir -p $$d || exit 1 ; \

   $(CP) $$1 $$d/$$f || exit 1; \

   chmod 0$$2 $$d/$$f || exit 1; \

   shift 4; \

 done

install-all: all $(INSTALLPROG)

	set -- \

	 cdb.h 644 $(includedir) - \

	 cdb.3 644 $(mandir)/man3 - \

	 cdb.1 644 $(mandir)/man1 - \

	 cdb.5 644 $(mandir)/man5 - \

	 $(INSTALLPROG) 755 $(bindir) cdb \

	 libcdb.a 644 $(libdir) - \

	 ; \

	$(do_install)

install-nss: nss

	@set -- $(NSS_CDB) 644 $(syslibdir) - \

	        nss_cdb-Makefile 644 $(sysconfdir) cdb-Makefile ; \

	$(do_install)

install-sharedlib: sharedlib

	@set -- $(SHAREDLIB) 644 $(libdir) - ; \

	$(do_install) ; \

	ln -sf $(SHAREDLIB) $(DESTDIR)$(libdir)/$(LIBBASE).so

install-piclib: piclib

	@set -- $(PICLIB) 644 $(libdir) - ; \

	$(do_install)

install: install-all

DNAME = tinycdb-$(VERSION)

dist: $(DNAME).tar.gz

$(DNAME).tar.gz: $(DISTFILES) $(DEBIANFILES)

	mkdir $(DNAME) $(DNAME)/debian

	ln $(DISTFILES) $(DNAME)/

	ln $(DEBIANFILES) $(DNAME)/debian/

	tar cfz $@ $(DNAME)

	rm -fr $(DNAME)

.PHONY: all clean realclean dist spec

.PHONY: test tests check test-shared tests-shared check-shared

.PHONY: static staticlib shared sharedlib nss piclib

.PHONY: install install-all install-sharedlib install-piclib install-nss

$Id: NEWS,v 1.6 2009-01-31 17:12:21 mjt Exp $

User-visible news.  Latest at the top.

tinycdb-0.77

 - bugfix release: manpage typos, portability fixes and the like

 - bugfix: improper logic in EINTR handling in _cdb_make_full_write

   routine which may lead to corruped .cdb file.

tinycdb-0.76

 - new cdb utility option: -p permissions, to specify permission

   bits for the newly created database file.

 - cdb utility, when creating the database, does unlink() of the

   (temp) db file and when opens it with O_CREAT|O_EXCL, instead

   of previous O_CREAT|O_TRUNC w/o unlink() behaviour, and uses

   O_NOFOLLOW flag if available.  This avoids any possible symlink

   race conditions, but is somewhat incompatible with previous

   versions, where it was possible to create temp file beforehand

   with proper permissions.  Together with new -p option (above),

   this isn't that big change.

 - cdb utility now allows to omit temp file usage (with final rename())

   when creating the database, by specifying -t- (`-' as temp file name)

   (or -t the_same_name_as_the_db_file).  Useful if the utility is called

   from a script which does its own rename afterwards.

 - alot of minor code changes to make modern compilers happy (mostly

   signed char vs unsigned char "fixes").  Including additions of

   `unsigned' into common structure definitions in cdb.h - the API

   stays compatible still.

 - several (spelling and other) fixes for manpages.

 - tinycdb is, once again, maintained as a native Debian package.

   Debian package has been split into 4 parts: libcdb1, libcdb-dev,

   tinycdb (the utility) and libnss_cdb.  RPM .spec file now builds

   two packages as well: tinycdb (includes shared library, the utility,

   and nss_cdb module) and tinycdb-devel (development files).

tinycdb-0.75 (2005-04-11)

 - make cdb_make_put(CDB_PUT_REPLACE) to actually *remove*

   all (was only first previously) matching records, by

   rewriting the file.

 - new mode CDB_PUT_REPLACE0, which zeroes out old duplicate

   records

 - fixed fputs() == NULL condition in cdb.c, finally

   (should be < 0, not == NULL)

tinycdb-0.74 (2003-11-04)

 - reworked cdb utility, see manpage for details.  cdb -q now

   prints all matching records by default (incompat change),

   use cdb -q -n XX to return only XXth record if any.

   -m works with -q.

 - there are several new routines (and macros) in library.

   - cdb_seqinit() and cdb_seqstart() to fetch all records

   - cdb_get() to get a pointer to data in internal buffer

   - cdb_{get,read}{data,key}()

 - cdbi_t gone (but still defined).  Use unsigned instead.

 - cdb_findnext() changed

 - fixed a bug in cdb_seek() (EIO instead of getting valid record)

 - added nss_cdb (for passwd, group and shadow databases only)

 - Makefile targets to build PIC code (libcdb_pic.a, required for

   nss_cdb) and shared library (probably not a good idea)

 - Modifications to allow tinycdb to compile under win32,

   by Victor Porton (porton at ex-code.com).

.\" $Id: cdb.1,v 1.12 2009-01-31 17:12:22 mjt Exp $

.\" cdb command tool manpage

.\"

.\" This file is a part of tinycdb package by Michael Tokarev, mjt@corpit.ru.

.\" Public domain.

.\"

.TH cdb 1 "Jan 2009"

.SH NAME

cdb \- Constant DataBase manipulation tool

.SH SYNOPSYS

\fBcdb\fR \-q [\-m] [\-n \fInum\fR] \fIdbname\fR \fIkey\fR

.br

\fBcdb\fR \-d [\-m] [\fIdbname\fR|\-]

.br

\fBcdb\fR \-l [\-m] [\fIdbname\fR|\-]

.br

\fBcdb\fR \-s [\fIdbname\fR|\-]

.br

\fBcdb\fR \-c [\-m] [\-t \fItmpname\fR|\-] [\-p \fIperms\fR] [\-weru0] \fIdbname\fR [\fIinfile\fR...]

.SH DESCRIPTION

\fBcdb\fR used to query, dump, list, analyze or create CDB (Constant

DataBase) files.  Format of cdb described in \fIcdb\fR(5) manpage.

This manual page corresponds to version \fB0.77\fR of \fBtinycdb\fR

package.

.SS Query

\fBcdb \-q\fR finds given \fIkey\fR in a given \fIdbname\fR

cdb file, and writes associated value to standard output if found (and

exits with zero), or exits with non\-zero if not found.  \fIdbname\fR must

be seekable file, and stdin can not be used as input.

By default, \fBcdb\fR will print \fIall\fR records found.

Options recognized in query mode:

.IP \fB\-n\fInum\fR

causes \fBcdb\fR to find and write a record with a given number \fInum\fR

starting with 1 \(em when there are many records with a given key.

.IP \fB\-m\fR

newline will be added after every value printed.  By default, multiple

values will be written without any delimiter.

.SS "Dump/List"

\fBcdb \-d\fR dumps contents, and \fBcdb \-l\fR lists keys

of \fIcdbfile\fR (or standard input if not specified) to standard

output, in format controlled by presence of \fB\-m\fR option.

See subsection "Formats" below.  Output from \fBcdb \-d\fR

can be used as an input for \fBcdb \-c\fR.

.SS Create

Cdb database created in two stages: temporary database is created,

and after it is complete, it gets atomically renamed to permanent

place.  This avoids requirements for locking between readers and

writers (or creaters).  \fBcdb \-c\fR will attempt to create

cdb in file \fItmpname\fR (or \fIdbname\fR with ".tmp" appended

if no \-t option given) and then rename it to \fIdbname\fR.  It

will read supplied \fIinfile\fRs (or standard input if none specified).

Options recognized in create mode:

.IP "\fB\-t \fItmpname\fR"

use given \fItmpname\fR as temporary file.  Defaults to

\fIdbname\fR.tmp (i.e. with output file with .tmp added).

Note \fItmpname\fR must be in the same filesystem as output file, as

.B cdb

uses

.IR rename (2)

to finalize the database creation procedure.

If \fItmpname\fR is a single dash (\-), no temp file will be created,

database will be built in\-place.  This mode is useful when the final

renaming is done by the caller.

.IP "\fB\-p \fIperms\fR"

permissions for the newly created file (usually an octal number, like 0644).

By default the permissions are 0666 (with current process umask applied).

If this option is specified, current umask value has no effect.

.IP \fB\-w\fR

warn about duplicate keys.

.IP \fB\-e\fR

abort on duplicate keys (implies \-w).

.IP \fB\-r\fR

replace existing key with new one in case of duplicate.

This may require database file rewrite to remove old

records, and can be slow.

.IP \fB\-0\fR

zero-fill existing records when duplicate records are

added.  This is faster than \fB\-r\fR, but leaves extra

zeros in the database file in case of duplicates.

.IP \fB\-u\fR

do not add duplicate records.

.IP \fB\-m\fR

interpret input as a sequence of lines, one record per line,

with value separated from a key by space or tab characters,

instead of native cdb format (see "Input/Output Format" below).

.PP

Note that using any option that requires duplicate checking will

slow creation process \fIsignificantly\fR, especially for large

databases.

.SS Statistics

\fBcdb \-s\fR will analyze \fIdbfile\fR and print summary to

standard output.  Statistics include: total number of rows in

a file, minimum, average and maximum key and value lengths,

hash tables (max 256) and entries used, number of hash collisions

(that is, more than one key point to the same hash table entry),

minimum, average and maximum hash table size (of non-empty tables),

and number of keys that sits at 10 different distances from

it's calculated hash table index \(em keys in distance 0 requires

only one hash table lookup, 1 \(em two and so on; more keys at

greater distance means slower database search.

.SS "Input/Output Format"

By default, \fBcdb\fR expects (for create operation) or writes

(for dump/list) native cdb format data.  Cdb native format is

a sequence of records in a form:

.br

    +\fIklen\fR,\fIvlen\fR:\fIkey\fR\->\fIval\fR\\n

.br

where "+", ",", ":", "\-", ">" and "\\n" (newline) are literal characters,

\fIklen\fR and \fIvlen\fR are length of key and value as decimal numbers,

and \fIkey\fR and \fIval\fR are key and value themselves.  Series of

records terminated by an empty line.  This is the only format where

key and value may contain any character including newline, zero (\\0)

and so on.

When \fB\-l\fR option requested (list keys mode), \fBcdb\fR will produce

slightly modified output in a form:

.br

    +\fIklen\fR:\fIkey\fR\\n

.br

(note \fIvlen\fR and \fIval\fR are omitted, together with surrounding

delimiters).

If \fB\-m\fR option is given, \fBcdb\fR will expect or produce one line

for every record (newline is a record delimiter), and every line should

contain optional whitespace, key, whitespace and value up to end of line.

Lines started with hash character (#) and empty lines are ignored.

This is the same format as \fBmkmap\fR(1) utility expects.

.SH "OPTIONS SUMMARY"

Here is a short summary of all options accepted by \fBcdb\fR utility:

.IP \fB\-0\fR

zero-fill duplicate records in create (\fB\-c\fR) mode.

.IP \fB\-c\fR

create mode.

.IP \fB\-d\fR

dump mode.

.IP \fB\-e\fR

abort (error) on duplicate key in create (\fB\-c\fR) mode.

.IP \fB\-h\fR

print short help and exit.

.IP \fB\-l\fR

list mode.

.IP \fB\-m\fR

input or output is in "map" format, not in native cdb format.  In query

mode, add a newline after every value written.

.IP \fB\-n\fInum\fR

find and print \fInum\fRth record in query (\fB\-q\fR) mode.

.IP \fB\-q\fR

query mode.

.IP \fB\-r\fR

replace duplicate keys in create (\fB\-c\fR) mode.

.IP \fB\-s\fR

statistics mode.

.IP "\fB\-t\fR \fItempfile\fR"

specify temporary file when creating (\fB\-c\fR) cdb file (use single dash

(\-) as \fItempfile\fR to stop using temp file).

.IP \fB\-u\fR

do not insert duplicate keys (unique) in create (\fB\-c\fR) mode.

.IP \fB\-w\fR

warn about duplicate keys in create (\fB\-c\fR) mode.

.SH AUTHOR

The \fBtinycdb\fR package written by Michael Tokarev <mjt@corpit.ru>,

based on ideas and shares file format with original cdb library by

Dan Bernstein.

.SH "SEE ALSO"

cdb(5), cdb(3).

.SH LICENCE

Public domain.

.\" $Id: cdb.3,v 1.11 2009-01-31 17:12:22 mjt Exp $

.\" cdb library manpage

.\"

.\" This file is a part of tinycdb package by Michael Tokarev, mjt@corpit.ru.

.\" Public domain.

.\"

.TH cdb 3 "Jun 2006"

.SH NAME

cdb \- Constant DataBase library

.SH SYNOPSYS

.nf

.ft B

 #include <cdb.h>

 cc ... \-lcdb

.ft R

.fi

.SH DESCRIPTION

.B cdb

is a library to create and access Constant DataBase files.

File stores (key,value) pairs and used to quickly find a

value based on a given key.  Cdb files are create-once files,

that is, once created, file cannot be updated but recreated

from scratch -- this is why database is called \fIconstant\fR.

Cdb file is optimized for quick access.  Format of such file

described in \fIcdb\fR(5) manpage.  This manual page corresponds

to version \fB0.77\fR of \fBtinycdb\fR package.

Library defines two non-interlaced interfaces: for querying

existing cdb file data (read-only mode) and for creating

such a file (almost write-only).  Strictly speaking, those

modes allows very limited set of opposite operation as well

(i.e. in query mode, it is possible to update key's value).

All routines in this library are thread-safe as no global

data used, except of \fIerrno\fR variable for error indication.

.B cdb

datafiles may be moved between systems safely, since format

does not depend on architecture.

.SH "QUERY MODE"

There are two query modes available.  First uses a structure

that represents a cdb database, just like \fBFILE\fR structure

in stdio library, and another works with plain filedescriptor.

First mode is more sophisticated and flexible, and usually somewhat

faster.  It uses \fBmmap\fR(2) internally.  This mode may look

more "natural" or object-oriented compared to second one.

The following routines works with any mode:

.nf

unsigned \fBcdb_unpack\fR(\fIbuf\fR)

   const unsigned char \fIbuf\fR[4];

.fi

.RS

helper routine to convert 32-bit integer from internal representation

to machine format.  May be used to handle application integers in

a portable way.  There is no error return.

.RE

.SS "Query Mode 1"

All query operations in first more deals with common data

structure, \fBstruct cdb\fR, associated with an open file

descriptor.  This structure is opaque to application.

The following routines exists for accessing \fBcdb\fR

database:

.nf

int \fBcdb_init\fR(\fIcdbp\fR, \fIfd\fR)

   struct cdb *\fIcdbp\fR;

   int \fIfd\fR;

.fi

.RS

initializes structure given by \fIcdbp\fR pointer and associates

it with opened file descriptor \fIfd\fR.  Memory allocation for

structure itself if needed and file open operation should be done

by application.  File \fIfd\fR should be opened at least read-only,

and should be seekable.  Routine returns 0 on success or negative

value on error.

.RE

.nf

void \fBcdb_free\fR(\fIcdbp\fR)

   struct cdb *\fIcdbp\fR;

.fi

.RS

frees internal resources held by structure.  Note that this

routine does \fInot\fR closes a file.

.RE

.nf

int \fBcdb_fileno\fR(\fIcdbp\fR)

  const struct cdb *\fIcdbp\fR;

.fi

.RS

returns filedescriptor associated with cdb (as was passed to

\fBcdb_init\fR()).

.RE

.nf

int \fBcdb_read\fR(\fIcdbp\fR, \fIbuf\fR, \fIlen\fR, \fIpos\fR)

int \fBcdb_readdata\fR(\fIcdbp\fR, \fIbuf\fR, \fIlen\fR, \fIpos\fR)

int \fBcdb_readkey\fR(\fIcdbp\fR, \fIbuf\fR, \fIlen\fR, \fIpos\fR)

   const struct cdb *\fIcdbp\fR;

   void *\fIbuf\fR;

   unsigned \fIlen\fR;

   unsigned \fIpos\fR;

.fi

.RS

reads a data from cdb file, starting at position \fIpos\fR of length

\fIlen\fR, placing result to \fIbuf\fR.  This routine may be used

to get actual value found by \fBcdb_find\fR() or other routines

that returns position and length of a data.  Returns 0 on success

or negative value on error.

Routines \fBcdb_readdata\fR() and \fBcdb_readkey\fR() are shorthands

to read current (after e.g. \fBcdb_find\fR()) data and key

respectively, using \fBcdb_read\fR().

.RE

.nf

const void *\fBcdb_get\fR(\fIcdbp\fR, \fIlen\fR, \fIpos\fR)

const void *\fBcdb_getdata\fR(\fIcdbp\fR)

const void *\fBcdb_getkey\fR(\fIcdbp\fR)

   const struct cdb *\fIcdbp\fR;

   unsigned \fIlen\fR;

   unsigned \fIpos\fR;

.fi

.RS

Internally, cdb library uses memory-mmaped region to access the on-disk

database.  \fBcdb_get\fR() allows to access internal memory in a way

similar to \fBcdb_read\fR() but without extra copying and buffer

allocation.  Returns pointer to actual data on success or NULL on

error (position points to outside of the database).

Routines \fBcdb_getdata\fR() and \fBcdb_getkey\fR() are shorthands

to access current (after e.g. \fBcdb_find\fR()) data and key

respectively, using \fBcdb_get\fR().

.RE

.nf

int \fBcdb_find\fR(\fIcdbp\fR, \fIkey\fR, \fIklen\fR)

unsigned \fBcdb_datapos\fR(\fIcdbp\fR)

unsigned \fBcdb_datalen\fR(\fIcdbp\fR)

unsigned \fBcdb_keypos\fR(\fIcdbp\fR)

unsigned \fBcdb_keylen\fR(\fIcdbp\fR)

   struct cdb *\fIcdbp\fR;

   const void *\fIkey\fR;

   unsigned \fIklen\fR;

.fi

.RS

attempts to find a key given by (\fIkey\fR,\fIklen\fR) parameters.

If key exists in database, routine returns 1 and places position

and length of value associated with this key to internal fields

inside \fIcdbp\fR structure, to be accessible by \fBcdb_datapos\fR(\fIcdbp\fR)

and \fBcdb_datalen\fR(\fIcdbp\fR) routines.  If key is not in database,

\fBcdb_find\fR() returns 0.  On error, negative value is returned.

Data pointers (available via \fBcdb_datapos\fR() and \fBcdb_datalen\fR())

gets updated only in case of successful search.  Note that using

\fBcdb_find\fR() it is possible to lookup only \fIfirst\fR record

with a given key.

.RE

.nf

int \fBcdb_findinit(\fIcdbfp\fR, \fIcdbp\fR, \fIkey\fR, \fIklen\fR)

int \fBcdb_findnext\fR(\fIcdbfp\fR)

  struct cdb_find *\fIcdbfp\fR;

  const struct cdb *\fIcdbp\fR;

  const void *\fIkey\fR;

  unsigned \fIklen\fR;

.fi

.RS

sequential-find routines that used separate structure.  It is

possible to have more than one record with the same key in a

database, and these routines allows to enumerate all them.

\fBcdb_findinit\fR() initializes search structure pointed to

by \fIcdbfp\fR.  It will return negative value on error or

non-negative value on success.  \fBcdb_findnext\fR() attempts

to find next (first when called right after \fBcdb_findinit\fR())

matching key, setting value position and length in \fIcdbfp\fR

structure.  It will return positive value if given key was

found, 0 if there is no more such key(s), or negative value

on error.  To access value position and length after successful

call to \fBcdb_findnext\fR() (when it returned positive result),

use \fBcdb_datapos\fR(\fIcdbp\fR) and \fBcdb_datalen\fR(\fIcdbp\fR)

routines.  It is error to continue using \fBcdb_findnext\fR() after

it returned 0 or error condition (\fBcdb_findinit\fR() should be

called again).  Current data pointers (available via \fBcdb_datapos\fR()

and \fBcdb_datalen\fR()) gets updated only on successful search.

.RE

.nf

void \fBcdb_seqinit\fR(\fIcptr\fR, \fIcdbp\fR)

int \fBcdb_seqnext\fR(\fIcptr\fR, \fIcdbp\fR)

  unsigned *\fIcptr\fR;

  struct cdb *\fIcdbp\fR;

.fi

.RS

sequential enumeration of all records stored in cdb file.

\fBcdb_seqinit\fR() initializes access current data pointer \fIcptr\fR

to point before first record in a cdb file. \fBcdb_seqnext\fR() updates

data pointers in \fIcdbp\fR to point to the next record and updates

\fIcptr\fR, returning positive value on success, 0 on end of data condition

and negative value on error.  Current record will be available after

successful operation using \fBcdb_datapos\fR(\fIcdbp\fR) and

\fBcdb_datalen\fR(\fIcdbp\fR) (for the data) and \fBcdb_keypos\fR(\fIcdbp\fR)

and \fBcdb_keylen\fR(\fIcdbp\fR) (for the key of the record).

Data pointers gets updated only in case of successful operation.

.RE

.SS "Query Mode 2"

In this mode, one need to open a \fBcdb\fR file using one of

standard system calls (such as \fBopen\fR(2)) to obtain a

filedescriptor, and then pass that filedescriptor to cdb routines.

Available methods to query a cdb database using only a filedescriptor

include:

.nf

int \fBcdb_seek\fR(\fIfd\fR, \fIkey\fR, \fIklen\fR, \fIdlenp\fR)

  int \fIfd\fR;

  const void *\fIkey\fR;

  unsigned \fIklen\fR;

  unsigned *\fIdlenp\fR;

.fi

.RS

searches a cdb database (as pointed to by \fIfd\fR filedescriptor)

for a key given by (\fIkey\fR, \fIklen\fR), and positions file pointer

to start of data associated with that key if found, so that next read

operation from this filedescriptor will read that value, and places

length of value, in bytes, to variable pointed to by \fIdlenp\fR.

Returns positive value if operation was successful, 0 if key was not

found, or negative value on error.  To read the data from a cdb file,

\fBcdb_bread\fR() routine below can be used.

.RE

.nf

int \fBcdb_bread\fR(\fIfd\fR, \fIbuf\fR, \fIlen\fR)

  int \fIfd\fR;

  void *\fIbuf\fR;

  int \fIlen\fR;

.fi

.RS

reads data from a file (as pointed to by \fIfd\fR filedescriptor) and

places \fIlen\fR bytes from this file to a buffer pointed to by \fIbuf\fR.

Returns 0 if exactly \fIlen\fR bytes was read, or a negative value in

case of error or end-of-file.  This routine ignores interrupt errors (EINTR).

Sets errno variable to \fBEIO\fR in case of end-of-file condition (when

there is less than \fIlen\fR bytes available to read).

.RE

.SS Notes

Note that \fIvalue\fR of any given key may be updated in place

by another value of the same size, by writing to file at position

found by \fBcdb_find\fR() or \fBcdb_seek\fR().  However one should

be very careful when doing so, since write operation may not succeed

in case of e.g. power failure, thus leaving corrupted data.  When

database is (re)created, one can guarantee that no incorrect data

will be written to database, but not with inplace update.  Note

also that it is not possible to update any key or to change length

of value.

.SS

.SH "CREATING MODE"

.B cdb

database file should usually be created in two steps: first, temporary

file created and written to disk, and second, that temporary file

is renamed to permanent place.  Unix rename(2) call is atomic operation,

it removes destination file if any AND renaes another file in one

step.  This way it is guaranteed that readers will not see incomplete

database.  To prevent multiple simultaneous updates, locking may

also be used.

All routines used to create \fBcdb\fR database works with

\fBstruct cdb_make\fR object that is opaque to application.

Application may assume that \fBstruct cdb_make\fR has at least

the same member(s) as published in \fBstruct cdb\fR above.

.nf

int \fBcdb_make_start\fR(\fIcdbmp\fR, \fIfd\fR)

   struct cdb_make *\fIcdbmp\fR;

   int \fIfd\fR;

.fi

.RS