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.
22 * This array holds one gdbm handle for each Citadel database.
24 GDBM_FILE gdbms[MAXCDB];
27 * We also keep these around, for sequential searches... (one per
28 * session. Maybe there's a better way?)
35 * Reclaim unused space in the databases. We need to do each one of
36 * these discretely, rather than in a loop.
38 void defrag_databases() {
40 /* defrag the message base */
41 begin_critical_section(S_MSGMAIN);
42 gdbm_reorganize(gdbms[CDB_MSGMAIN]);
43 end_critical_section(S_MSGMAIN);
45 /* defrag the user file */
46 begin_critical_section(S_USERSUPP);
47 gdbm_reorganize(gdbms[CDB_USERSUPP]);
48 end_critical_section(S_USERSUPP);
50 /* defrag the room files */
51 begin_critical_section(S_QUICKROOM);
52 gdbm_reorganize(gdbms[CDB_QUICKROOM]);
53 gdbm_reorganize(gdbms[CDB_FULLROOM]);
54 end_critical_section(S_QUICKROOM);
56 /* defrag the floor table */
57 begin_critical_section(S_FLOORTAB);
58 gdbm_reorganize(gdbms[CDB_FLOORTAB]);
59 end_critical_section(S_FLOORTAB);
64 * Open the various gdbm databases we'll be using. Any database which
65 * does not exist should be created.
67 void open_databases() {
70 gdbms[CDB_MSGMAIN] = gdbm_open("msgmain.gdbm", 8192,
71 GDBM_WRCREAT, 0700, NULL);
72 if (gdbms[CDB_MSGMAIN] == NULL) {
73 lprintf(2, "Cannot open msgmain: %s\n",
74 gdbm_strerror(gdbm_errno));
77 gdbms[CDB_USERSUPP] = gdbm_open("usersupp.gdbm", 0,
78 GDBM_WRCREAT, 0700, NULL);
79 if (gdbms[CDB_USERSUPP] == NULL) {
80 lprintf(2, "Cannot open usersupp: %s\n",
81 gdbm_strerror(gdbm_errno));
84 gdbms[CDB_QUICKROOM] = gdbm_open("quickroom.gdbm", 0,
85 GDBM_WRCREAT, 0700, NULL);
86 if (gdbms[CDB_QUICKROOM] == NULL) {
87 lprintf(2, "Cannot open quickroom: %s\n",
88 gdbm_strerror(gdbm_errno));
91 gdbms[CDB_FULLROOM] = gdbm_open("fullroom.gdbm", 0,
92 GDBM_WRCREAT, 0700, NULL);
93 if (gdbms[CDB_FULLROOM] == NULL) {
94 lprintf(2, "Cannot open fullroom: %s\n",
95 gdbm_strerror(gdbm_errno));
98 gdbms[CDB_FLOORTAB] = gdbm_open("floortab.gdbm", 0,
99 GDBM_WRCREAT, 0700, NULL);
100 if (gdbms[CDB_FLOORTAB] == NULL) {
101 lprintf(2, "Cannot open floortab: %s\n",
102 gdbm_strerror(gdbm_errno));
105 for (a=0; a<MAXKEYS; ++a) {
107 dtkey[a].dptr = NULL;
115 * Close all of the gdbm database files we've opened. This can be done
116 * in a loop, since it's just a bunch of closes.
118 void close_databases() {
122 for (a=0; a<MAXCDB; ++a) {
123 lprintf(7, "Closing database %d\n", a);
124 gdbm_close(gdbms[a]);
127 for (a=0; a<MAXKEYS; ++a) {
128 if (dtkey[a].dptr != NULL) {
137 * Store a piece of data. Returns 0 if the operation was successful. If a
138 * datum already exists it should be overwritten.
140 int cdb_store(int cdb,
141 char *key, int keylen,
142 char *data, int datalen) {
148 ddata.dsize = datalen;
151 if ( gdbm_store(gdbms[cdb], dkey, ddata, GDBM_REPLACE) < 0 ) {
152 lprintf(2, "gdbm error: %s\n", gdbm_strerror(gdbm_errno));
161 * Delete a piece of data. Returns 0 if the operation was successful.
163 int cdb_delete(int cdb, char *key, int keylen) {
170 return(gdbm_delete(gdbms[cdb], dkey));
178 * Fetch a piece of data. If not found, returns NULL. Otherwise, it returns
179 * a struct cdbdata which it is the caller's responsibility to free later on
180 * using the cdb_free() routine.
182 struct cdbdata *cdb_fetch(int cdb, char *key, int keylen) {
184 struct cdbdata *tempcdb;
190 dret = gdbm_fetch(gdbms[cdb], dkey);
191 if (dret.dptr == NULL) {
195 tempcdb = (struct cdbdata *) malloc(sizeof(struct cdbdata));
196 if (tempcdb == NULL) {
197 lprintf(2, "Cannot allocate memory!\n");
200 tempcdb->len = dret.dsize;
201 tempcdb->ptr = dret.dptr;
207 * Free a cdbdata item (ok, this is really no big deal, but we might need to do
208 * more complex stuff with other database managers in the future).
210 void cdb_free(struct cdbdata *cdb) {
217 * Prepare for a sequential search of an entire database. (In the gdbm model,
218 * we do this by keeping an array dtkey[] of "the next" key for each session
219 * that is open. There is guaranteed to be no more than one traversal in
220 * progress per session at any given time.)
222 void cdb_rewind(int cdb) {
224 if (dtkey[CC->cs_pid].dptr != NULL) {
225 free(dtkey[CC->cs_pid].dptr);
228 dtkey[CC->cs_pid] = gdbm_firstkey(gdbms[cdb]);
233 * Fetch the next item in a sequential search. Returns a pointer to a
234 * cdbdata structure, or NULL if we've hit the end.
236 struct cdbdata *cdb_next_item(int cdb) {
238 struct cdbdata *cdbret;
241 if (dtkey[CC->cs_pid].dptr == NULL) { /* end of file */
245 dret = gdbm_fetch(gdbms[cdb], dtkey[CC->cs_pid]);
246 if (dret.dptr == NULL) { /* bad read */
247 free(dtkey[CC->cs_pid].dptr);
251 cdbret = (struct cdbdata *) malloc(sizeof(struct cdbdata));
252 cdbret->len = dret.dsize;
253 cdbret->ptr = dret.dptr;
255 dtkey[CC->cs_pid] = gdbm_nextkey(gdbms[cdb], dtkey[CC->cs_pid]);