1 /*
2 ** Copyright (c) 1999-2002 Proofpoint, 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.59 2013-11-22 20:51:49 ca 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 static bool smdb_lockfile __P((int, int));
22
23 /*
24 ** SMDB_MALLOC_DATABASE -- Allocates a database structure.
25 **
26 ** Parameters:
27 ** None
28 **
29 ** Returns:
30 ** A pointer to an allocated SMDB_DATABASE structure or
31 ** NULL if it couldn't allocate the memory.
32 */
33
34 SMDB_DATABASE *
smdb_malloc_database()35 smdb_malloc_database()
36 {
37 SMDB_DATABASE *db;
38
39 db = (SMDB_DATABASE *) malloc(sizeof(SMDB_DATABASE));
40
41 if (db != NULL)
42 (void) memset(db, '\0', sizeof(SMDB_DATABASE));
43
44 return db;
45 }
46
47 /*
48 ** SMDB_FREE_DATABASE -- Unallocates a database structure.
49 **
50 ** Parameters:
51 ** database -- a SMDB_DATABASE pointer to deallocate.
52 **
53 ** Returns:
54 ** None
55 */
56
57 void
smdb_free_database(database)58 smdb_free_database(database)
59 SMDB_DATABASE *database;
60 {
61 if (database != NULL)
62 free(database);
63 }
64
65 /*
66 ** SMDB_LOCKFILE -- lock a file using flock or (shudder) fcntl locking
67 **
68 ** Parameters:
69 ** fd -- the file descriptor of the file.
70 ** type -- type of the lock. Bits can be:
71 ** LOCK_EX -- exclusive lock.
72 ** LOCK_NB -- non-blocking.
73 **
74 ** Returns:
75 ** true if the lock was acquired.
76 ** false otherwise.
77 */
78
79 static bool
smdb_lockfile(fd,type)80 smdb_lockfile(fd, type)
81 int fd;
82 int type;
83 {
84 int i;
85 int save_errno;
86 #if !HASFLOCK
87 int action;
88 struct flock lfd;
89
90 (void) memset(&lfd, '\0', sizeof lfd);
91 if (bitset(LOCK_UN, type))
92 lfd.l_type = F_UNLCK;
93 else if (bitset(LOCK_EX, type))
94 lfd.l_type = F_WRLCK;
95 else
96 lfd.l_type = F_RDLCK;
97
98 if (bitset(LOCK_NB, type))
99 action = F_SETLK;
100 else
101 action = F_SETLKW;
102
103 while ((i = fcntl(fd, action, &lfd)) < 0 && errno == EINTR)
104 continue;
105 if (i >= 0)
106 return true;
107 save_errno = errno;
108
109 /*
110 ** On SunOS, if you are testing using -oQ/tmp/mqueue or
111 ** -oA/tmp/aliases or anything like that, and /tmp is mounted
112 ** as type "tmp" (that is, served from swap space), the
113 ** previous fcntl will fail with "Invalid argument" errors.
114 ** Since this is fairly common during testing, we will assume
115 ** that this indicates that the lock is successfully grabbed.
116 */
117
118 if (save_errno == EINVAL)
119 return true;
120
121 if (!bitset(LOCK_NB, type) ||
122 (save_errno != EACCES && save_errno != EAGAIN))
123 {
124 # if 0
125 int omode = fcntl(fd, F_GETFL, NULL);
126 int euid = (int) geteuid();
127
128 syslog(LOG_ERR, "cannot lockf(%s%s, fd=%d, type=%o, omode=%o, euid=%d)",
129 filename, ext, fd, type, omode, euid);
130 # endif /* 0 */
131 errno = save_errno;
132 return false;
133 }
134 #else /* !HASFLOCK */
135
136 while ((i = flock(fd, type)) < 0 && errno == EINTR)
137 continue;
138 if (i >= 0)
139 return true;
140 save_errno = errno;
141
142 if (!bitset(LOCK_NB, type) || save_errno != EWOULDBLOCK)
143 {
144 # if 0
145 int omode = fcntl(fd, F_GETFL, NULL);
146 int euid = (int) geteuid();
147
148 syslog(LOG_ERR, "cannot flock(%s%s, fd=%d, type=%o, omode=%o, euid=%d)",
149 filename, ext, fd, type, omode, euid);
150 # endif /* 0 */
151 errno = save_errno;
152 return false;
153 }
154 #endif /* !HASFLOCK */
155 errno = save_errno;
156 return false;
157 }
158
159 /*
160 ** SMDB_OPEN_DATABASE -- Opens a database.
161 **
162 ** This opens a database. If type is SMDB_DEFAULT it tries to
163 ** use available DB types. If a specific type is given it will
164 ** try to open a database of that type.
165 **
166 ** Parameters:
167 ** database -- A pointer to a SMDB_DATABASE pointer where the
168 ** opened database will be stored. This should
169 ** be unallocated.
170 ** db_name -- The name of the database to open. Do not include
171 ** the file name extension.
172 ** mode -- The mode to set on the database file or files.
173 ** mode_mask -- Mode bits that must match on an opened database.
174 ** sff -- Flags to safefile.
175 ** type -- The type of database to open. Supported types
176 ** vary depending on what was compiled in.
177 ** user_info -- Information on the user to use for file
178 ** permissions.
179 ** params -- Params specific to the database being opened.
180 ** Only supports some DB hash options right now
181 ** (see smdb_db_open() for details).
182 **
183 ** Returns:
184 ** SMDBE_OK -- Success.
185 ** Anything else is an error. Look up more info about the
186 ** error in the comments for the specific open() used.
187 */
188
189 struct type2func_s
190 {
191 const char *t2f_type;
192 smdb_open_func *t2f_open_fun;
193 };
194 typedef struct type2func_s type2func_t;
195 static type2func_t type2func[] = {
196 { SMDB_TYPE_HASH, smdb_db_open },
197 { SMDB_TYPE_BTREE, smdb_db_open },
198 { SMDB_TYPE_NDBM, smdb_ndbm_open},
199 { SMDB_TYPE_CDB, smdb_cdb_open },
200 { NULL, NULL }
201 };
202
203 int
smdb_open_database(database,db_name,mode,mode_mask,sff,type,user_info,params)204 smdb_open_database(database, db_name, mode, mode_mask, sff, type, user_info,
205 params)
206 SMDB_DATABASE **database;
207 char *db_name;
208 int mode;
209 int mode_mask;
210 long sff;
211 SMDB_DBTYPE type;
212 SMDB_USER_INFO *user_info;
213 SMDB_DBPARAMS *params;
214 {
215 bool type_was_default;
216 int result, i;
217 const char *smdb_type;
218 smdb_open_func *smdb_open_fun;
219
220 result = SMDBE_UNSUPPORTED_DB_TYPE;
221 type_was_default = SMDB_IS_TYPE_DEFAULT(type);
222 for (i = 0; (smdb_type = type2func[i].t2f_type) != NULL; i++)
223 {
224 if (!type_was_default && strcmp(type, smdb_type) != 0)
225 continue;
226 smdb_open_fun = type2func[i].t2f_open_fun;
227 if (smdb_open_fun == NULL)
228 {
229 if (type_was_default)
230 continue;
231 else
232 return SMDBE_UNSUPPORTED_DB_TYPE;
233 }
234 result = (*smdb_open_fun)(database, db_name, mode, mode_mask, sff,
235 (char *)smdb_type, user_info, params);
236 if (!((result == ENOENT
237 || result == EINVAL
238 #ifdef EFTYPE
239 || result == EFTYPE
240 #endif
241 )
242 && type_was_default))
243 goto ret;
244 }
245 return SMDBE_UNKNOWN_DB_TYPE;
246
247 ret:
248 return result;
249 }
250
251 /*
252 ** SMDB_ADD_EXTENSION -- Adds an extension to a file name.
253 **
254 ** Just adds a . followed by a string to a db_name if there
255 ** is room and the db_name does not already have that extension.
256 **
257 ** Parameters:
258 ** full_name -- The final file name.
259 ** max_full_name_len -- The max length for full_name.
260 ** db_name -- The name of the db.
261 ** extension -- The extension to add.
262 **
263 ** Returns:
264 ** SMDBE_OK -- Success.
265 ** Anything else is an error. Look up more info about the
266 ** error in the comments for the specific open() used.
267 */
268
269 int
smdb_add_extension(full_name,max_full_name_len,db_name,extension)270 smdb_add_extension(full_name, max_full_name_len, db_name, extension)
271 char *full_name;
272 int max_full_name_len;
273 char *db_name;
274 char *extension;
275 {
276 int extension_len;
277 int db_name_len;
278
279 if (full_name == NULL || db_name == NULL || extension == NULL)
280 return SMDBE_INVALID_PARAMETER;
281
282 extension_len = strlen(extension);
283 db_name_len = strlen(db_name);
284
285 if (extension_len + db_name_len + 2 > max_full_name_len)
286 return SMDBE_DB_NAME_TOO_LONG;
287
288 if (db_name_len < extension_len + 1 ||
289 db_name[db_name_len - extension_len - 1] != '.' ||
290 strcmp(&db_name[db_name_len - extension_len], extension) != 0)
291 (void) sm_snprintf(full_name, max_full_name_len, "%s.%s",
292 db_name, extension);
293 else
294 (void) sm_strlcpy(full_name, db_name, max_full_name_len);
295
296 return SMDBE_OK;
297 }
298 /*
299 ** SMDB_LOCK_FILE -- Locks the database file.
300 **
301 ** Locks the actual database file.
302 **
303 ** Parameters:
304 ** lock_fd -- The resulting descriptor for the locked file.
305 ** db_name -- The name of the database without extension.
306 ** mode -- The open mode.
307 ** sff -- Flags to safefile.
308 ** extension -- The extension for the file.
309 **
310 ** Returns:
311 ** SMDBE_OK -- Success, otherwise errno.
312 */
313
314 int
smdb_lock_file(lock_fd,db_name,mode,sff,extension)315 smdb_lock_file(lock_fd, db_name, mode, sff, extension)
316 int *lock_fd;
317 char *db_name;
318 int mode;
319 long sff;
320 char *extension;
321 {
322 int result;
323 char file_name[MAXPATHLEN];
324
325 result = smdb_add_extension(file_name, sizeof file_name, db_name,
326 extension);
327 if (result != SMDBE_OK)
328 return result;
329
330 *lock_fd = safeopen(file_name, mode & ~O_TRUNC, DBMMODE, sff);
331 if (*lock_fd < 0)
332 return errno;
333
334 return SMDBE_OK;
335 }
336
337 /*
338 ** SMDB_UNLOCK_FILE -- Unlocks a file - via close()
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
smdb_unlock_file(lock_fd)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
smdb_lock_map(database,type)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
smdb_unlock_map(database)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
smdb_setup_file(db_name,extension,mode_mask,sff,user_info,stat_info)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
smdb_filechanged(db_name,extension,db_fd,stat_info)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 /*
487 ** SMDB_PRINT_AVAILABLE_TYPES -- Prints the names of the available types.
488 **
489 ** Parameters:
490 ** ext - also show extension?
491 **
492 ** Returns:
493 ** None
494 */
495
496 void
smdb_print_available_types(ext)497 smdb_print_available_types(ext)
498 bool ext;
499 {
500 # define PEXT1 ((ext) ? ":" : "")
501 # define PEXT2(x) ((ext) ? x : "")
502
503 #if NDBM
504 printf("%s%s%s\n", SMDB_TYPE_NDBM, PEXT1, PEXT2(SMNDB_DIR_FILE_EXTENSION));
505 #endif
506 #if NEWDB
507 /* # if SMDB1_FILE_EXTENSION == SMDB2_FILE_EXTENSION */
508 printf("%s%s%s\n", SMDB_TYPE_HASH, PEXT1, PEXT2(SMDB1_FILE_EXTENSION));
509 printf("%s%s%s\n", SMDB_TYPE_BTREE, PEXT1, PEXT2(SMDB1_FILE_EXTENSION));
510 #endif
511 #if CDB
512 printf("%s%s%s\n", SMDB_TYPE_CDB, PEXT1, PEXT2(SMCDB_FILE_EXTENSION));
513 #endif
514 #ifdef SMDB_TYPE_IMPL
515 printf("%s%s%s\n", SMDB_TYPE_IMPL, PEXT1, "");
516 #endif
517 }
518
519 /*
520 ** SMDB_IS_DB_TYPE -- Does a name match an available DB type?
521 **
522 ** Parameters:
523 ** type -- The name of the database type.
524 **
525 ** Returns:
526 ** true iff match
527 */
528
529 bool
smdb_is_db_type(db_type)530 smdb_is_db_type(db_type)
531 const char *db_type;
532 {
533 #if NDBM
534 if (strcmp(db_type, SMDB_TYPE_NDBM) == 0)
535 return true;
536 #endif
537 #if NEWDB
538 if (strcmp(db_type, SMDB_TYPE_HASH) == 0)
539 return true;
540 if (strcmp(db_type, SMDB_TYPE_BTREE) == 0)
541 return true;
542 #endif
543 #if CDB
544 if (strcmp(db_type, SMDB_TYPE_CDB) == 0)
545 return true;
546 #endif
547 return false;
548 }
549
550
551 /*
552 ** SMDB_DB_DEFINITION -- Given a database type, return database definition
553 **
554 ** Reads though a structure making an association with the database
555 ** type and the required cpp define from sendmail/README.
556 ** List size is dynamic and must be NULL terminated.
557 **
558 ** Parameters:
559 ** type -- The name of the database type.
560 **
561 ** Returns:
562 ** definition for type, otherwise NULL.
563 */
564
565 typedef struct
566 {
567 SMDB_DBTYPE type;
568 char *dbdef;
569 } dbtype;
570
571 static dbtype DatabaseDefs[] =
572 {
573 { SMDB_TYPE_HASH, "NEWDB" },
574 { SMDB_TYPE_BTREE, "NEWDB" },
575 { SMDB_TYPE_NDBM, "NDBM" },
576 { SMDB_TYPE_CDB, "CDB" },
577 { NULL, "OOPS" }
578 };
579
580 char *
smdb_db_definition(type)581 smdb_db_definition(type)
582 SMDB_DBTYPE type;
583 {
584 dbtype *ptr = DatabaseDefs;
585
586 while (ptr != NULL && ptr->type != NULL)
587 {
588 if (strcmp(type, ptr->type) == 0)
589 return ptr->dbdef;
590 ptr++;
591 }
592 return NULL;
593 }
594