2 * This file contains a set of abstractions that allow Citadel to plug into any
3 * record manager or database system for its data store.
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.)
30 #include "sysdep_decls.h"
34 * This array holds one gdbm handle for each Citadel database.
36 GDBM_FILE gdbms[MAXCDB];
39 * We also keep these around, for sequential searches... (one per
40 * session. Maybe there's a better way?)
47 * Reclaim unused space in the databases. We need to do each one of
48 * these discretely, rather than in a loop.
50 void defrag_databases(void) {
52 /* defrag the message base */
53 begin_critical_section(S_MSGMAIN);
54 begin_critical_section(S_DATABASE);
55 gdbm_reorganize(gdbms[CDB_MSGMAIN]);
56 end_critical_section(S_DATABASE);
57 end_critical_section(S_MSGMAIN);
59 /* defrag the user file, mailboxes, and user/room relationships */
60 begin_critical_section(S_USERSUPP);
61 begin_critical_section(S_DATABASE);
62 gdbm_reorganize(gdbms[CDB_USERSUPP]);
63 gdbm_reorganize(gdbms[CDB_VISIT]);
64 end_critical_section(S_DATABASE);
65 end_critical_section(S_USERSUPP);
67 /* defrag the room files and message lists */
68 begin_critical_section(S_QUICKROOM);
69 begin_critical_section(S_DATABASE);
70 gdbm_reorganize(gdbms[CDB_QUICKROOM]);
71 gdbm_reorganize(gdbms[CDB_MSGLISTS]);
72 end_critical_section(S_DATABASE);
73 end_critical_section(S_QUICKROOM);
75 /* defrag the floor table */
76 begin_critical_section(S_FLOORTAB);
77 begin_critical_section(S_DATABASE);
78 gdbm_reorganize(gdbms[CDB_FLOORTAB]);
79 end_critical_section(S_DATABASE);
80 end_critical_section(S_FLOORTAB);
85 * Open the various gdbm databases we'll be using. Any database which
86 * does not exist should be created.
88 void open_databases(void) {
92 * Silently try to create the database subdirectory. If it's
93 * already there, no problem.
95 system("exec mkdir data 2>/dev/null");
97 begin_critical_section(S_DATABASE);
99 gdbms[CDB_MSGMAIN] = gdbm_open("data/msgmain.gdbm", 8192,
100 GDBM_WRCREAT, 0600, NULL);
101 if (gdbms[CDB_MSGMAIN] == NULL) {
102 lprintf(2, "Cannot open msgmain: %s\n",
103 gdbm_strerror(gdbm_errno));
106 gdbms[CDB_USERSUPP] = gdbm_open("data/usersupp.gdbm", 0,
107 GDBM_WRCREAT, 0600, NULL);
108 if (gdbms[CDB_USERSUPP] == NULL) {
109 lprintf(2, "Cannot open usersupp: %s\n",
110 gdbm_strerror(gdbm_errno));
113 gdbms[CDB_VISIT] = gdbm_open("data/visit.gdbm", 0,
114 GDBM_WRCREAT, 0600, NULL);
115 if (gdbms[CDB_VISIT] == NULL) {
116 lprintf(2, "Cannot open visit file: %s\n",
117 gdbm_strerror(gdbm_errno));
120 gdbms[CDB_QUICKROOM] = gdbm_open("data/quickroom.gdbm", 0,
121 GDBM_WRCREAT, 0600, NULL);
122 if (gdbms[CDB_QUICKROOM] == NULL) {
123 lprintf(2, "Cannot open quickroom: %s\n",
124 gdbm_strerror(gdbm_errno));
127 gdbms[CDB_FLOORTAB] = gdbm_open("data/floortab.gdbm", 0,
128 GDBM_WRCREAT, 0600, NULL);
129 if (gdbms[CDB_FLOORTAB] == NULL) {
130 lprintf(2, "Cannot open floortab: %s\n",
131 gdbm_strerror(gdbm_errno));
134 gdbms[CDB_MSGLISTS] = gdbm_open("data/msglists.gdbm", 0,
135 GDBM_WRCREAT, 0600, NULL);
136 if (gdbms[CDB_MSGLISTS] == NULL) {
137 lprintf(2, "Cannot open msglists: %s\n",
138 gdbm_strerror(gdbm_errno));
141 for (a=0; a<MAXKEYS; ++a) {
143 dtkey[a].dptr = NULL;
146 end_critical_section(S_DATABASE);
152 * Close all of the gdbm database files we've opened. This can be done
153 * in a loop, since it's just a bunch of closes.
155 void close_databases(void) {
158 /* Hmm... we should decide when would be a good time to defrag.
159 * Server shutdowns might be an opportune time.
163 begin_critical_section(S_DATABASE);
164 for (a=0; a<MAXCDB; ++a) {
165 lprintf(7, "Closing database %d\n", a);
166 gdbm_close(gdbms[a]);
168 end_critical_section(S_DATABASE);
170 for (a=0; a<MAXKEYS; ++a) {
171 if (dtkey[a].dptr != NULL) {
180 * Store a piece of data. Returns 0 if the operation was successful. If a
181 * datum already exists it should be overwritten.
183 int cdb_store(int cdb,
184 void *key, int keylen,
185 void *data, int datalen) {
192 ddata.dsize = datalen;
195 begin_critical_section(S_DATABASE);
196 retval = gdbm_store(gdbms[cdb], dkey, ddata, GDBM_REPLACE);
197 end_critical_section(S_DATABASE);
199 lprintf(2, "gdbm error: %s\n", gdbm_strerror(gdbm_errno));
208 * Delete a piece of data. Returns 0 if the operation was successful.
210 int cdb_delete(int cdb, void *key, int keylen) {
218 begin_critical_section(S_DATABASE);
219 retval = gdbm_delete(gdbms[cdb], dkey);
220 end_critical_section(S_DATABASE);
229 * Fetch a piece of data. If not found, returns NULL. Otherwise, it returns
230 * a struct cdbdata which it is the caller's responsibility to free later on
231 * using the cdb_free() routine.
233 struct cdbdata *cdb_fetch(int cdb, void *key, int keylen) {
235 struct cdbdata *tempcdb;
241 begin_critical_section(S_DATABASE);
242 dret = gdbm_fetch(gdbms[cdb], dkey);
243 end_critical_section(S_DATABASE);
244 if (dret.dptr == NULL) {
248 tempcdb = (struct cdbdata *) malloc(sizeof(struct cdbdata));
249 if (tempcdb == NULL) {
250 lprintf(2, "Cannot allocate memory!\n");
253 tempcdb->len = dret.dsize;
254 tempcdb->ptr = dret.dptr;
260 * Free a cdbdata item (ok, this is really no big deal, but we might need to do
261 * more complex stuff with other database managers in the future).
263 void cdb_free(struct cdbdata *cdb) {
270 * Prepare for a sequential search of an entire database. (In the gdbm model,
271 * we do this by keeping an array dtkey[] of "the next" key for each session
272 * that is open. There is guaranteed to be no more than one traversal in
273 * progress per session at any given time.)
275 void cdb_rewind(int cdb) {
277 if (dtkey[CC->cs_pid].dptr != NULL) {
278 free(dtkey[CC->cs_pid].dptr);
281 begin_critical_section(S_DATABASE);
282 dtkey[CC->cs_pid] = gdbm_firstkey(gdbms[cdb]);
283 end_critical_section(S_DATABASE);
288 * Fetch the next item in a sequential search. Returns a pointer to a
289 * cdbdata structure, or NULL if we've hit the end.
291 struct cdbdata *cdb_next_item(int cdb) {
293 struct cdbdata *cdbret;
296 if (dtkey[CC->cs_pid].dptr == NULL) { /* end of file */
300 begin_critical_section(S_DATABASE);
301 dret = gdbm_fetch(gdbms[cdb], dtkey[CC->cs_pid]);
302 end_critical_section(S_DATABASE);
303 if (dret.dptr == NULL) { /* bad read */
304 free(dtkey[CC->cs_pid].dptr);
308 cdbret = (struct cdbdata *) malloc(sizeof(struct cdbdata));
309 cdbret->len = dret.dsize;
310 cdbret->ptr = dret.dptr;
312 begin_critical_section(S_DATABASE);
313 dtkey[CC->cs_pid] = gdbm_nextkey(gdbms[cdb], dtkey[CC->cs_pid]);
314 end_critical_section(S_DATABASE);