diff options
Diffstat (limited to 'contrib/sendmail/libsmdb/smdb1.c')
| -rw-r--r-- | contrib/sendmail/libsmdb/smdb1.c | 584 |
1 files changed, 584 insertions, 0 deletions
diff --git a/contrib/sendmail/libsmdb/smdb1.c b/contrib/sendmail/libsmdb/smdb1.c new file mode 100644 index 0000000..842d4b2 --- /dev/null +++ b/contrib/sendmail/libsmdb/smdb1.c @@ -0,0 +1,584 @@ +/* +** Copyright (c) 1999-2002, 2004, 2009 Sendmail, Inc. and its suppliers. +** All rights reserved. +** +** By using this file, you agree to the terms and conditions set +** forth in the LICENSE file which can be found at the top level of +** the sendmail distribution. +*/ + +#include <sm/gen.h> +SM_RCSID("@(#)$Id: smdb1.c,v 8.62 2009/11/12 23:04:18 ca Exp $") + +#include <unistd.h> +#include <stdlib.h> +#include <fcntl.h> + +#include <sendmail/sendmail.h> +#include <libsmdb/smdb.h> + +#if (DB_VERSION_MAJOR == 1) + +# define SMDB1_FILE_EXTENSION "db" + +struct smdb_db1_struct +{ + DB *smdb1_db; + int smdb1_lock_fd; + bool smdb1_cursor_in_use; +}; +typedef struct smdb_db1_struct SMDB_DB1_DATABASE; + +struct smdb_db1_cursor +{ + SMDB_DB1_DATABASE *db; +}; +typedef struct smdb_db1_cursor SMDB_DB1_CURSOR; + +static DBTYPE smdb_type_to_db1_type __P((SMDB_DBTYPE)); +static unsigned int smdb_put_flags_to_db1_flags __P((SMDB_FLAG)); +static int smdb_cursor_get_flags_to_smdb1 __P((SMDB_FLAG)); +static SMDB_DB1_DATABASE *smdb1_malloc_database __P((void)); +static int smdb1_close __P((SMDB_DATABASE *)); +static int smdb1_del __P((SMDB_DATABASE *, SMDB_DBENT *, unsigned int)); +static int smdb1_fd __P((SMDB_DATABASE *, int *)); +static int smdb1_lockfd __P((SMDB_DATABASE *)); +static int smdb1_get __P((SMDB_DATABASE *, SMDB_DBENT *, SMDB_DBENT *, unsigned int)); +static int smdb1_put __P((SMDB_DATABASE *, SMDB_DBENT *, SMDB_DBENT *, unsigned int)); +static int smdb1_set_owner __P((SMDB_DATABASE *, uid_t, gid_t)); +static int smdb1_sync __P((SMDB_DATABASE *, unsigned int)); +static int smdb1_cursor_close __P((SMDB_CURSOR *)); +static int smdb1_cursor_del __P((SMDB_CURSOR *, unsigned int)); +static int smdb1_cursor_get __P((SMDB_CURSOR *, SMDB_DBENT *, SMDB_DBENT *, SMDB_FLAG)); +static int smdb1_cursor_put __P((SMDB_CURSOR *, SMDB_DBENT *, SMDB_DBENT *, SMDB_FLAG)); +static int smdb1_cursor __P((SMDB_DATABASE *, SMDB_CURSOR **, unsigned int)); + +/* +** SMDB_TYPE_TO_DB1_TYPE -- Translates smdb database type to db1 type. +** +** Parameters: +** type -- The type to translate. +** +** Returns: +** The DB1 type that corresponsds to the passed in SMDB type. +** Returns -1 if there is no equivalent type. +** +*/ + +static DBTYPE +smdb_type_to_db1_type(type) + SMDB_DBTYPE type; +{ + if (type == SMDB_TYPE_DEFAULT) + return DB_HASH; + + if (strncmp(type, SMDB_TYPE_HASH, SMDB_TYPE_HASH_LEN) == 0) + return DB_HASH; + + if (strncmp(type, SMDB_TYPE_BTREE, SMDB_TYPE_BTREE_LEN) == 0) + return DB_BTREE; + + /* Should never get here thanks to test in smdb_db_open() */ + return DB_HASH; +} +/* +** SMDB_PUT_FLAGS_TO_DB1_FLAGS -- Translates smdb put flags to db1 put flags. +** +** Parameters: +** flags -- The flags to translate. +** +** Returns: +** The db1 flags that are equivalent to the smdb flags. +** +** Notes: +** Any invalid flags are ignored. +** +*/ + +static unsigned int +smdb_put_flags_to_db1_flags(flags) + SMDB_FLAG flags; +{ + int return_flags; + + return_flags = 0; + + if (bitset(SMDBF_NO_OVERWRITE, flags)) + return_flags |= R_NOOVERWRITE; + + return return_flags; +} +/* +** SMDB_CURSOR_GET_FLAGS_TO_SMDB1 +** +** Parameters: +** flags -- The flags to translate. +** +** Returns: +** The db1 flags that are equivalent to the smdb flags. +** +** Notes: +** Returns -1 if we don't support the flag. +** +*/ + +static int +smdb_cursor_get_flags_to_smdb1(flags) + SMDB_FLAG flags; +{ + switch(flags) + { + case SMDB_CURSOR_GET_FIRST: + return R_FIRST; + + case SMDB_CURSOR_GET_LAST: + return R_LAST; + + case SMDB_CURSOR_GET_NEXT: + return R_NEXT; + + case SMDB_CURSOR_GET_RANGE: + return R_CURSOR; + + default: + return -1; + } +} + +/* +** The rest of these functions correspond to the interface laid out in smdb.h. +*/ + +static SMDB_DB1_DATABASE * +smdb1_malloc_database() +{ + SMDB_DB1_DATABASE *db1; + + db1 = (SMDB_DB1_DATABASE *) malloc(sizeof(SMDB_DB1_DATABASE)); + + if (db1 != NULL) + { + db1->smdb1_lock_fd = -1; + db1->smdb1_cursor_in_use = false; + } + + return db1; +} + +static int +smdb1_close(database) + SMDB_DATABASE *database; +{ + int result; + SMDB_DB1_DATABASE *db1 = (SMDB_DB1_DATABASE *) database->smdb_impl; + DB *db = ((SMDB_DB1_DATABASE *) database->smdb_impl)->smdb1_db; + + result = db->close(db); + if (db1->smdb1_lock_fd != -1) + (void) close(db1->smdb1_lock_fd); + + free(db1); + database->smdb_impl = NULL; + + return result; +} + +static int +smdb1_del(database, key, flags) + SMDB_DATABASE *database; + SMDB_DBENT *key; + unsigned int flags; +{ + DB *db = ((SMDB_DB1_DATABASE *) database->smdb_impl)->smdb1_db; + DBT dbkey; + + (void) memset(&dbkey, '\0', sizeof dbkey); + dbkey.data = key->data; + dbkey.size = key->size; + return db->del(db, &dbkey, flags); +} + +static int +smdb1_fd(database, fd) + SMDB_DATABASE *database; + int *fd; +{ + DB *db = ((SMDB_DB1_DATABASE *) database->smdb_impl)->smdb1_db; + + *fd = db->fd(db); + if (*fd == -1) + return errno; + + return SMDBE_OK; +} + +static int +smdb1_lockfd(database) + SMDB_DATABASE *database; +{ + SMDB_DB1_DATABASE *db1 = (SMDB_DB1_DATABASE *) database->smdb_impl; + + return db1->smdb1_lock_fd; +} + + +static int +smdb1_get(database, key, data, flags) + SMDB_DATABASE *database; + SMDB_DBENT *key; + SMDB_DBENT *data; + unsigned int flags; +{ + int result; + DB *db = ((SMDB_DB1_DATABASE *) database->smdb_impl)->smdb1_db; + DBT dbkey, dbdata; + + (void) memset(&dbdata, '\0', sizeof dbdata); + (void) memset(&dbkey, '\0', sizeof dbkey); + dbkey.data = key->data; + dbkey.size = key->size; + + result = db->get(db, &dbkey, &dbdata, flags); + if (result != 0) + { + if (result == 1) + return SMDBE_NOT_FOUND; + return errno; + } + data->data = dbdata.data; + data->size = dbdata.size; + return SMDBE_OK; +} + +static int +smdb1_put(database, key, data, flags) + SMDB_DATABASE *database; + SMDB_DBENT *key; + SMDB_DBENT *data; + unsigned int flags; +{ + DB *db = ((SMDB_DB1_DATABASE *) database->smdb_impl)->smdb1_db; + DBT dbkey, dbdata; + + (void) memset(&dbdata, '\0', sizeof dbdata); + (void) memset(&dbkey, '\0', sizeof dbkey); + dbkey.data = key->data; + dbkey.size = key->size; + dbdata.data = data->data; + dbdata.size = data->size; + + return db->put(db, &dbkey, &dbdata, + smdb_put_flags_to_db1_flags(flags)); +} + +static int +smdb1_set_owner(database, uid, gid) + SMDB_DATABASE *database; + uid_t uid; + gid_t gid; +{ +# if HASFCHOWN + int fd; + int result; + DB *db = ((SMDB_DB1_DATABASE *) database->smdb_impl)->smdb1_db; + + fd = db->fd(db); + if (fd == -1) + return errno; + + result = fchown(fd, uid, gid); + if (result < 0) + return errno; +# endif /* HASFCHOWN */ + + return SMDBE_OK; +} + +static int +smdb1_sync(database, flags) + SMDB_DATABASE *database; + unsigned int flags; +{ + DB *db = ((SMDB_DB1_DATABASE *) database->smdb_impl)->smdb1_db; + + return db->sync(db, flags); +} + +static int +smdb1_cursor_close(cursor) + SMDB_CURSOR *cursor; +{ + SMDB_DB1_CURSOR *db1_cursor = (SMDB_DB1_CURSOR *) cursor->smdbc_impl; + SMDB_DB1_DATABASE *db1 = db1_cursor->db; + + if (!db1->smdb1_cursor_in_use) + return SMDBE_NOT_A_VALID_CURSOR; + + db1->smdb1_cursor_in_use = false; + free(cursor); + + return SMDBE_OK; +} + +static int +smdb1_cursor_del(cursor, flags) + SMDB_CURSOR *cursor; + unsigned int flags; +{ + SMDB_DB1_CURSOR *db1_cursor = (SMDB_DB1_CURSOR *) cursor->smdbc_impl; + SMDB_DB1_DATABASE *db1 = db1_cursor->db; + DB *db = db1->smdb1_db; + + return db->del(db, NULL, R_CURSOR); +} + +static int +smdb1_cursor_get(cursor, key, value, flags) + SMDB_CURSOR *cursor; + SMDB_DBENT *key; + SMDB_DBENT *value; + SMDB_FLAG flags; +{ + int db1_flags; + int result; + SMDB_DB1_CURSOR *db1_cursor = (SMDB_DB1_CURSOR *) cursor->smdbc_impl; + SMDB_DB1_DATABASE *db1 = db1_cursor->db; + DB *db = db1->smdb1_db; + DBT dbkey, dbdata; + + (void) memset(&dbdata, '\0', sizeof dbdata); + (void) memset(&dbkey, '\0', sizeof dbkey); + + db1_flags = smdb_cursor_get_flags_to_smdb1(flags); + result = db->seq(db, &dbkey, &dbdata, db1_flags); + if (result == -1) + return errno; + if (result == 1) + return SMDBE_LAST_ENTRY; + value->data = dbdata.data; + value->size = dbdata.size; + key->data = dbkey.data; + key->size = dbkey.size; + return SMDBE_OK; +} + +static int +smdb1_cursor_put(cursor, key, value, flags) + SMDB_CURSOR *cursor; + SMDB_DBENT *key; + SMDB_DBENT *value; + SMDB_FLAG flags; +{ + SMDB_DB1_CURSOR *db1_cursor = (SMDB_DB1_CURSOR *) cursor->smdbc_impl; + SMDB_DB1_DATABASE *db1 = db1_cursor->db; + DB *db = db1->smdb1_db; + DBT dbkey, dbdata; + + (void) memset(&dbdata, '\0', sizeof dbdata); + (void) memset(&dbkey, '\0', sizeof dbkey); + dbkey.data = key->data; + dbkey.size = key->size; + dbdata.data = value->data; + dbdata.size = value->size; + + return db->put(db, &dbkey, &dbdata, R_CURSOR); +} + +static int +smdb1_cursor(database, cursor, flags) + SMDB_DATABASE *database; + SMDB_CURSOR **cursor; + unsigned int flags; +{ + SMDB_DB1_DATABASE *db1 = (SMDB_DB1_DATABASE *) database->smdb_impl; + SMDB_CURSOR *cur; + SMDB_DB1_CURSOR *db1_cursor; + + if (db1->smdb1_cursor_in_use) + return SMDBE_ONLY_SUPPORTS_ONE_CURSOR; + + db1_cursor = (SMDB_DB1_CURSOR *) malloc(sizeof(SMDB_DB1_CURSOR)); + if (db1_cursor == NULL) + return SMDBE_MALLOC; + + cur = (SMDB_CURSOR *) malloc(sizeof(SMDB_CURSOR)); + if (cur == NULL) + { + free(db1_cursor); + return SMDBE_MALLOC; + } + + db1->smdb1_cursor_in_use = true; + db1_cursor->db = db1; + cur->smdbc_impl = db1_cursor; + cur->smdbc_close = smdb1_cursor_close; + cur->smdbc_del = smdb1_cursor_del; + cur->smdbc_get = smdb1_cursor_get; + cur->smdbc_put = smdb1_cursor_put; + *cursor = cur; + + return SMDBE_OK; +} +/* +** SMDB_DB_OPEN -- Opens a db1 database. +** +** Parameters: +** database -- An unallocated database pointer to a pointer. +** db_name -- The name of the database without extension. +** mode -- File permisions on the database if created. +** mode_mask -- Mode bits that must match on an existing database. +** sff -- Flags for safefile. +** type -- The type of database to open +** See smdb_type_to_db1_type for valid types. +** user_info -- Information on the user to use for file +** permissions. +** db_params -- +** An SMDB_DBPARAMS struct including params. These +** are processed according to the type of the +** database. Currently supported params (only for +** HASH type) are: +** num_elements +** cache_size +** +** Returns: +** SMDBE_OK -- Success, otherwise errno. +*/ + +int +smdb_db_open(database, db_name, mode, mode_mask, sff, type, user_info, + db_params) + SMDB_DATABASE **database; + char *db_name; + int mode; + int mode_mask; + long sff; + SMDB_DBTYPE type; + SMDB_USER_INFO *user_info; + SMDB_DBPARAMS *db_params; +{ + bool lockcreated = false; + int db_fd; + int lock_fd; + int result; + void *params; + SMDB_DATABASE *smdb_db; + SMDB_DB1_DATABASE *db1; + DB *db; + HASHINFO hash_info; + BTREEINFO btree_info; + DBTYPE db_type; + struct stat stat_info; + char db_file_name[MAXPATHLEN]; + + if (type == NULL || + (strncmp(SMDB_TYPE_HASH, type, SMDB_TYPE_HASH_LEN) != 0 && + strncmp(SMDB_TYPE_BTREE, type, SMDB_TYPE_BTREE_LEN) != 0)) + return SMDBE_UNKNOWN_DB_TYPE; + + result = smdb_add_extension(db_file_name, sizeof db_file_name, + db_name, SMDB1_FILE_EXTENSION); + if (result != SMDBE_OK) + return result; + + result = smdb_setup_file(db_name, SMDB1_FILE_EXTENSION, mode_mask, + sff, user_info, &stat_info); + if (result != SMDBE_OK) + return result; + + if (stat_info.st_mode == ST_MODE_NOFILE && + bitset(mode, O_CREAT)) + lockcreated = true; + + lock_fd = -1; + result = smdb_lock_file(&lock_fd, db_name, mode, sff, + SMDB1_FILE_EXTENSION); + if (result != SMDBE_OK) + return result; + + if (lockcreated) + { + mode |= O_TRUNC; + mode &= ~(O_CREAT|O_EXCL); + } + + *database = NULL; + + smdb_db = smdb_malloc_database(); + db1 = smdb1_malloc_database(); + if (smdb_db == NULL || db1 == NULL) + { + (void) smdb_unlock_file(lock_fd); + smdb_free_database(smdb_db); + free(db1); + return SMDBE_MALLOC; + } + db1->smdb1_lock_fd = lock_fd; + + params = NULL; + if (db_params != NULL && + (strncmp(SMDB_TYPE_HASH, type, SMDB_TYPE_HASH_LEN) == 0)) + { + (void) memset(&hash_info, '\0', sizeof hash_info); + hash_info.nelem = db_params->smdbp_num_elements; + hash_info.cachesize = db_params->smdbp_cache_size; + params = &hash_info; + } + + if (db_params != NULL && + (strncmp(SMDB_TYPE_BTREE, type, SMDB_TYPE_BTREE_LEN) == 0)) + { + (void) memset(&btree_info, '\0', sizeof btree_info); + btree_info.cachesize = db_params->smdbp_cache_size; + if (db_params->smdbp_allow_dup) + btree_info.flags |= R_DUP; + params = &btree_info; + } + + db_type = smdb_type_to_db1_type(type); + db = dbopen(db_file_name, mode, DBMMODE, db_type, params); + if (db != NULL) + { + db_fd = db->fd(db); + result = smdb_filechanged(db_name, SMDB1_FILE_EXTENSION, db_fd, + &stat_info); + } + else + { + if (errno == 0) + result = SMDBE_BAD_OPEN; + else + result = errno; + } + + if (result == SMDBE_OK) + { + /* Everything is ok. Setup driver */ + db1->smdb1_db = db; + + smdb_db->smdb_close = smdb1_close; + smdb_db->smdb_del = smdb1_del; + smdb_db->smdb_fd = smdb1_fd; + smdb_db->smdb_lockfd = smdb1_lockfd; + smdb_db->smdb_get = smdb1_get; + smdb_db->smdb_put = smdb1_put; + smdb_db->smdb_set_owner = smdb1_set_owner; + smdb_db->smdb_sync = smdb1_sync; + smdb_db->smdb_cursor = smdb1_cursor; + smdb_db->smdb_impl = db1; + + *database = smdb_db; + return SMDBE_OK; + } + + if (db != NULL) + (void) db->close(db); + + /* Error opening database */ + (void) smdb_unlock_file(db1->smdb1_lock_fd); + free(db1); + smdb_free_database(smdb_db); + + return result; +} + +#endif /* (DB_VERSION_MAJOR == 1) */ |
