xref: /freebsd/contrib/sendmail/libsmdb/smdb.c (revision b0b1dbdd) 
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 **		An pointer to an allocated SMDB_DATABASE structure or
31 **		NULL if it couldn't allocate the memory.
32 */
33 
34 SMDB_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 /*
49 ** SMDB_FREE_DATABASE -- Unallocates a database structure.
50 **
51 **	Parameters:
52 **		database -- a SMDB_DATABASE pointer to deallocate.
53 **
54 **	Returns:
55 **		None
56 */
57 
58 void
59 smdb_free_database(database)
60 	SMDB_DATABASE *database;
61 {
62 	if (database != NULL)
63 		free(database);
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
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 ** SMDB_OPEN_DATABASE -- Opens a database.
160 **
161 **	This opens a database. If type is SMDB_DEFAULT it tries to
162 **	use a DB1 or DB2 hash. If that isn't available, it will try
163 **	to use NDBM. If a specific type is given it will try to open
164 **	a database of that type.
165 **
166 **	Parameters:
167 **		database -- An 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 int
190 smdb_open_database(database, db_name, mode, mode_mask, sff, type, user_info,
191 		   params)
192 	SMDB_DATABASE **database;
193 	char *db_name;
194 	int mode;
195 	int mode_mask;
196 	long sff;
197 	SMDB_DBTYPE type;
198 	SMDB_USER_INFO *user_info;
199 	SMDB_DBPARAMS *params;
200 {
201 #if defined(NEWDB) && defined(NDBM)
202 	bool type_was_default = false;
203 #endif
204 
205 	if (type == SMDB_TYPE_DEFAULT)
206 	{
207 #ifdef NEWDB
208 # ifdef NDBM
209 		type_was_default = true;
210 # endif
211 		type = SMDB_TYPE_HASH;
212 #else /* NEWDB */
213 # ifdef NDBM
214 		type = SMDB_TYPE_NDBM;
215 # endif /* NDBM */
216 #endif /* NEWDB */
217 	}
218 
219 	if (type == SMDB_TYPE_DEFAULT)
220 		return SMDBE_UNKNOWN_DB_TYPE;
221 
222 	if ((strncmp(type, SMDB_TYPE_HASH, SMDB_TYPE_HASH_LEN) == 0) ||
223 	    (strncmp(type, SMDB_TYPE_BTREE, SMDB_TYPE_BTREE_LEN) == 0))
224 	{
225 #ifdef NEWDB
226 		int result;
227 
228 		result = smdb_db_open(database, db_name, mode, mode_mask, sff,
229 				      type, user_info, params);
230 # ifdef NDBM
231 		if (result == ENOENT && type_was_default)
232 			type = SMDB_TYPE_NDBM;
233 		else
234 # endif /* NDBM */
235 			return result;
236 #else /* NEWDB */
237 		return SMDBE_UNSUPPORTED_DB_TYPE;
238 #endif /* NEWDB */
239 	}
240 
241 	if (strncmp(type, SMDB_TYPE_NDBM, SMDB_TYPE_NDBM_LEN) == 0)
242 	{
243 #ifdef NDBM
244 		int result;
245 
246 		result = smdb_ndbm_open(database, db_name, mode, mode_mask,
247 					sff, type, user_info, params);
248 		return result;
249 #else /* NDBM */
250 		return SMDBE_UNSUPPORTED_DB_TYPE;
251 #endif /* NDBM */
252 	}
253 
254 	return SMDBE_UNKNOWN_DB_TYPE;
255 }
256 /*
257 ** SMDB_ADD_EXTENSION -- Adds an extension to a file name.
258 **
259 **	Just adds a . followed by a string to a db_name if there
260 **	is room and the db_name does not already have that extension.
261 **
262 **	Parameters:
263 **		full_name -- The final file name.
264 **		max_full_name_len -- The max length for full_name.
265 **		db_name -- The name of the db.
266 **		extension -- The extension to add.
267 **
268 **	Returns:
269 **		SMDBE_OK -- Success.
270 **		Anything else is an error. Look up more info about the
271 **		error in the comments for the specific open() used.
272 */
273 
274 int
275 smdb_add_extension(full_name, max_full_name_len, db_name, extension)
276 	char *full_name;
277 	int max_full_name_len;
278 	char *db_name;
279 	char *extension;
280 {
281 	int extension_len;
282 	int db_name_len;
283 
284 	if (full_name == NULL || db_name == NULL || extension == NULL)
285 		return SMDBE_INVALID_PARAMETER;
286 
287 	extension_len = strlen(extension);
288 	db_name_len = strlen(db_name);
289 
290 	if (extension_len + db_name_len + 2 > max_full_name_len)
291 		return SMDBE_DB_NAME_TOO_LONG;
292 
293 	if (db_name_len < extension_len + 1 ||
294 	    db_name[db_name_len - extension_len - 1] != '.' ||
295 	    strcmp(&db_name[db_name_len - extension_len], extension) != 0)
296 		(void) sm_snprintf(full_name, max_full_name_len, "%s.%s",
297 				   db_name, extension);
298 	else
299 		(void) sm_strlcpy(full_name, db_name, max_full_name_len);
300 
301 	return SMDBE_OK;
302 }
303 /*
304 **  SMDB_LOCK_FILE -- Locks the database file.
305 **
306 **	Locks the actual database file.
307 **
308 **	Parameters:
309 **		lock_fd -- The resulting descriptor for the locked file.
310 **		db_name -- The name of the database without extension.
311 **		mode -- The open mode.
312 **		sff -- Flags to safefile.
313 **		extension -- The extension for the file.
314 **
315 **	Returns:
316 **		SMDBE_OK -- Success, otherwise errno.
317 */
318 
319 int
320 smdb_lock_file(lock_fd, db_name, mode, sff, extension)
321 	int *lock_fd;
322 	char *db_name;
323 	int mode;
324 	long sff;
325 	char *extension;
326 {
327 	int result;
328 	char file_name[MAXPATHLEN];
329 
330 	result = smdb_add_extension(file_name, sizeof file_name, db_name,
331 				    extension);
332 	if (result != SMDBE_OK)
333 		return result;
334 
335 	*lock_fd = safeopen(file_name, mode & ~O_TRUNC, DBMMODE, sff);
336 	if (*lock_fd < 0)
337 		return errno;
338 
339 	return SMDBE_OK;
340 }
341 /*
342 **  SMDB_UNLOCK_FILE -- Unlocks a file
343 **
344 **	Unlocks a file.
345 **
346 **	Parameters:
347 **		lock_fd -- The descriptor for the locked file.
348 **
349 **	Returns:
350 **		SMDBE_OK -- Success, otherwise errno.
351 */
352 
353 int
354 smdb_unlock_file(lock_fd)
355 	int lock_fd;
356 {
357 	int result;
358 
359 	result = close(lock_fd);
360 	if (result != 0)
361 		return errno;
362 
363 	return SMDBE_OK;
364 }
365 /*
366 **  SMDB_LOCK_MAP -- Locks a database.
367 **
368 **	Parameters:
369 **		database -- database description.
370 **		type -- type of the lock.  Bits can be:
371 **			LOCK_EX -- exclusive lock.
372 **			LOCK_NB -- non-blocking.
373 **
374 **	Returns:
375 **		SMDBE_OK -- Success, otherwise errno.
376 */
377 
378 int
379 smdb_lock_map(database, type)
380 	SMDB_DATABASE *database;
381 	int type;
382 {
383 	int fd;
384 
385 	fd = database->smdb_lockfd(database);
386 	if (fd < 0)
387 		return SMDBE_NOT_FOUND;
388 	if (!smdb_lockfile(fd, type))
389 		return SMDBE_LOCK_NOT_GRANTED;
390 	return SMDBE_OK;
391 }
392 /*
393 **  SMDB_UNLOCK_MAP -- Unlocks a database
394 **
395 **	Parameters:
396 **		database -- database description.
397 **
398 **	Returns:
399 **		SMDBE_OK -- Success, otherwise errno.
400 */
401 
402 int
403 smdb_unlock_map(database)
404 	SMDB_DATABASE *database;
405 {
406 	int fd;
407 
408 	fd = database->smdb_lockfd(database);
409 	if (fd < 0)
410 		return SMDBE_NOT_FOUND;
411 	if (!smdb_lockfile(fd, LOCK_UN))
412 		return SMDBE_LOCK_NOT_HELD;
413 	return SMDBE_OK;
414 }
415 /*
416 **  SMDB_SETUP_FILE -- Gets db file ready for use.
417 **
418 **	Makes sure permissions on file are safe and creates it if it
419 **	doesn't exist.
420 **
421 **	Parameters:
422 **		db_name -- The name of the database without extension.
423 **		extension -- The extension.
424 **		sff -- Flags to safefile.
425 **		mode_mask -- Mode bits that must match.
426 **		user_info -- Information on the user to use for file
427 **			    permissions.
428 **		stat_info -- A place to put the stat info for the file.
429 **	Returns:
430 **		SMDBE_OK -- Success, otherwise errno.
431 */
432 
433 int
434 smdb_setup_file(db_name, extension, mode_mask, sff, user_info, stat_info)
435 	char *db_name;
436 	char *extension;
437 	int mode_mask;
438 	long sff;
439 	SMDB_USER_INFO *user_info;
440 	struct stat *stat_info;
441 {
442 	int st;
443 	int result;
444 	char db_file_name[MAXPATHLEN];
445 
446 	result = smdb_add_extension(db_file_name, sizeof db_file_name, db_name,
447 				    extension);
448 	if (result != SMDBE_OK)
449 		return result;
450 
451 	st = safefile(db_file_name, user_info->smdbu_id,
452 		      user_info->smdbu_group_id, user_info->smdbu_name,
453 		      sff, mode_mask, stat_info);
454 	if (st != 0)
455 		return st;
456 
457 	return SMDBE_OK;
458 }
459 /*
460 **  SMDB_FILECHANGED -- Checks to see if a file changed.
461 **
462 **	Compares the passed in stat_info with a current stat on
463 **	the passed in file descriptor. Check filechanged for
464 **	return values.
465 **
466 **	Parameters:
467 **		db_name -- The name of the database without extension.
468 **		extension -- The extension.
469 **		db_fd -- A file descriptor for the database file.
470 **		stat_info -- An old stat_info.
471 **	Returns:
472 **		SMDBE_OK -- Success, otherwise errno.
473 */
474 
475 int
476 smdb_filechanged(db_name, extension, db_fd, stat_info)
477 	char *db_name;
478 	char *extension;
479 	int db_fd;
480 	struct stat *stat_info;
481 {
482 	int result;
483 	char db_file_name[MAXPATHLEN];
484 
485 	result = smdb_add_extension(db_file_name, sizeof db_file_name, db_name,
486 				    extension);
487 	if (result != SMDBE_OK)
488 		return result;
489 	return filechanged(db_file_name, db_fd, stat_info);
490 }
491 /*
492 ** SMDB_PRINT_AVAILABLE_TYPES -- Prints the names of the available types.
493 **
494 **	Parameters:
495 **		None
496 **
497 **	Returns:
498 **		None
499 */
500 
501 void
502 smdb_print_available_types()
503 {
504 #ifdef NDBM
505 	printf("dbm\n");
506 #endif /* NDBM */
507 #ifdef NEWDB
508 	printf("hash\n");
509 	printf("btree\n");
510 #endif /* NEWDB */
511 }
512 /*
513 ** SMDB_DB_DEFINITION -- Given a database type, return database definition
514 **
515 **	Reads though a structure making an association with the database
516 **	type and the required cpp define from sendmail/README.
517 **	List size is dynamic and must be NULL terminated.
518 **
519 **	Parameters:
520 **		type -- The name of the database type.
521 **
522 **	Returns:
523 **		definition for type, otherwise NULL.
524 */
525 
526 typedef struct
527 {
528 	SMDB_DBTYPE type;
529 	char *dbdef;
530 } dbtype;
531 
532 static dbtype DatabaseDefs[] =
533 {
534 	{ SMDB_TYPE_HASH,	"NEWDB" },
535 	{ SMDB_TYPE_BTREE,	"NEWDB" },
536 	{ SMDB_TYPE_NDBM,	"NDBM"	},
537 	{ NULL,			"OOPS"	}
538 };
539 
540 char *
541 smdb_db_definition(type)
542 	SMDB_DBTYPE type;
543 {
544 	dbtype *ptr = DatabaseDefs;
545 
546 	while (ptr != NULL && ptr->type != NULL)
547 	{
548 		if (strcmp(type, ptr->type) == 0)
549 			return ptr->dbdef;
550 		ptr++;
551 	}
552 	return NULL;
553 }
554