Merge from vendor branch LIBSTDC++:
[dragonfly.git] / contrib / sendmail / libsmdb / smdb.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: smdb.c,v 8.57 2002/05/24 23:09:11 gshapiro Exp $")
12
13 #include <fcntl.h>
14 #include <stdlib.h>
15 #include <unistd.h>
16
17
18 #include <sendmail/sendmail.h>
19 #include <libsmdb/smdb.h>
20
21 /*
22 ** SMDB_MALLOC_DATABASE -- Allocates a database structure.
23 **
24 **      Parameters:
25 **              None
26 **
27 **      Returns:
28 **              An pointer to an allocated SMDB_DATABASE structure or
29 **              NULL if it couldn't allocate the memory.
30 */
31
32 SMDB_DATABASE *
33 smdb_malloc_database()
34 {
35         SMDB_DATABASE *db;
36
37         db = (SMDB_DATABASE *) malloc(sizeof(SMDB_DATABASE));
38
39         if (db != NULL)
40                 (void) memset(db, '\0', sizeof(SMDB_DATABASE));
41
42         return db;
43 }
44
45
46 /*
47 ** SMDB_FREE_DATABASE -- Unallocates a database structure.
48 **
49 **      Parameters:
50 **              database -- a SMDB_DATABASE pointer to deallocate.
51 **
52 **      Returns:
53 **              None
54 */
55
56 void
57 smdb_free_database(database)
58         SMDB_DATABASE *database;
59 {
60         if (database != NULL)
61                 free(database);
62 }
63 /*
64 **  SMDB_LOCKFILE -- lock a file using flock or (shudder) fcntl locking
65 **
66 **      Parameters:
67 **              fd -- the file descriptor of the file.
68 **              type -- type of the lock.  Bits can be:
69 **                      LOCK_EX -- exclusive lock.
70 **                      LOCK_NB -- non-blocking.
71 **
72 **      Returns:
73 **              true if the lock was acquired.
74 **              false otherwise.
75 */
76
77 static bool
78 smdb_lockfile(fd, type)
79         int fd;
80         int type;
81 {
82         int i;
83         int save_errno;
84 #if !HASFLOCK
85         int action;
86         struct flock lfd;
87
88         (void) memset(&lfd, '\0', sizeof lfd);
89         if (bitset(LOCK_UN, type))
90                 lfd.l_type = F_UNLCK;
91         else if (bitset(LOCK_EX, type))
92                 lfd.l_type = F_WRLCK;
93         else
94                 lfd.l_type = F_RDLCK;
95
96         if (bitset(LOCK_NB, type))
97                 action = F_SETLK;
98         else
99                 action = F_SETLKW;
100
101         while ((i = fcntl(fd, action, &lfd)) < 0 && errno == EINTR)
102                 continue;
103         if (i >= 0)
104                 return true;
105         save_errno = errno;
106
107         /*
108         **  On SunOS, if you are testing using -oQ/tmp/mqueue or
109         **  -oA/tmp/aliases or anything like that, and /tmp is mounted
110         **  as type "tmp" (that is, served from swap space), the
111         **  previous fcntl will fail with "Invalid argument" errors.
112         **  Since this is fairly common during testing, we will assume
113         **  that this indicates that the lock is successfully grabbed.
114         */
115
116         if (save_errno == EINVAL)
117                 return true;
118
119         if (!bitset(LOCK_NB, type) ||
120             (save_errno != EACCES && save_errno != EAGAIN))
121         {
122 # if 0
123                 int omode = fcntl(fd, F_GETFL, NULL);
124                 int euid = (int) geteuid();
125
126                 syslog(LOG_ERR, "cannot lockf(%s%s, fd=%d, type=%o, omode=%o, euid=%d)",
127                        filename, ext, fd, type, omode, euid);
128 # endif /* 0 */
129                 errno = save_errno;
130                 return false;
131         }
132 #else /* !HASFLOCK */
133
134         while ((i = flock(fd, type)) < 0 && errno == EINTR)
135                 continue;
136         if (i >= 0)
137                 return true;
138         save_errno = errno;
139
140         if (!bitset(LOCK_NB, type) || save_errno != EWOULDBLOCK)
141         {
142 # if 0
143                 int omode = fcntl(fd, F_GETFL, NULL);
144                 int euid = (int) geteuid();
145
146                 syslog(LOG_ERR, "cannot flock(%s%s, fd=%d, type=%o, omode=%o, euid=%d)",
147                        filename, ext, fd, type, omode, euid);
148 # endif /* 0 */
149                 errno = save_errno;
150                 return false;
151         }
152 #endif /* !HASFLOCK */
153         errno = save_errno;
154         return false;
155 }
156 /*
157 ** SMDB_OPEN_DATABASE -- Opens a database.
158 **
159 **      This opens a database. If type is SMDB_DEFAULT it tries to
160 **      use a DB1 or DB2 hash. If that isn't available, it will try
161 **      to use NDBM. If a specific type is given it will try to open
162 **      a database of that type.
163 **
164 **      Parameters:
165 **              database -- An pointer to a SMDB_DATABASE pointer where the
166 **                         opened database will be stored. This should
167 **                         be unallocated.
168 **              db_name -- The name of the database to open. Do not include
169 **                        the file name extension.
170 **              mode -- The mode to set on the database file or files.
171 **              mode_mask -- Mode bits that must match on an opened database.
172 **              sff -- Flags to safefile.
173 **              type -- The type of database to open. Supported types
174 **                     vary depending on what was compiled in.
175 **              user_info -- Information on the user to use for file
176 **                          permissions.
177 **              params -- Params specific to the database being opened.
178 **                       Only supports some DB hash options right now
179 **                       (see smdb_db_open() for details).
180 **
181 **      Returns:
182 **              SMDBE_OK -- Success.
183 **              Anything else is an error. Look up more info about the
184 **              error in the comments for the specific open() used.
185 */
186
187 int
188 smdb_open_database(database, db_name, mode, mode_mask, sff, type, user_info,
189                    params)
190         SMDB_DATABASE **database;
191         char *db_name;
192         int mode;
193         int mode_mask;
194         long sff;
195         SMDB_DBTYPE type;
196         SMDB_USER_INFO *user_info;
197         SMDB_DBPARAMS *params;
198 {
199         bool type_was_default = false;
200
201         if (type == SMDB_TYPE_DEFAULT)
202         {
203                 type_was_default = true;
204 #ifdef NEWDB
205                 type = SMDB_TYPE_HASH;
206 #else /* NEWDB */
207 # ifdef NDBM
208                 type = SMDB_TYPE_NDBM;
209 # endif /* NDBM */
210 #endif /* NEWDB */
211         }
212
213         if (type == SMDB_TYPE_DEFAULT)
214                 return SMDBE_UNKNOWN_DB_TYPE;
215
216         if ((strncmp(type, SMDB_TYPE_HASH, SMDB_TYPE_HASH_LEN) == 0) ||
217             (strncmp(type, SMDB_TYPE_BTREE, SMDB_TYPE_BTREE_LEN) == 0))
218         {
219 #ifdef NEWDB
220                 int result;
221
222                 result = smdb_db_open(database, db_name, mode, mode_mask, sff,
223                                       type, user_info, params);
224 # ifdef NDBM
225                 if (result == ENOENT && type_was_default)
226                         type = SMDB_TYPE_NDBM;
227                 else
228 # endif /* NDBM */
229                         return result;
230 #else /* NEWDB */
231                 return SMDBE_UNSUPPORTED_DB_TYPE;
232 #endif /* NEWDB */
233         }
234
235         if (strncmp(type, SMDB_TYPE_NDBM, SMDB_TYPE_NDBM_LEN) == 0)
236         {
237 #ifdef NDBM
238                 int result;
239
240                 result = smdb_ndbm_open(database, db_name, mode, mode_mask,
241                                         sff, type, user_info, params);
242                 return result;
243 #else /* NDBM */
244                 return SMDBE_UNSUPPORTED_DB_TYPE;
245 #endif /* NDBM */
246         }
247
248         return SMDBE_UNKNOWN_DB_TYPE;
249 }
250 /*
251 ** SMDB_ADD_EXTENSION -- Adds an extension to a file name.
252 **
253 **      Just adds a . followed by a string to a db_name if there
254 **      is room and the db_name does not already have that extension.
255 **
256 **      Parameters:
257 **              full_name -- The final file name.
258 **              max_full_name_len -- The max length for full_name.
259 **              db_name -- The name of the db.
260 **              extension -- The extension to add.
261 **
262 **      Returns:
263 **              SMDBE_OK -- Success.
264 **              Anything else is an error. Look up more info about the
265 **              error in the comments for the specific open() used.
266 */
267
268 int
269 smdb_add_extension(full_name, max_full_name_len, db_name, extension)
270         char *full_name;
271         int max_full_name_len;
272         char *db_name;
273         char *extension;
274 {
275         int extension_len;
276         int db_name_len;
277
278         if (full_name == NULL || db_name == NULL || extension == NULL)
279                 return SMDBE_INVALID_PARAMETER;
280
281         extension_len = strlen(extension);
282         db_name_len = strlen(db_name);
283
284         if (extension_len + db_name_len + 2 > max_full_name_len)
285                 return SMDBE_DB_NAME_TOO_LONG;
286
287         if (db_name_len < extension_len + 1 ||
288             db_name[db_name_len - extension_len - 1] != '.' ||
289             strcmp(&db_name[db_name_len - extension_len], extension) != 0)
290                 (void) sm_snprintf(full_name, max_full_name_len, "%s.%s",
291                                    db_name, extension);
292         else
293                 (void) sm_strlcpy(full_name, db_name, max_full_name_len);
294
295         return SMDBE_OK;
296 }
297 /*
298 **  SMDB_LOCK_FILE -- Locks the database file.
299 **
300 **      Locks the actual database file.
301 **
302 **      Parameters:
303 **              lock_fd -- The resulting descriptor for the locked file.
304 **              db_name -- The name of the database without extension.
305 **              mode -- The open mode.
306 **              sff -- Flags to safefile.
307 **              extension -- The extension for the file.
308 **
309 **      Returns:
310 **              SMDBE_OK -- Success, otherwise errno.
311 */
312
313 int
314 smdb_lock_file(lock_fd, db_name, mode, sff, extension)
315         int *lock_fd;
316         char *db_name;
317         int mode;
318         long sff;
319         char *extension;
320 {
321         int result;
322         char file_name[MAXPATHLEN];
323
324         result = smdb_add_extension(file_name, sizeof file_name, db_name,
325                                     extension);
326         if (result != SMDBE_OK)
327                 return result;
328
329         *lock_fd = safeopen(file_name, mode & ~O_TRUNC, DBMMODE, sff);
330         if (*lock_fd < 0)
331                 return errno;
332
333         return SMDBE_OK;
334 }
335 /*
336 **  SMDB_UNLOCK_FILE -- Unlocks a file
337 **
338 **      Unlocks a file.
339 **
340 **      Parameters:
341 **              lock_fd -- The descriptor for the locked file.
342 **
343 **      Returns:
344 **              SMDBE_OK -- Success, otherwise errno.
345 */
346
347 int
348 smdb_unlock_file(lock_fd)
349         int lock_fd;
350 {
351         int result;
352
353         result = close(lock_fd);
354         if (result != 0)
355                 return errno;
356
357         return SMDBE_OK;
358 }
359 /*
360 **  SMDB_LOCK_MAP -- Locks a database.
361 **
362 **      Parameters:
363 **              database -- database description.
364 **              type -- type of the lock.  Bits can be:
365 **                      LOCK_EX -- exclusive lock.
366 **                      LOCK_NB -- non-blocking.
367 **
368 **      Returns:
369 **              SMDBE_OK -- Success, otherwise errno.
370 */
371
372 int
373 smdb_lock_map(database, type)
374         SMDB_DATABASE *database;
375         int type;
376 {
377         int fd;
378
379         fd = database->smdb_lockfd(database);
380         if (fd < 0)
381                 return SMDBE_NOT_FOUND;
382         if (!smdb_lockfile(fd, type))
383                 return SMDBE_LOCK_NOT_GRANTED;
384         return SMDBE_OK;
385 }
386 /*
387 **  SMDB_UNLOCK_MAP -- Unlocks a database
388 **
389 **      Parameters:
390 **              database -- database description.
391 **
392 **      Returns:
393 **              SMDBE_OK -- Success, otherwise errno.
394 */
395
396 int
397 smdb_unlock_map(database)
398         SMDB_DATABASE *database;
399 {
400         int fd;
401
402         fd = database->smdb_lockfd(database);
403         if (fd < 0)
404                 return SMDBE_NOT_FOUND;
405         if (!smdb_lockfile(fd, LOCK_UN))
406                 return SMDBE_LOCK_NOT_HELD;
407         return SMDBE_OK;
408 }
409 /*
410 **  SMDB_SETUP_FILE -- Gets db file ready for use.
411 **
412 **      Makes sure permissions on file are safe and creates it if it
413 **      doesn't exist.
414 **
415 **      Parameters:
416 **              db_name -- The name of the database without extension.
417 **              extension -- The extension.
418 **              sff -- Flags to safefile.
419 **              mode_mask -- Mode bits that must match.
420 **              user_info -- Information on the user to use for file
421 **                          permissions.
422 **              stat_info -- A place to put the stat info for the file.
423 **      Returns:
424 **              SMDBE_OK -- Success, otherwise errno.
425 */
426
427 int
428 smdb_setup_file(db_name, extension, mode_mask, sff, user_info, stat_info)
429         char *db_name;
430         char *extension;
431         int mode_mask;
432         long sff;
433         SMDB_USER_INFO *user_info;
434         struct stat *stat_info;
435 {
436         int st;
437         int result;
438         char db_file_name[MAXPATHLEN];
439
440         result = smdb_add_extension(db_file_name, sizeof db_file_name, db_name,
441                                     extension);
442         if (result != SMDBE_OK)
443                 return result;
444
445         st = safefile(db_file_name, user_info->smdbu_id,
446                       user_info->smdbu_group_id, user_info->smdbu_name,
447                       sff, mode_mask, stat_info);
448         if (st != 0)
449                 return st;
450
451         return SMDBE_OK;
452 }
453 /*
454 **  SMDB_FILECHANGED -- Checks to see if a file changed.
455 **
456 **      Compares the passed in stat_info with a current stat on
457 **      the passed in file descriptor. Check filechanged for
458 **      return values.
459 **
460 **      Parameters:
461 **              db_name -- The name of the database without extension.
462 **              extension -- The extension.
463 **              db_fd -- A file descriptor for the database file.
464 **              stat_info -- An old stat_info.
465 **      Returns:
466 **              SMDBE_OK -- Success, otherwise errno.
467 */
468
469 int
470 smdb_filechanged(db_name, extension, db_fd, stat_info)
471         char *db_name;
472         char *extension;
473         int db_fd;
474         struct stat *stat_info;
475 {
476         int result;
477         char db_file_name[MAXPATHLEN];
478
479         result = smdb_add_extension(db_file_name, sizeof db_file_name, db_name,
480                                     extension);
481         if (result != SMDBE_OK)
482                 return result;
483         return filechanged(db_file_name, db_fd, stat_info);
484 }
485 /*
486 ** SMDB_PRINT_AVAILABLE_TYPES -- Prints the names of the available types.
487 **
488 **      Parameters:
489 **              None
490 **
491 **      Returns:
492 **              None
493 */
494
495 void
496 smdb_print_available_types()
497 {
498 #ifdef NDBM
499         printf("dbm\n");
500 #endif /* NDBM */
501 #ifdef NEWDB
502         printf("hash\n");
503         printf("btree\n");
504 #endif /* NEWDB */
505 }
506 /*
507 ** SMDB_DB_DEFINITION -- Given a database type, return database definition
508 **
509 **      Reads though a structure making an association with the database
510 **      type and the required cpp define from sendmail/README.
511 **      List size is dynamic and must be NULL terminated.
512 **
513 **      Parameters:
514 **              type -- The name of the database type.
515 **
516 **      Returns:
517 **              definition for type, otherwise NULL.
518 */
519
520 typedef struct
521 {
522         SMDB_DBTYPE type;
523         char *dbdef;
524 } dbtype;
525
526 static dbtype DatabaseDefs[] =
527 {
528         { SMDB_TYPE_HASH,       "NEWDB" },
529         { SMDB_TYPE_BTREE,      "NEWDB" },
530         { SMDB_TYPE_NDBM,       "NDBM"  },
531         { NULL,                 "OOPS"  }
532 };
533
534 char *
535 smdb_db_definition(type)
536         SMDB_DBTYPE type;
537 {
538         dbtype *ptr = DatabaseDefs;
539
540         while (ptr != NULL && ptr->type != NULL)
541         {
542                 if (strcmp(type, ptr->type) == 0)
543                         return ptr->dbdef;
544                 ptr++;
545         }
546         return NULL;
547 }