Merge from vendor branch TEXINFO:
[dragonfly.git] / contrib / sendmail-8.13.4 / libsmdb / smndbm.c
1 /*
2 ** Copyright (c) 1999-2002 Sendmail, Inc. and its suppliers.
3 **      All rights reserved.
4 **
5 ** By using this file, you agree to the terms and conditions set
6 ** forth in the LICENSE file which can be found at the top level of
7 ** the sendmail distribution.
8 */
9
10 #include <sm/gen.h>
11 SM_RCSID("@(#)$Id: smndbm.c,v 8.52 2002/05/21 22:30:30 gshapiro Exp $")
12
13 #include <fcntl.h>
14 #include <stdlib.h>
15 #include <unistd.h>
16
17 #include <sendmail/sendmail.h>
18 #include <libsmdb/smdb.h>
19
20 #ifdef NDBM
21
22 # define SMNDB_DIR_FILE_EXTENSION "dir"
23 # define SMNDB_PAG_FILE_EXTENSION "pag"
24
25 struct smdb_dbm_database_struct
26 {
27         DBM     *smndbm_dbm;
28         int     smndbm_lock_fd;
29         bool    smndbm_cursor_in_use;
30 };
31 typedef struct smdb_dbm_database_struct SMDB_DBM_DATABASE;
32
33 struct smdb_dbm_cursor_struct
34 {
35         SMDB_DBM_DATABASE       *smndbmc_db;
36         datum                   smndbmc_current_key;
37 };
38 typedef struct smdb_dbm_cursor_struct SMDB_DBM_CURSOR;
39
40 /*
41 **  SMDB_PUT_FLAGS_TO_NDBM_FLAGS -- Translates smdb put flags to ndbm put flags.
42 **
43 **      Parameters:
44 **              flags -- The flags to translate.
45 **
46 **      Returns:
47 **              The ndbm flags that are equivalent to the smdb flags.
48 **
49 **      Notes:
50 **              Any invalid flags are ignored.
51 **
52 */
53
54 int
55 smdb_put_flags_to_ndbm_flags(flags)
56         SMDB_FLAG flags;
57 {
58         int return_flags;
59
60         return_flags = 0;
61         if (bitset(SMDBF_NO_OVERWRITE, flags))
62                 return_flags = DBM_INSERT;
63         else
64                 return_flags = DBM_REPLACE;
65
66         return return_flags;
67 }
68
69 /*
70 **  Except for smdb_ndbm_open, the rest of these function correspond to the
71 **  interface laid out in smdb.h.
72 */
73
74 SMDB_DBM_DATABASE *
75 smdbm_malloc_database()
76 {
77         SMDB_DBM_DATABASE *db;
78
79         db = (SMDB_DBM_DATABASE *) malloc(sizeof(SMDB_DBM_DATABASE));
80         if (db != NULL)
81         {
82                 db->smndbm_dbm = NULL;
83                 db->smndbm_lock_fd = -1;
84                 db->smndbm_cursor_in_use = false;
85         }
86
87         return db;
88 }
89
90 int
91 smdbm_close(database)
92         SMDB_DATABASE *database;
93 {
94         SMDB_DBM_DATABASE *db = (SMDB_DBM_DATABASE *) database->smdb_impl;
95         DBM *dbm = ((SMDB_DBM_DATABASE *) database->smdb_impl)->smndbm_dbm;
96
97         dbm_close(dbm);
98         if (db->smndbm_lock_fd != -1)
99                 close(db->smndbm_lock_fd);
100
101         free(db);
102         database->smdb_impl = NULL;
103
104         return SMDBE_OK;
105 }
106
107 int
108 smdbm_del(database, key, flags)
109         SMDB_DATABASE *database;
110         SMDB_DBENT *key;
111         unsigned int flags;
112 {
113         int result;
114         DBM *dbm = ((SMDB_DBM_DATABASE *) database->smdb_impl)->smndbm_dbm;
115         datum dbkey;
116
117         (void) memset(&dbkey, '\0', sizeof dbkey);
118         dbkey.dptr = key->data;
119         dbkey.dsize = key->size;
120
121         errno = 0;
122         result = dbm_delete(dbm, dbkey);
123         if (result != 0)
124         {
125                 int save_errno = errno;
126
127                 if (dbm_error(dbm))
128                         return SMDBE_IO_ERROR;
129
130                 if (save_errno != 0)
131                         return save_errno;
132
133                 return SMDBE_NOT_FOUND;
134         }
135         return SMDBE_OK;
136 }
137
138 int
139 smdbm_fd(database, fd)
140         SMDB_DATABASE *database;
141         int *fd;
142 {
143         DBM *dbm = ((SMDB_DBM_DATABASE *) database->smdb_impl)->smndbm_dbm;
144
145         *fd = dbm_dirfno(dbm);
146         if (*fd <= 0)
147                 return EINVAL;
148
149         return SMDBE_OK;
150 }
151
152 int
153 smdbm_lockfd(database)
154         SMDB_DATABASE *database;
155 {
156         SMDB_DBM_DATABASE *db = (SMDB_DBM_DATABASE *) database->smdb_impl;
157
158         return db->smndbm_lock_fd;
159 }
160
161 int
162 smdbm_get(database, key, data, flags)
163         SMDB_DATABASE *database;
164         SMDB_DBENT *key;
165         SMDB_DBENT *data;
166         unsigned int flags;
167 {
168         DBM *dbm = ((SMDB_DBM_DATABASE *) database->smdb_impl)->smndbm_dbm;
169         datum dbkey, dbdata;
170
171         (void) memset(&dbkey, '\0', sizeof dbkey);
172         (void) memset(&dbdata, '\0', sizeof dbdata);
173         dbkey.dptr = key->data;
174         dbkey.dsize = key->size;
175
176         errno = 0;
177         dbdata = dbm_fetch(dbm, dbkey);
178         if (dbdata.dptr == NULL)
179         {
180                 int save_errno = errno;
181
182                 if (dbm_error(dbm))
183                         return SMDBE_IO_ERROR;
184
185                 if (save_errno != 0)
186                         return save_errno;
187
188                 return SMDBE_NOT_FOUND;
189         }
190         data->data = dbdata.dptr;
191         data->size = dbdata.dsize;
192         return SMDBE_OK;
193 }
194
195 int
196 smdbm_put(database, key, data, flags)
197         SMDB_DATABASE *database;
198         SMDB_DBENT *key;
199         SMDB_DBENT *data;
200         unsigned int flags;
201 {
202         int result;
203         int save_errno;
204         DBM *dbm = ((SMDB_DBM_DATABASE *) database->smdb_impl)->smndbm_dbm;
205         datum dbkey, dbdata;
206
207         (void) memset(&dbkey, '\0', sizeof dbkey);
208         (void) memset(&dbdata, '\0', sizeof dbdata);
209         dbkey.dptr = key->data;
210         dbkey.dsize = key->size;
211         dbdata.dptr = data->data;
212         dbdata.dsize = data->size;
213
214         errno = 0;
215         result = dbm_store(dbm, dbkey, dbdata,
216                            smdb_put_flags_to_ndbm_flags(flags));
217         switch (result)
218         {
219           case 1:
220                 return SMDBE_DUPLICATE;
221
222           case 0:
223                 return SMDBE_OK;
224
225           default:
226                 save_errno = errno;
227
228                 if (dbm_error(dbm))
229                         return SMDBE_IO_ERROR;
230
231                 if (save_errno != 0)
232                         return save_errno;
233
234                 return SMDBE_IO_ERROR;
235         }
236         /* NOTREACHED */
237 }
238
239 int
240 smndbm_set_owner(database, uid, gid)
241         SMDB_DATABASE *database;
242         uid_t uid;
243         gid_t gid;
244 {
245 # if HASFCHOWN
246         int fd;
247         int result;
248         DBM *dbm = ((SMDB_DBM_DATABASE *) database->smdb_impl)->smndbm_dbm;
249
250         fd = dbm_dirfno(dbm);
251         if (fd <= 0)
252                 return EINVAL;
253
254         result = fchown(fd, uid, gid);
255         if (result < 0)
256                 return errno;
257
258         fd = dbm_pagfno(dbm);
259         if (fd <= 0)
260                 return EINVAL;
261
262         result = fchown(fd, uid, gid);
263         if (result < 0)
264                 return errno;
265 # endif /* HASFCHOWN */
266
267         return SMDBE_OK;
268 }
269
270 int
271 smdbm_sync(database, flags)
272         SMDB_DATABASE *database;
273         unsigned int flags;
274 {
275         return SMDBE_UNSUPPORTED;
276 }
277
278 int
279 smdbm_cursor_close(cursor)
280         SMDB_CURSOR *cursor;
281 {
282         SMDB_DBM_CURSOR *dbm_cursor = (SMDB_DBM_CURSOR *) cursor->smdbc_impl;
283         SMDB_DBM_DATABASE *db = dbm_cursor->smndbmc_db;
284
285         if (!db->smndbm_cursor_in_use)
286                 return SMDBE_NOT_A_VALID_CURSOR;
287
288         db->smndbm_cursor_in_use = false;
289         free(dbm_cursor);
290         free(cursor);
291
292         return SMDBE_OK;
293 }
294
295 int
296 smdbm_cursor_del(cursor, flags)
297         SMDB_CURSOR *cursor;
298         unsigned int flags;
299 {
300         int result;
301         SMDB_DBM_CURSOR *dbm_cursor = (SMDB_DBM_CURSOR *) cursor->smdbc_impl;
302         SMDB_DBM_DATABASE *db = dbm_cursor->smndbmc_db;
303         DBM *dbm = db->smndbm_dbm;
304
305         errno = 0;
306         result = dbm_delete(dbm, dbm_cursor->smndbmc_current_key);
307         if (result != 0)
308         {
309                 int save_errno = errno;
310
311                 if (dbm_error(dbm))
312                         return SMDBE_IO_ERROR;
313
314                 if (save_errno != 0)
315                         return save_errno;
316
317                 return SMDBE_NOT_FOUND;
318         }
319         return SMDBE_OK;
320 }
321
322 int
323 smdbm_cursor_get(cursor, key, value, flags)
324         SMDB_CURSOR *cursor;
325         SMDB_DBENT *key;
326         SMDB_DBENT *value;
327         SMDB_FLAG flags;
328 {
329         SMDB_DBM_CURSOR *dbm_cursor = (SMDB_DBM_CURSOR *) cursor->smdbc_impl;
330         SMDB_DBM_DATABASE *db = dbm_cursor->smndbmc_db;
331         DBM *dbm = db->smndbm_dbm;
332         datum dbkey, dbdata;
333
334         (void) memset(&dbkey, '\0', sizeof dbkey);
335         (void) memset(&dbdata, '\0', sizeof dbdata);
336
337         if (flags == SMDB_CURSOR_GET_RANGE)
338                 return SMDBE_UNSUPPORTED;
339
340         if (dbm_cursor->smndbmc_current_key.dptr == NULL)
341         {
342                 dbm_cursor->smndbmc_current_key = dbm_firstkey(dbm);
343                 if (dbm_cursor->smndbmc_current_key.dptr == NULL)
344                 {
345                         if (dbm_error(dbm))
346                                 return SMDBE_IO_ERROR;
347                         return SMDBE_LAST_ENTRY;
348                 }
349         }
350         else
351         {
352                 dbm_cursor->smndbmc_current_key = dbm_nextkey(dbm);
353                 if (dbm_cursor->smndbmc_current_key.dptr == NULL)
354                 {
355                         if (dbm_error(dbm))
356                                 return SMDBE_IO_ERROR;
357                         return SMDBE_LAST_ENTRY;
358                 }
359         }
360
361         errno = 0;
362         dbdata = dbm_fetch(dbm, dbm_cursor->smndbmc_current_key);
363         if (dbdata.dptr == NULL)
364         {
365                 int save_errno = errno;
366
367                 if (dbm_error(dbm))
368                         return SMDBE_IO_ERROR;
369
370                 if (save_errno != 0)
371                         return save_errno;
372
373                 return SMDBE_NOT_FOUND;
374         }
375         value->data = dbdata.dptr;
376         value->size = dbdata.dsize;
377         key->data = dbm_cursor->smndbmc_current_key.dptr;
378         key->size = dbm_cursor->smndbmc_current_key.dsize;
379
380         return SMDBE_OK;
381 }
382
383 int
384 smdbm_cursor_put(cursor, key, value, flags)
385         SMDB_CURSOR *cursor;
386         SMDB_DBENT *key;
387         SMDB_DBENT *value;
388         SMDB_FLAG flags;
389 {
390         int result;
391         int save_errno;
392         SMDB_DBM_CURSOR *dbm_cursor = (SMDB_DBM_CURSOR *) cursor->smdbc_impl;
393         SMDB_DBM_DATABASE *db = dbm_cursor->smndbmc_db;
394         DBM *dbm = db->smndbm_dbm;
395         datum dbdata;
396
397         (void) memset(&dbdata, '\0', sizeof dbdata);
398         dbdata.dptr = value->data;
399         dbdata.dsize = value->size;
400
401         errno = 0;
402         result = dbm_store(dbm, dbm_cursor->smndbmc_current_key, dbdata,
403                            smdb_put_flags_to_ndbm_flags(flags));
404         switch (result)
405         {
406           case 1:
407                 return SMDBE_DUPLICATE;
408
409           case 0:
410                 return SMDBE_OK;
411
412           default:
413                 save_errno = errno;
414
415                 if (dbm_error(dbm))
416                         return SMDBE_IO_ERROR;
417
418                 if (save_errno != 0)
419                         return save_errno;
420
421                 return SMDBE_IO_ERROR;
422         }
423         /* NOTREACHED */
424 }
425
426 int
427 smdbm_cursor(database, cursor, flags)
428         SMDB_DATABASE *database;
429         SMDB_CURSOR **cursor;
430         SMDB_FLAG flags;
431 {
432         SMDB_DBM_DATABASE *db = (SMDB_DBM_DATABASE *) database->smdb_impl;
433         SMDB_CURSOR *cur;
434         SMDB_DBM_CURSOR *dbm_cursor;
435
436         if (db->smndbm_cursor_in_use)
437                 return SMDBE_ONLY_SUPPORTS_ONE_CURSOR;
438
439         db->smndbm_cursor_in_use = true;
440         dbm_cursor = (SMDB_DBM_CURSOR *) malloc(sizeof(SMDB_DBM_CURSOR));
441         dbm_cursor->smndbmc_db = db;
442         dbm_cursor->smndbmc_current_key.dptr = NULL;
443         dbm_cursor->smndbmc_current_key.dsize = 0;
444
445         cur = (SMDB_CURSOR*) malloc(sizeof(SMDB_CURSOR));
446         if (cur == NULL)
447                 return SMDBE_MALLOC;
448
449         cur->smdbc_impl = dbm_cursor;
450         cur->smdbc_close = smdbm_cursor_close;
451         cur->smdbc_del = smdbm_cursor_del;
452         cur->smdbc_get = smdbm_cursor_get;
453         cur->smdbc_put = smdbm_cursor_put;
454         *cursor = cur;
455
456         return SMDBE_OK;
457 }
458 /*
459 **  SMDB_NDBM_OPEN -- Opens a ndbm database.
460 **
461 **      Parameters:
462 **              database -- An unallocated database pointer to a pointer.
463 **              db_name -- The name of the database without extension.
464 **              mode -- File permisions on a created database.
465 **              mode_mask -- Mode bits that much match on an opened database.
466 **              sff -- Flags to safefile.
467 **              type -- The type of database to open.
468 **                      Only SMDB_NDBM is supported.
469 **              user_info -- Information on the user to use for file
470 **                          permissions.
471 **              db_params -- No params are supported.
472 **
473 **      Returns:
474 **              SMDBE_OK -- Success, otherwise errno:
475 **              SMDBE_MALLOC -- Cannot allocate memory.
476 **              SMDBE_UNSUPPORTED -- The type is not supported.
477 **              SMDBE_GDBM_IS_BAD -- We have detected GDBM and we don't
478 **                                  like it.
479 **              SMDBE_BAD_OPEN -- dbm_open failed and errno was not set.
480 **              Anything else: errno
481 */
482
483 int
484 smdb_ndbm_open(database, db_name, mode, mode_mask, sff, type, user_info,
485                db_params)
486         SMDB_DATABASE **database;
487         char *db_name;
488         int mode;
489         int mode_mask;
490         long sff;
491         SMDB_DBTYPE type;
492         SMDB_USER_INFO *user_info;
493         SMDB_DBPARAMS *db_params;
494 {
495         bool lockcreated = false;
496         int result;
497         int lock_fd;
498         SMDB_DATABASE *smdb_db;
499         SMDB_DBM_DATABASE *db;
500         DBM *dbm = NULL;
501         struct stat dir_stat_info;
502         struct stat pag_stat_info;
503
504         result = SMDBE_OK;
505         *database = NULL;
506
507         if (type == NULL)
508                 return SMDBE_UNKNOWN_DB_TYPE;
509
510         result = smdb_setup_file(db_name, SMNDB_DIR_FILE_EXTENSION, mode_mask,
511                                  sff, user_info, &dir_stat_info);
512         if (result != SMDBE_OK)
513                 return result;
514
515         result = smdb_setup_file(db_name, SMNDB_PAG_FILE_EXTENSION, mode_mask,
516                                  sff, user_info, &pag_stat_info);
517         if (result != SMDBE_OK)
518                 return result;
519
520         if ((dir_stat_info.st_mode == ST_MODE_NOFILE ||
521              pag_stat_info.st_mode == ST_MODE_NOFILE) &&
522             bitset(mode, O_CREAT))
523                 lockcreated = true;
524
525         lock_fd = -1;
526         result = smdb_lock_file(&lock_fd, db_name, mode, sff,
527                                 SMNDB_DIR_FILE_EXTENSION);
528         if (result != SMDBE_OK)
529                 return result;
530
531         if (lockcreated)
532         {
533                 int pag_fd;
534
535                 /* Need to pre-open the .pag file as well with O_EXCL */
536                 result = smdb_lock_file(&pag_fd, db_name, mode, sff,
537                                         SMNDB_PAG_FILE_EXTENSION);
538                 if (result != SMDBE_OK)
539                 {
540                         (void) close(lock_fd);
541                         return result;
542                 }
543                 (void) close(pag_fd);
544
545                 mode |= O_TRUNC;
546                 mode &= ~(O_CREAT|O_EXCL);
547         }
548
549         smdb_db = smdb_malloc_database();
550         if (smdb_db == NULL)
551                 result = SMDBE_MALLOC;
552
553         db = smdbm_malloc_database();
554         if (db == NULL)
555                 result = SMDBE_MALLOC;
556
557         /* Try to open database */
558         if (result == SMDBE_OK)
559         {
560                 db->smndbm_lock_fd = lock_fd;
561
562                 errno = 0;
563                 dbm = dbm_open(db_name, mode, DBMMODE);
564                 if (dbm == NULL)
565                 {
566                         if (errno == 0)
567                                 result = SMDBE_BAD_OPEN;
568                         else
569                                 result = errno;
570                 }
571                 db->smndbm_dbm = dbm;
572         }
573
574         /* Check for GDBM */
575         if (result == SMDBE_OK)
576         {
577                 if (dbm_dirfno(dbm) == dbm_pagfno(dbm))
578                         result = SMDBE_GDBM_IS_BAD;
579         }
580
581         /* Check for filechanged */
582         if (result == SMDBE_OK)
583         {
584                 result = smdb_filechanged(db_name, SMNDB_DIR_FILE_EXTENSION,
585                                           dbm_dirfno(dbm), &dir_stat_info);
586                 if (result == SMDBE_OK)
587                 {
588                         result = smdb_filechanged(db_name,
589                                                   SMNDB_PAG_FILE_EXTENSION,
590                                                   dbm_pagfno(dbm),
591                                                   &pag_stat_info);
592                 }
593         }
594
595         /* XXX Got to get fchown stuff in here */
596
597         /* Setup driver if everything is ok */
598         if (result == SMDBE_OK)
599         {
600                 *database = smdb_db;
601
602                 smdb_db->smdb_close = smdbm_close;
603                 smdb_db->smdb_del = smdbm_del;
604                 smdb_db->smdb_fd = smdbm_fd;
605                 smdb_db->smdb_lockfd = smdbm_lockfd;
606                 smdb_db->smdb_get = smdbm_get;
607                 smdb_db->smdb_put = smdbm_put;
608                 smdb_db->smdb_set_owner = smndbm_set_owner;
609                 smdb_db->smdb_sync = smdbm_sync;
610                 smdb_db->smdb_cursor = smdbm_cursor;
611
612                 smdb_db->smdb_impl = db;
613
614                 return SMDBE_OK;
615         }
616
617         /* If we're here, something bad happened, clean up */
618         if (dbm != NULL)
619                 dbm_close(dbm);
620
621         smdb_unlock_file(db->smndbm_lock_fd);
622         free(db);
623         smdb_free_database(smdb_db);
624
625         return result;
626 }
627 #endif /* NDBM */