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