src/bnetd/file_cdb.c

/*
 * Copyright (C) 2003,2004 Mihai RUSU (dizzy@rdsnet.ro)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
#include "common/setup_before.h"
#include <stdio.h>
#ifdef HAVE_STDDEF_H
# include <stddef.h>
#else
# ifndef NULL
#  define NULL ((void *)0)
# endif
#endif
#ifdef STDC_HEADERS
# include <stdlib.h>
#else
# ifdef HAVE_MALLOC_H
#  include <malloc.h>
# endif
#endif
#ifdef HAVE_STRING_H
# include <string.h>
#else
# ifdef HAVE_STRINGS_H
#  include <strings.h>
# endif
#endif
#include "compat/strchr.h"
#include "compat/strdup.h"
#include "compat/strcasecmp.h"
#include "compat/strncasecmp.h"
#include <ctype.h>
#ifdef HAVE_LIMITS_H
# include <limits.h>
#endif
#include "compat/char_bit.h"
#ifdef TIME_WITH_SYS_TIME
# include <sys/time.h>
# include <time.h>
#else
# ifdef HAVE_SYS_TIME_H
#  include <sys/time.h>
# else
#  include <time.h>
# endif
#endif
#include <errno.h>
#include "compat/strerror.h"
#ifdef HAVE_SYS_TYPES_H
# include <sys/types.h>
#endif
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#else
# ifdef WIN32
#  include <io.h>
# endif
#endif
#include "compat/pdir.h"
#include "common/eventlog.h"
#include "prefs.h"
#include "common/util.h"
#include "common/field_sizes.h"
#include "common/bnethash.h"
#include "common/introtate.h"
#define CLAN_INTERNAL_ACCESS
#define ACCOUNT_INTERNAL_ACCESS
#include "account.h"
#include "common/hashtable.h"
#include "storage.h"
#include "storage_file.h"
#include "common/list.h"
#include "common/xalloc.h"
#include "connection.h"
#include "watch.h"
#include "clan.h"
#undef ACCOUNT_INTERNAL_ACCESS
#undef CLAN_INTERNAL_ACCESS
#include "common/tag.h"
#ifdef HAVE_FCNTL_H
# include <fcntl.h>
#else
# ifdef HAVE_SYS_FILE_H
#  include <sys/file.h>
# endif
#endif
#include "tinycdb/cdb.h"
#include "common/setup_after.h"

/* cdb file storage API functions */

static int cdb_read_attrs(const char *filename, t_read_attr_func cb, void *data);
static void * cdb_read_attr(const char *filename, const char *key);
static int cdb_write_attrs(const char *filename, void *attributes);

/* file_engine struct populated with the functions above */

t_file_engine file_cdb = {
    cdb_read_attr,
    cdb_read_attrs,
    cdb_write_attrs
};

/* start of actual cdb file storage code */

//#define CDB_ON_DEMAND 1

static int cdb_write_attrs(const char *filename, void *attributes)
{
    FILE           *cdbfile;
    t_attribute    *attr;
    struct cdb_make cdbm;

    if ((cdbfile = fopen(filename, "w+b")) == NULL) {
        eventlog(eventlog_level_error, __FUNCTION__, "unable to open file \"%s\" for writing ",filename);
        return -1;
    }

    cdb_make_start(&cdbm, cdbfile);
    for (attr=(t_attribute *)attributes; attr; attr=attr->next) {
        if (attr->key && attr->val) {
            if (strncmp("BNET\\CharacterDefault\\", attr->key, 20) == 0) {
                eventlog(eventlog_level_debug, __FUNCTION__, "skipping attribute key=\"%s\"",attr->key);
            } else {
                eventlog(eventlog_level_debug, __FUNCTION__, "saving attribute key=\"%s\" val=\"%s\"",attr->key,attr->val);
                if (cdb_make_add(&cdbm, attr->key, strlen(attr->key), attr->val, strlen(attr->val))<0)
                {
                    eventlog(eventlog_level_error, __FUNCTION__, "got error on cdb_make_add ('%s' = '%s')", attr->key, attr->val);
                    cdb_make_finish(&cdbm); /* try to bail out nicely */
                    fclose(cdbfile);
                    return -1;
                }
            }
        } else eventlog(eventlog_level_error, __FUNCTION__,"could not save attribute key=\"%s\"",attr->key);

    }

    if (cdb_make_finish(&cdbm)<0) {
        eventlog(eventlog_level_error, __FUNCTION__, "got error on cdb_make_finish");
        fclose(cdbfile);
        return -1;
    }

    if (fclose(cdbfile)<0) {
        eventlog(eventlog_level_error, __FUNCTION__, "got error on fclose()");
        return -1;
    }

    return 0;
}

#ifndef CDB_ON_DEMAND
/* code adapted from tinycdb-0.73/cdb.c */

static int fget(FILE * fd, unsigned char *b, cdbi_t len, cdbi_t *posp, cdbi_t limit)
{
    if (posp && limit - *posp < len) {
        eventlog(eventlog_level_error, __FUNCTION__, "invalid cdb database format");
        return -1;
    }

    if (fread(b, 1, len, fd) != len) {
        if (ferror(fd)) {
            eventlog(eventlog_level_error, __FUNCTION__, "got error reading from db file");
            return -1;
        }
        eventlog(eventlog_level_error, __FUNCTION__, "unable to read from cdb file, incomplete file");
        return -1;
    }

    if (posp) *posp += len;
    return 0;
}

static const char * fcpy(FILE *fd, cdbi_t len, cdbi_t *posp, cdbi_t limit, unsigned char * buf)
{
    static char *str;
    static unsigned strl;
    unsigned int res = 0, no = 0;

    if (strl < len + 1) {
        char *tmp;

        tmp = xmalloc(len + 1);
        if (str) xfree((void*)str);
        str = tmp;
        strl = len + 1;
    }

    while(len - res > 0) {
        if (len > 2048) no = 2048;
        else no = len;

        if (fget(fd, buf, no, posp, limit)) return NULL;
        memmove(str + res, buf, no);
        res += no;
    }

    if (res > strl - 1) {
        eventlog(eventlog_level_error, __FUNCTION__, "BUG, this should not happen");
        return NULL;
    }

    str[res] = '\0';
    return str;
}

static int cdb_read_attrs(const char *filename, t_read_attr_func cb, void *data)
{
    cdbi_t eod, klen, vlen;
    cdbi_t pos = 0;
    const char *key;
    const char *val;
    unsigned char buf[2048];
    FILE *f;

    if ((f = fopen(filename, "rb")) == NULL) {
        eventlog(eventlog_level_error, __FUNCTION__, "got error opening file '%s'", filename);
        return -1;
    }

    if (fget(f, buf, 2048, &pos, 2048)) goto err_fd;
    eod = cdb_unpack(buf);
    while(pos < eod) {
        if (fget(f, buf, 8, &pos, eod)) goto err_fd;
        klen = cdb_unpack(buf);
        vlen = cdb_unpack(buf + 4);
        if ((key = fcpy(f, klen, &pos, eod, buf)) == NULL) {
            eventlog(eventlog_level_error, __FUNCTION__, "error reading attribute key");
            goto err_fd;
        }

        key = xstrdup(key);

        if ((val = fcpy(f, vlen, &pos, eod, buf)) == NULL) {
            eventlog(eventlog_level_error, __FUNCTION__, "error reading attribute val");
            goto err_key;
        }

//      eventlog(eventlog_level_trace, __FUNCTION__, "read atribute : '%s' -> '%s'", key, val);
        if (cb(key, val, data))
            eventlog(eventlog_level_error, __FUNCTION__, "got error from callback on account file '%s'", filename);
        xfree((void *)key);
    }

    fclose(f);
    return 0;

err_key:
    xfree((void *)key);

err_fd:
    fclose(f);
    return -1;
}
#else /* CDB_ON_DEMAND */
static int cdb_read_attrs(const char *filename, t_read_attr_func cb, void *data)
{
    return 0;
}
#endif

static void * cdb_read_attr(const char *filename, const char *key)
{
#ifdef CDB_ON_DEMAND
    FILE        *cdbfile;
    t_attribute *attr;
    char        *val;
    unsigned    vlen = 1;

//    eventlog(eventlog_level_trace, __FUNCTION__, "reading key '%s'", key);
    if ((cdbfile = fopen(filename, "rb")) == NULL) {
//      eventlog(eventlog_level_debug, __FUNCTION__, "unable to open file \"%s\" for reading ",filename);
        return NULL;
    }

    if (cdb_seek(cdbfile, key, strlen(key), &vlen) <= 0) {
//      eventlog(eventlog_level_debug, __FUNCTION__, "could not find key '%s'", key);
        fclose(cdbfile);
        return NULL;
    }

    attr = xmalloc(sizeof(t_attribute));
    attr->key = xstrdup(key);
    val = xmalloc(vlen + 1);

    cdb_bread(cdbfile, val, vlen);
    fclose(cdbfile);

    val[vlen] = '\0';

    attr->val = val;
    attr->dirty = 0;
//    eventlog(eventlog_level_trace, __FUNCTION__, "read key '%s' value '%s'", attr->key, attr->val);
    return attr;
#else
    return NULL;
#endif
}

1	/*
2	* Copyright (C) 2003,2004 Mihai RUSU (dizzy@rdsnet.ro)
3	*
4	* This program is free software; you can redistribute it and/or
5	* modify it under the terms of the GNU General Public License
6	* as published by the Free Software Foundation; either version 2
7	* of the License, or (at your option) any later version.
8	*
9	* This program is distributed in the hope that it will be useful,
10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12	* GNU General Public License for more details.
13	*
14	* You should have received a copy of the GNU General Public License
15	* along with this program; if not, write to the Free Software
16	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17	*/
18	#include "common/setup_before.h"
19	#include <stdio.h>
20	#ifdef HAVE_STDDEF_H
21	# include <stddef.h>
22	#else
23	# ifndef NULL
24	# define NULL ((void *)0)
25	# endif
26	#endif
27	#ifdef STDC_HEADERS
28	# include <stdlib.h>
29	#else
30	# ifdef HAVE_MALLOC_H
31	# include <malloc.h>
32	# endif
33	#endif
34	#ifdef HAVE_STRING_H
35	# include <string.h>
36	#else
37	# ifdef HAVE_STRINGS_H
38	# include <strings.h>
39	# endif
40	#endif
41	#include "compat/strchr.h"
42	#include "compat/strdup.h"
43	#include "compat/strcasecmp.h"
44	#include "compat/strncasecmp.h"
45	#include <ctype.h>
46	#ifdef HAVE_LIMITS_H
47	# include <limits.h>
48	#endif
49	#include "compat/char_bit.h"
50	#ifdef TIME_WITH_SYS_TIME
51	# include <sys/time.h>
52	# include <time.h>
53	#else
54	# ifdef HAVE_SYS_TIME_H
55	# include <sys/time.h>
56	# else
57	# include <time.h>
58	# endif
59	#endif
60	#include <errno.h>
61	#include "compat/strerror.h"
62	#ifdef HAVE_SYS_TYPES_H
63	# include <sys/types.h>
64	#endif
65	#ifdef HAVE_UNISTD_H
66	# include <unistd.h>
67	#else
68	# ifdef WIN32
69	# include <io.h>
70	# endif
71	#endif
72	#include "compat/pdir.h"
73	#include "common/eventlog.h"
74	#include "prefs.h"
75	#include "common/util.h"
76	#include "common/field_sizes.h"
77	#include "common/bnethash.h"
78	#include "common/introtate.h"
79	#define CLAN_INTERNAL_ACCESS
80	#define ACCOUNT_INTERNAL_ACCESS
81	#include "account.h"
82	#include "common/hashtable.h"
83	#include "storage.h"
84	#include "storage_file.h"
85	#include "common/list.h"
86	#include "common/xalloc.h"
87	#include "connection.h"
88	#include "watch.h"
89	#include "clan.h"
90	#undef ACCOUNT_INTERNAL_ACCESS
91	#undef CLAN_INTERNAL_ACCESS
92	#include "common/tag.h"
93	#ifdef HAVE_FCNTL_H
94	# include <fcntl.h>
95	#else
96	# ifdef HAVE_SYS_FILE_H
97	# include <sys/file.h>
98	# endif
99	#endif
100	#include "tinycdb/cdb.h"
101	#include "common/setup_after.h"
102
103	/* cdb file storage API functions */
104
105	static int cdb_read_attrs(const char filename, t_read_attr_func cb, void data);
106	static void * cdb_read_attr(const char filename, const char key);
107	static int cdb_write_attrs(const char filename, void attributes);
108
109	/* file_engine struct populated with the functions above */
110
111	t_file_engine file_cdb = {
112	cdb_read_attr,
113	cdb_read_attrs,
114	cdb_write_attrs
115	};
116
117	/* start of actual cdb file storage code */
118
119	//#define CDB_ON_DEMAND 1
120
121	static int cdb_write_attrs(const char filename, void attributes)
122	{
123	FILE *cdbfile;
124	t_attribute *attr;
125	struct cdb_make cdbm;
126
127	if ((cdbfile = fopen(filename, "w+b")) == NULL) {
128	eventlog(eventlog_level_error, __FUNCTION__, "unable to open file \"%s\" for writing ",filename);
129	return -1;
130	}
131
132	cdb_make_start(&cdbm, cdbfile);
133	for (attr=(t_attribute *)attributes; attr; attr=attr->next) {
134	if (attr->key && attr->val) {
135	if (strncmp("BNET\\CharacterDefault\\", attr->key, 20) == 0) {
136	eventlog(eventlog_level_debug, __FUNCTION__, "skipping attribute key=\"%s\"",attr->key);
137	} else {
138	eventlog(eventlog_level_debug, __FUNCTION__, "saving attribute key=\"%s\" val=\"%s\"",attr->key,attr->val);
139	if (cdb_make_add(&cdbm, attr->key, strlen(attr->key), attr->val, strlen(attr->val))<0)
140	{
141	eventlog(eventlog_level_error, __FUNCTION__, "got error on cdb_make_add ('%s' = '%s')", attr->key, attr->val);
142	cdb_make_finish(&cdbm); /* try to bail out nicely */
143	fclose(cdbfile);
144	return -1;
145	}
146	}
147	} else eventlog(eventlog_level_error, __FUNCTION__,"could not save attribute key=\"%s\"",attr->key);
148
149	}
150
151	if (cdb_make_finish(&cdbm)<0) {
152	eventlog(eventlog_level_error, __FUNCTION__, "got error on cdb_make_finish");
153	fclose(cdbfile);
154	return -1;
155	}
156
157	if (fclose(cdbfile)<0) {
158	eventlog(eventlog_level_error, __FUNCTION__, "got error on fclose()");
159	return -1;
160	}
161
162	return 0;
163	}
164
165	#ifndef CDB_ON_DEMAND
166	/* code adapted from tinycdb-0.73/cdb.c */
167
168	static int fget(FILE * fd, unsigned char b, cdbi_t len, cdbi_t posp, cdbi_t limit)
169	{
170	if (posp && limit - *posp < len) {
171	eventlog(eventlog_level_error, __FUNCTION__, "invalid cdb database format");
172	return -1;
173	}
174
175	if (fread(b, 1, len, fd) != len) {
176	if (ferror(fd)) {
177	eventlog(eventlog_level_error, __FUNCTION__, "got error reading from db file");
178	return -1;
179	}
180	eventlog(eventlog_level_error, __FUNCTION__, "unable to read from cdb file, incomplete file");
181	return -1;
182	}
183
184	if (posp) *posp += len;
185	return 0;
186	}
187
188	static const char * fcpy(FILE fd, cdbi_t len, cdbi_t posp, cdbi_t limit, unsigned char * buf)
189	{
190	static char *str;
191	static unsigned strl;
192	unsigned int res = 0, no = 0;
193
194	if (strl < len + 1) {
195	char *tmp;
196
197	tmp = xmalloc(len + 1);
198	if (str) xfree((void*)str);
199	str = tmp;
200	strl = len + 1;
201	}
202
203	while(len - res > 0) {
204	if (len > 2048) no = 2048;
205	else no = len;
206
207	if (fget(fd, buf, no, posp, limit)) return NULL;
208	memmove(str + res, buf, no);
209	res += no;
210	}
211
212	if (res > strl - 1) {
213	eventlog(eventlog_level_error, __FUNCTION__, "BUG, this should not happen");
214	return NULL;
215	}
216
217	str[res] = '\0';
218	return str;
219	}
220
221	static int cdb_read_attrs(const char filename, t_read_attr_func cb, void data)
222	{
223	cdbi_t eod, klen, vlen;
224	cdbi_t pos = 0;
225	const char *key;
226	const char *val;
227	unsigned char buf[2048];
228	FILE *f;
229
230	if ((f = fopen(filename, "rb")) == NULL) {
231	eventlog(eventlog_level_error, __FUNCTION__, "got error opening file '%s'", filename);
232	return -1;
233	}
234
235	if (fget(f, buf, 2048, &pos, 2048)) goto err_fd;
236	eod = cdb_unpack(buf);
237	while(pos < eod) {
238	if (fget(f, buf, 8, &pos, eod)) goto err_fd;
239	klen = cdb_unpack(buf);
240	vlen = cdb_unpack(buf + 4);
241	if ((key = fcpy(f, klen, &pos, eod, buf)) == NULL) {
242	eventlog(eventlog_level_error, __FUNCTION__, "error reading attribute key");
243	goto err_fd;
244	}
245
246	key = xstrdup(key);
247
248	if ((val = fcpy(f, vlen, &pos, eod, buf)) == NULL) {
249	eventlog(eventlog_level_error, __FUNCTION__, "error reading attribute val");
250	goto err_key;
251	}
252
253	// eventlog(eventlog_level_trace, __FUNCTION__, "read atribute : '%s' -> '%s'", key, val);
254	if (cb(key, val, data))
255	eventlog(eventlog_level_error, __FUNCTION__, "got error from callback on account file '%s'", filename);
256	xfree((void *)key);
257	}
258
259	fclose(f);
260	return 0;
261
262	err_key:
263	xfree((void *)key);
264
265	err_fd:
266	fclose(f);
267	return -1;
268	}
269	#else /* CDB_ON_DEMAND */
270	static int cdb_read_attrs(const char filename, t_read_attr_func cb, void data)
271	{
272	return 0;
273	}
274	#endif
275
276	static void * cdb_read_attr(const char filename, const char key)
277	{
278	#ifdef CDB_ON_DEMAND
279	FILE *cdbfile;
280	t_attribute *attr;
281	char *val;
282	unsigned vlen = 1;
283
284	// eventlog(eventlog_level_trace, __FUNCTION__, "reading key '%s'", key);
285	if ((cdbfile = fopen(filename, "rb")) == NULL) {
286	// eventlog(eventlog_level_debug, __FUNCTION__, "unable to open file \"%s\" for reading ",filename);
287	return NULL;
288	}
289
290	if (cdb_seek(cdbfile, key, strlen(key), &vlen) <= 0) {
291	// eventlog(eventlog_level_debug, __FUNCTION__, "could not find key '%s'", key);
292	fclose(cdbfile);
293	return NULL;
294	}
295
296	attr = xmalloc(sizeof(t_attribute));
297	attr->key = xstrdup(key);
298	val = xmalloc(vlen + 1);
299
300	cdb_bread(cdbfile, val, vlen);
301	fclose(cdbfile);
302
303	val[vlen] = '\0';
304
305	attr->val = val;
306	attr->dirty = 0;
307	// eventlog(eventlog_level_trace, __FUNCTION__, "read key '%s' value '%s'", attr->key, attr->val);
308	return attr;
309	#else
310	return NULL;
311	#endif
312	}
313
webmaster@leafok.com	ViewVC Help
Powered by ViewVC 1.3.0-beta1