4 * GDBM database driver for Citadel/UX
9 * Note that each call to a GDBM function is wrapped in an S_DATABASE critical
10 * section. This is done because GDBM is not threadsafe. This is the ONLY
11 * place in the entire Citadel server where any code enters two different
12 * classes of critical sections at the same time; this is why the GDBM calls
13 * are *tightly* wrapped in S_DATABASE. Opening multiple concurrent critical
14 * sections elsewhere in the code can, and probably will, cause deadlock
15 * conditions to occur. (Deadlock is bad. Eliminate.)
27 #if TIME_WITH_SYS_TIME
28 # include <sys/time.h>
32 # include <sys/time.h>
45 #include "sysdep_decls.h"
49 * This array holds one gdbm handle for each Citadel database.
51 GDBM_FILE gdbms[MAXCDB];
54 * We also keep these around, for sequential searches (one per session slot)
61 * Reclaim unused space in the databases. We need to do each one of
62 * these discretely, rather than in a loop.
64 void defrag_databases(void)
67 /* defrag the message base */
68 lprintf(7, "Defragmenting message base\n");
69 begin_critical_section(S_DATABASE);
70 gdbm_reorganize(gdbms[CDB_MSGMAIN]);
71 end_critical_section(S_DATABASE);
73 /* defrag the user file, mailboxes, and user/room relationships */
74 lprintf(7, "Defragmenting user file\n");
75 begin_critical_section(S_USERSUPP);
76 begin_critical_section(S_DATABASE);
77 gdbm_reorganize(gdbms[CDB_USERSUPP]);
78 gdbm_reorganize(gdbms[CDB_VISIT]);
79 end_critical_section(S_DATABASE);
80 end_critical_section(S_USERSUPP);
82 /* defrag the room files and message lists */
83 lprintf(7, "Defragmenting room files and message lists\n");
84 begin_critical_section(S_QUICKROOM);
85 begin_critical_section(S_DATABASE);
86 gdbm_reorganize(gdbms[CDB_QUICKROOM]);
87 gdbm_reorganize(gdbms[CDB_MSGLISTS]);
88 end_critical_section(S_DATABASE);
89 end_critical_section(S_QUICKROOM);
91 /* defrag the floor table */
92 lprintf(7, "Defragmenting floor table\n");
93 begin_critical_section(S_FLOORTAB);
94 begin_critical_section(S_DATABASE);
95 gdbm_reorganize(gdbms[CDB_FLOORTAB]);
96 end_critical_section(S_DATABASE);
97 end_critical_section(S_FLOORTAB);
99 /* defrag the directory */
100 lprintf(7, "Defragmenting the directory\n");
101 begin_critical_section(S_DIRECTORY);
102 gdbm_reorganize(gdbms[CDB_DIRECTORY]);
103 end_critical_section(S_DIRECTORY);
105 /* defrag the use table */
106 lprintf(7, "Defragmenting the use table\n");
107 gdbm_reorganize(gdbms[CDB_USETABLE]);
112 * Open the various gdbm databases we'll be using. Any database which
113 * does not exist should be created.
115 void open_databases(void)
117 lprintf(7, "%s\n", gdbm_version);
120 * Silently try to create the database subdirectory. If it's
121 * already there, no problem.
123 system("exec mkdir data 2>/dev/null");
125 /* a critical section is unnecessary, as this function is called before
126 any other threads are created. and it causes problems on BSDI.
128 begin_critical_section(S_DATABASE);
132 gdbms[CDB_MSGMAIN] = gdbm_open("data/msgmain.gdbm", 8192,
133 GDBM_WRCREAT, 0600, NULL);
134 if (gdbms[CDB_MSGMAIN] == NULL) {
135 lprintf(2, "Cannot open msgmain: %s\n",
136 gdbm_strerror(gdbm_errno));
139 gdbms[CDB_USERSUPP] = gdbm_open("data/usersupp.gdbm", 0,
140 GDBM_WRCREAT, 0600, NULL);
141 if (gdbms[CDB_USERSUPP] == NULL) {
142 lprintf(2, "Cannot open usersupp: %s\n",
143 gdbm_strerror(gdbm_errno));
146 gdbms[CDB_VISIT] = gdbm_open("data/visit.gdbm", 0,
147 GDBM_WRCREAT, 0600, NULL);
148 if (gdbms[CDB_VISIT] == NULL) {
149 lprintf(2, "Cannot open visit file: %s\n",
150 gdbm_strerror(gdbm_errno));
153 gdbms[CDB_QUICKROOM] = gdbm_open("data/quickroom.gdbm", 0,
154 GDBM_WRCREAT, 0600, NULL);
155 if (gdbms[CDB_QUICKROOM] == NULL) {
156 lprintf(2, "Cannot open quickroom: %s\n",
157 gdbm_strerror(gdbm_errno));
160 gdbms[CDB_FLOORTAB] = gdbm_open("data/floortab.gdbm", 0,
161 GDBM_WRCREAT, 0600, NULL);
162 if (gdbms[CDB_FLOORTAB] == NULL) {
163 lprintf(2, "Cannot open floortab: %s\n",
164 gdbm_strerror(gdbm_errno));
167 gdbms[CDB_MSGLISTS] = gdbm_open("data/msglists.gdbm", 0,
168 GDBM_WRCREAT, 0600, NULL);
169 if (gdbms[CDB_MSGLISTS] == NULL) {
170 lprintf(2, "Cannot open msglists: %s\n",
171 gdbm_strerror(gdbm_errno));
174 gdbms[CDB_DIRECTORY] = gdbm_open("data/directory.gdbm", 0,
175 GDBM_WRCREAT, 0600, NULL);
176 if (gdbms[CDB_DIRECTORY] == NULL) {
177 lprintf(2, "Cannot open directory: %s\n",
178 gdbm_strerror(gdbm_errno));
181 gdbms[CDB_USETABLE] = gdbm_open("data/usetable.gdbm", 0,
182 GDBM_WRCREAT, 0600, NULL);
183 if (gdbms[CDB_USETABLE] == NULL) {
184 lprintf(2, "Cannot open use table: %s\n",
185 gdbm_strerror(gdbm_errno));
190 end_critical_section(S_DATABASE);
197 * Close all of the gdbm database files we've opened. This can be done
198 * in a loop, since it's just a bunch of closes.
200 void close_databases(void)
204 begin_critical_section(S_DATABASE);
205 for (a = 0; a < MAXCDB; ++a) {
206 lprintf(7, "Closing database %d\n", a);
207 gdbm_close(gdbms[a]);
209 end_critical_section(S_DATABASE);
211 for (a = 0; a < max_keys; ++a) {
212 if (dtkey[a].dptr != NULL) {
213 phree(dtkey[a].dptr);
221 * Store a piece of data. Returns 0 if the operation was successful. If a
222 * datum already exists it should be overwritten.
224 int cdb_store(int cdb,
225 void *key, int keylen,
226 void *data, int datalen)
234 ddata.dsize = datalen;
237 begin_critical_section(S_DATABASE);
238 retval = gdbm_store(gdbms[cdb], dkey, ddata, GDBM_REPLACE);
239 end_critical_section(S_DATABASE);
241 lprintf(2, "gdbm error: %s\n", gdbm_strerror(gdbm_errno));
249 * Delete a piece of data. Returns 0 if the operation was successful.
251 int cdb_delete(int cdb, void *key, int keylen)
260 begin_critical_section(S_DATABASE);
261 retval = gdbm_delete(gdbms[cdb], dkey);
262 end_critical_section(S_DATABASE);
271 * Fetch a piece of data. If not found, returns NULL. Otherwise, it returns
272 * a struct cdbdata which it is the caller's responsibility to free later on
273 * using the cdb_free() routine.
275 struct cdbdata *cdb_fetch(int cdb, void *key, int keylen)
278 struct cdbdata *tempcdb;
284 begin_critical_section(S_DATABASE);
285 dret = gdbm_fetch(gdbms[cdb], dkey);
286 end_critical_section(S_DATABASE);
287 if (dret.dptr == NULL) {
290 tempcdb = (struct cdbdata *) mallok(sizeof(struct cdbdata));
291 if (tempcdb == NULL) {
292 lprintf(2, "Cannot allocate memory!\n");
294 tempcdb->len = dret.dsize;
295 tempcdb->ptr = dret.dptr;
301 * Free a cdbdata item (ok, this is really no big deal, but we might need to do
302 * more complex stuff with other database managers in the future).
304 void cdb_free(struct cdbdata *cdb)
310 void cdb_close_cursor(cdb)
312 while (max_keys <= CC->cs_pid) {
316 mallok((sizeof(datum) * max_keys));
319 reallok(dtkey, (sizeof(datum) * max_keys));
321 dtkey[max_keys - 1].dsize = 0;
322 dtkey[max_keys - 1].dptr = NULL;
325 if (dtkey[CC->cs_pid].dptr != NULL) {
326 phree(dtkey[CC->cs_pid].dptr);
328 dtkey[CC->cs_pid].dptr = NULL;
329 dtkey[CC->cs_pid].dsize = 0;
334 * Prepare for a sequential search of an entire database. (In the gdbm model,
335 * we do this by keeping an array dtkey[] of "the next" key for each session
336 * that is open. There is guaranteed to be no more than one traversal in
337 * progress per session at any given time.)
339 void cdb_rewind(int cdb)
342 while (max_keys <= CC->cs_pid) {
346 mallok((sizeof(datum) * max_keys));
349 reallok(dtkey, (sizeof(datum) * max_keys));
351 dtkey[max_keys - 1].dsize = 0;
352 dtkey[max_keys - 1].dptr = NULL;
355 if (dtkey[CC->cs_pid].dptr != NULL) {
356 phree(dtkey[CC->cs_pid].dptr);
358 begin_critical_section(S_DATABASE);
359 dtkey[CC->cs_pid] = gdbm_firstkey(gdbms[cdb]);
360 end_critical_section(S_DATABASE);
365 * Fetch the next item in a sequential search. Returns a pointer to a
366 * cdbdata structure, or NULL if we've hit the end.
368 struct cdbdata *cdb_next_item(int cdb)
371 struct cdbdata *cdbret;
375 if (dtkey[CC->cs_pid].dptr == NULL) { /* end of file */
378 begin_critical_section(S_DATABASE);
379 dret = gdbm_fetch(gdbms[cdb], dtkey[CC->cs_pid]);
380 end_critical_section(S_DATABASE);
381 if (dret.dptr == NULL) { /* bad read */
382 phree(dtkey[CC->cs_pid].dptr);
385 cdbret = (struct cdbdata *) mallok(sizeof(struct cdbdata));
386 cdbret->len = dret.dsize;
387 cdbret->ptr = dret.dptr;
389 ptr = dtkey[CC->cs_pid].dptr;
390 begin_critical_section(S_DATABASE);
391 dtkey[CC->cs_pid] = gdbm_nextkey(gdbms[cdb], dtkey[CC->cs_pid]);
392 end_critical_section(S_DATABASE);
394 if (ptr != NULL) { /* Free the previous key. */
403 * Truncate (delete every record)
405 void cdb_trunc(int cdb) {
408 begin_critical_section(S_DATABASE);
409 key = gdbm_firstkey (gdbms[cdb]);
410 while (key = gdbm_firstkey(gdbms[cdb], key.dptr) {
411 gdbm_delete(gdbms[cdb], key);
413 end_critical_section(S_DATABASE);
419 * empty functions because GDBM doesn't have transaction support
422 void cdb_begin_transaction(void) {
425 void cdb_end_transaction(void) {
428 void cdb_allocate_tsd(void) {
431 void cdb_free_tsd(void) {
434 void cdb_check_handles(void) {