ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/hybrid-ircservices-1/databases.c
(Generate patch)

Comparing hybrid-ircservices-1/databases.c (file contents):
Revision 1208 by michael, Mon Aug 22 18:55:33 2011 UTC vs.
Revision 1209 by michael, Thu Aug 25 19:05:49 2011 UTC

# Line 16 | Line 16
16  
17   /* List of registered tables */
18   typedef struct dbtablenode_ DBTableNode;
19 < struct dbtablenode_ {
20 <    DBTableNode *next, *prev;
21 <    DBTable *table;
22 <    const Module *owner;  /* Which module registered this table? */
23 <    int loaded;           /* Has this table been loaded? */
19 > struct dbtablenode_
20 > {
21 >  DBTableNode *next, *prev;
22 >  DBTable *table;
23 >  const Module *owner;          /* Which module registered this table? */
24 >  int loaded;                   /* Has this table been loaded? */
25   };
26   static DBTableNode *tables = NULL;
27  
# Line 29 | Line 30 | static DBModule *dbmodule = NULL;
30  
31  
32   /* Local routines: */
33 < static int do_unload_module(const Module *module);
33 > static int do_unload_module(const Module * module);
34  
35   /*************************************************************************/
36   /*************************************************************************/
37  
38   /* Initialization/cleanup routines. */
39  
40 < int database_init(int ac, char **av)
40 > int
41 > database_init(int ac, char **av)
42   {
43 <    if (!add_callback(NULL, "unload module", do_unload_module)) {
44 <        log("database_init: add_callback() failed");
45 <        return 0;
46 <    }
47 <    return 1;
43 >  if (!add_callback(NULL, "unload module", do_unload_module))
44 >  {
45 >    log("database_init: add_callback() failed");
46 >    return 0;
47 >  }
48 >  return 1;
49   }
50  
51   /************************************/
52  
53 < void database_cleanup(void)
53 > void
54 > database_cleanup(void)
55   {
56 <    remove_callback(NULL, "unload module", do_unload_module);
56 >  remove_callback(NULL, "unload module", do_unload_module);
57   }
58  
59   /************************************/
60  
61   /* Check for tables that the module forgot to unload. */
62  
63 < static int do_unload_module(const Module *module)
63 > static int
64 > do_unload_module(const Module * module)
65   {
66 <    DBTableNode *t, *t2;
66 >  DBTableNode *t, *t2;
67  
68 <    LIST_FOREACH_SAFE (t, tables, t2) {
69 <        if (t->owner == module) {
70 <            log("database: Module `%s' forgot to unregister table `%s'",
71 <                get_module_name(module), t->table->name);
72 <            unregister_dbtable(t->table);
73 <        }
68 >  LIST_FOREACH_SAFE(t, tables, t2)
69 >  {
70 >    if (t->owner == module)
71 >    {
72 >      log("database: Module `%s' forgot to unregister table `%s'",
73 >          get_module_name(module), t->table->name);
74 >      unregister_dbtable(t->table);
75      }
76 <    return 0;
76 >  }
77 >  return 0;
78   }
79  
80   /*************************************************************************/
# Line 76 | Line 83 | static int do_unload_module(const Module
83   * error.
84   */
85  
86 < int _register_dbtable(DBTable *table, const Module *caller)
86 > int
87 > _register_dbtable(DBTable * table, const Module * caller)
88   {
89 <    DBTableNode *t;
82 <
83 <    /* Sanity checks on parameter */
84 <    if (!table) {
85 <        log("BUG: register_dbtable() with NULL table!");
86 <        return 0;
87 <    }
88 <    if (!table->name) {
89 <        log("BUG: register_dbtable(): table->name is NULL!");
90 <        return 0;
91 <    }
92 <    if (!table->fields || !table->newrec || !table->freerec
93 <     || !table->insert || !table->first || !table->next
94 <    ) {
95 <        log("BUG: register_dbtable(%s): table->%s is NULL!", table->name,
96 <            !table->fields  ? "fields"  :
97 <            !table->newrec  ? "newrec"  :
98 <            !table->freerec ? "freerec" :
99 <            !table->insert  ? "insert"  :
100 <            !table->first   ? "first"   :
101 <            !table->next    ? "next"    :
102 <                              "???");
103 <        return 0;
104 <    }
89 >  DBTableNode *t;
90  
91 <    /* Sanity check: make sure it's not already registered */
92 <    LIST_FOREACH (t, tables) {
93 <        if (t->table == table) {
94 <            log("BUG: register_dbtable(%s): table already registered!",
95 <                table->name);
96 <            break;
97 <        }
98 <    }
91 >  /* Sanity checks on parameter */
92 >  if (!table)
93 >  {
94 >    log("BUG: register_dbtable() with NULL table!");
95 >    return 0;
96 >  }
97 >  if (!table->name)
98 >  {
99 >    log("BUG: register_dbtable(): table->name is NULL!");
100 >    return 0;
101 >  }
102 >  if (!table->fields || !table->newrec || !table->freerec
103 >      || !table->insert || !table->first || !table->next)
104 >  {
105 >    log("BUG: register_dbtable(%s): table->%s is NULL!", table->name,
106 >        !table->fields ? "fields" :
107 >        !table->newrec ? "newrec" :
108 >        !table->freerec ? "freerec" :
109 >        !table->insert ? "insert" :
110 >        !table->first ? "first" : !table->next ? "next" : "???");
111 >    return 0;
112 >  }
113  
114 <    /* Allocate and append to list (make sure to preserve order, since
115 <     * later tables may depend on earlier ones); if a database module is
116 <     * available, load the table ammediately*/
117 <    t = smalloc(sizeof(*t));
118 <    t->table = table;
119 <    t->owner = caller;
120 <    t->loaded = 0;
121 <    LIST_APPEND(t, tables);
122 <    if (dbmodule)
123 <        t->loaded = (*dbmodule->load_table)(t->table);
114 >  /* Sanity check: make sure it's not already registered */
115 >  LIST_FOREACH(t, tables)
116 >  {
117 >    if (t->table == table)
118 >    {
119 >      log("BUG: register_dbtable(%s): table already registered!",
120 >          table->name);
121 >      break;
122 >    }
123 >  }
124 >
125 >  /* Allocate and append to list (make sure to preserve order, since
126 >   * later tables may depend on earlier ones); if a database module is
127 >   * available, load the table ammediately*/
128 >  t = smalloc(sizeof(*t));
129 >  t->table = table;
130 >  t->owner = caller;
131 >  t->loaded = 0;
132 >  LIST_APPEND(t, tables);
133 >  if (dbmodule)
134 >    t->loaded = (*dbmodule->load_table) (t->table);
135  
136 <    return 1;
136 >  return 1;
137   }
138  
139   /*************************************************************************/
# Line 132 | Line 142 | int _register_dbtable(DBTable *table, co
142   * registered in the first place.
143   */
144  
145 < void unregister_dbtable(DBTable *table)
145 > void
146 > unregister_dbtable(DBTable * table)
147   {
148 <    DBTableNode *t;
148 >  DBTableNode *t;
149  
150 <    if (!table) {
151 <        log("BUG: unregister_dbtable() with NULL table!");
152 <        return;
153 <    }
154 <    /* Sanity check: make sure it was registered first */
155 <    LIST_FOREACH (t, tables) {
156 <        if (t->table == table) {
157 <            LIST_REMOVE(t, tables);
158 <            free(t);
159 <            break;
160 <        }
150 >  if (!table)
151 >  {
152 >    log("BUG: unregister_dbtable() with NULL table!");
153 >    return;
154 >  }
155 >  /* Sanity check: make sure it was registered first */
156 >  LIST_FOREACH(t, tables)
157 >  {
158 >    if (t->table == table)
159 >    {
160 >      LIST_REMOVE(t, tables);
161 >      free(t);
162 >      break;
163      }
164 +  }
165   }
166  
167   /*************************************************************************/
# Line 158 | Line 172 | void unregister_dbtable(DBTable *table)
172   * tables were successfully saved.
173   */
174  
175 < int save_all_dbtables(void)
175 > int
176 > save_all_dbtables(void)
177   {
178 <    DBTableNode *t;
179 <    int some_saved = 0;
180 <    int some_failed = 0;
181 <
182 <    if (!tables)
183 <        return 1;
184 <    if (!dbmodule) {
185 <        log("save_all_dbtables(): No database module registered!");
186 <        return -1;
187 <    }
188 <    LIST_FOREACH (t, tables) {
189 <        if ((*dbmodule->save_table)(t->table)) {
190 <            some_saved = 1;
191 <        } else {
192 <            log("save_all_dbtables(): Failed to save table `%s'",
193 <                t->table->name);
194 <            some_failed = 1;
195 <        }
178 >  DBTableNode *t;
179 >  int some_saved = 0;
180 >  int some_failed = 0;
181 >
182 >  if (!tables)
183 >    return 1;
184 >  if (!dbmodule)
185 >  {
186 >    log("save_all_dbtables(): No database module registered!");
187 >    return -1;
188 >  }
189 >  LIST_FOREACH(t, tables)
190 >  {
191 >    if ((*dbmodule->save_table) (t->table))
192 >    {
193 >      some_saved = 1;
194 >    }
195 >    else
196 >    {
197 >      log("save_all_dbtables(): Failed to save table `%s'", t->table->name);
198 >      some_failed = 1;
199      }
200 <    return some_saved - some_failed;
200 >  }
201 >  return some_saved - some_failed;
202   }
203  
204   /*************************************************************************/
# Line 191 | Line 210 | int save_all_dbtables(void)
210   * registered.
211   */
212  
213 < int register_dbmodule(DBModule *module)
213 > int
214 > register_dbmodule(DBModule * module)
215   {
216 <    DBTableNode *t;
216 >  DBTableNode *t;
217  
218 <    if (!module) {
219 <        log("BUG: register_dbmodule() with NULL module!");
220 <        return 0;
221 <    }
222 <    if (!module->load_table || !module->save_table) {
223 <        log("BUG: register_dbmodule(): module->%s is NULL!",
224 <            !module->load_table ? "load_table" : "save_table");
225 <        return 0;
226 <    }
227 <    if (dbmodule) {
228 <        if (module == dbmodule)
229 <            log("BUG: register_dbmodule(): attempt to re-register module!");
230 <        else
231 <            log("register_dbmodule(): a database module is already registered");
232 <        return 0;
233 <    }
218 >  if (!module)
219 >  {
220 >    log("BUG: register_dbmodule() with NULL module!");
221 >    return 0;
222 >  }
223 >  if (!module->load_table || !module->save_table)
224 >  {
225 >    log("BUG: register_dbmodule(): module->%s is NULL!",
226 >        !module->load_table ? "load_table" : "save_table");
227 >    return 0;
228 >  }
229 >  if (dbmodule)
230 >  {
231 >    if (module == dbmodule)
232 >      log("BUG: register_dbmodule(): attempt to re-register module!");
233 >    else
234 >      log("register_dbmodule(): a database module is already registered");
235 >    return 0;
236 >  }
237  
238 <    dbmodule = module;
239 <    LIST_FOREACH (t, tables) {
240 <        if (!t->loaded)
241 <            t->loaded = (*dbmodule->load_table)(t->table);
242 <    }
243 <    return 1;
238 >  dbmodule = module;
239 >  LIST_FOREACH(t, tables)
240 >  {
241 >    if (!t->loaded)
242 >      t->loaded = (*dbmodule->load_table) (t->table);
243 >  }
244 >  return 1;
245   }
246  
247   /*************************************************************************/
# Line 226 | Line 250 | int register_dbmodule(DBModule *module)
250   * registered in the first place.
251   */
252  
253 < void unregister_dbmodule(DBModule *module)
253 > void
254 > unregister_dbmodule(DBModule * module)
255   {
256 <    if (!module) {
257 <        log("BUG: unregister_dbmodule() with NULL module!");
258 <        return;
259 <    }
260 <    if (dbmodule == module)
261 <        dbmodule = NULL;
256 >  if (!module)
257 >  {
258 >    log("BUG: unregister_dbmodule() with NULL module!");
259 >    return;
260 >  }
261 >  if (dbmodule == module)
262 >    dbmodule = NULL;
263   }
264  
265   /*************************************************************************/
# Line 242 | Line 268 | void unregister_dbmodule(DBModule *modul
268   * large enough to hold the retrieved value.
269   */
270  
271 < void get_dbfield(const void *record, const DBField *field, void *buffer)
271 > void
272 > get_dbfield(const void *record, const DBField * field, void *buffer)
273   {
274 <    int size;
274 >  int size;
275  
276 <    if (!record || !field || !buffer) {
277 <        log("BUG: get_dbfield(): %s is NULL!",
278 <            !record ? "record" : !field ? "field" : "buffer");
279 <        return;
280 <    }
281 <    if (field->get) {
282 <        (*field->get)(record, buffer);
283 <        return;
284 <    }
285 <    switch (field->type) {
286 <        case DBTYPE_INT8:     size = 1;                break;
287 <        case DBTYPE_UINT8:    size = 1;                break;
288 <        case DBTYPE_INT16:    size = 2;                break;
289 <        case DBTYPE_UINT16:   size = 2;                break;
290 <        case DBTYPE_INT32:    size = 4;                break;
291 <        case DBTYPE_UINT32:   size = 4;                break;
292 <        case DBTYPE_TIME:     size = sizeof(time_t);   break;
293 <        case DBTYPE_STRING:   size = sizeof(char *);   break;
294 <        case DBTYPE_BUFFER:   size = field->length;    break;
295 <        case DBTYPE_PASSWORD: size = sizeof(Password); break;
296 <        default:
297 <            log("BUG: bad field type %d in get_dbfield()", field->type);
298 <            return;
299 <    }
300 <    if (!size) {
301 <        return;
302 <    }
303 <    memcpy(buffer, (const uint8 *)record + field->offset, size);
276 >  if (!record || !field || !buffer)
277 >  {
278 >    log("BUG: get_dbfield(): %s is NULL!",
279 >        !record ? "record" : !field ? "field" : "buffer");
280 >    return;
281 >  }
282 >  if (field->get)
283 >  {
284 >    (*field->get) (record, buffer);
285 >    return;
286 >  }
287 >  switch (field->type)
288 >  {
289 >  case DBTYPE_INT8:
290 >    size = 1;
291 >    break;
292 >  case DBTYPE_UINT8:
293 >    size = 1;
294 >    break;
295 >  case DBTYPE_INT16:
296 >    size = 2;
297 >    break;
298 >  case DBTYPE_UINT16:
299 >    size = 2;
300 >    break;
301 >  case DBTYPE_INT32:
302 >    size = 4;
303 >    break;
304 >  case DBTYPE_UINT32:
305 >    size = 4;
306 >    break;
307 >  case DBTYPE_TIME:
308 >    size = sizeof(time_t);
309 >    break;
310 >  case DBTYPE_STRING:
311 >    size = sizeof(char *);
312 >    break;
313 >  case DBTYPE_BUFFER:
314 >    size = field->length;
315 >    break;
316 >  case DBTYPE_PASSWORD:
317 >    size = sizeof(Password);
318 >    break;
319 >  default:
320 >    log("BUG: bad field type %d in get_dbfield()", field->type);
321 >    return;
322 >  }
323 >  if (!size)
324 >  {
325 >    return;
326 >  }
327 >  memcpy(buffer, (const uint8 *) record + field->offset, size);
328   }
329  
330   /*************************************************************************/
331  
332   /* Store a value to a database field. */
333  
334 < void put_dbfield(void *record, const DBField *field, const void *value)
334 > void
335 > put_dbfield(void *record, const DBField * field, const void *value)
336   {
337 <    int size;
337 >  int size;
338  
339 <    if (!record || !field || !value) {
340 <        log("BUG: get_dbfield(): %s is NULL!",
341 <            !record ? "record" : !field ? "field" : "value");
342 <        return;
343 <    }
344 <    if (field->put) {
345 <        (*field->put)(record, value);
346 <        return;
347 <    }
348 <    switch (field->type) {
349 <        case DBTYPE_INT8:     size = 1;                break;
350 <        case DBTYPE_UINT8:    size = 1;                break;
351 <        case DBTYPE_INT16:    size = 2;                break;
352 <        case DBTYPE_UINT16:   size = 2;                break;
353 <        case DBTYPE_INT32:    size = 4;                break;
354 <        case DBTYPE_UINT32:   size = 4;                break;
355 <        case DBTYPE_TIME:     size = sizeof(time_t);   break;
356 <        case DBTYPE_STRING:   size = sizeof(char *);   break;
357 <        case DBTYPE_BUFFER:   size = field->length;    break;
358 <        case DBTYPE_PASSWORD: size = sizeof(Password); break;
359 <        default:
360 <            log("BUG: bad field type %d in get_dbfield()", field->type);
361 <            return;
362 <    }
363 <    if (!size) {
364 <        return;
365 <    }
366 <    memcpy((uint8 *)record + field->offset, value, size);
339 >  if (!record || !field || !value)
340 >  {
341 >    log("BUG: get_dbfield(): %s is NULL!",
342 >        !record ? "record" : !field ? "field" : "value");
343 >    return;
344 >  }
345 >  if (field->put)
346 >  {
347 >    (*field->put) (record, value);
348 >    return;
349 >  }
350 >  switch (field->type)
351 >  {
352 >  case DBTYPE_INT8:
353 >    size = 1;
354 >    break;
355 >  case DBTYPE_UINT8:
356 >    size = 1;
357 >    break;
358 >  case DBTYPE_INT16:
359 >    size = 2;
360 >    break;
361 >  case DBTYPE_UINT16:
362 >    size = 2;
363 >    break;
364 >  case DBTYPE_INT32:
365 >    size = 4;
366 >    break;
367 >  case DBTYPE_UINT32:
368 >    size = 4;
369 >    break;
370 >  case DBTYPE_TIME:
371 >    size = sizeof(time_t);
372 >    break;
373 >  case DBTYPE_STRING:
374 >    size = sizeof(char *);
375 >    break;
376 >  case DBTYPE_BUFFER:
377 >    size = field->length;
378 >    break;
379 >  case DBTYPE_PASSWORD:
380 >    size = sizeof(Password);
381 >    break;
382 >  default:
383 >    log("BUG: bad field type %d in get_dbfield()", field->type);
384 >    return;
385 >  }
386 >  if (!size)
387 >  {
388 >    return;
389 >  }
390 >  memcpy((uint8 *) record + field->offset, value, size);
391   }
392  
393   /*************************************************************************/

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines