From e584cd6d5a3782ddeb6640f69534ab1664da2605 Mon Sep 17 00:00:00 2001 From: Andre Noll Date: Sat, 8 Nov 2008 23:05:54 +0100 Subject: [PATCH] User handling improvments. - move global variable num_uids to user.c. - logging improvements. - replace search_uid() by create_user_table(). search_uid() had a horrible interface. - in user.c, use FOR_EACH_USER() to loop over all users rather than for_each_admissible_user(). --- adu.c | 2 - adu.h | 1 - create.c | 4 +- user.c | 144 ++++++++++++++++++++++++++++--------------------------- user.h | 8 +--- 5 files changed, 76 insertions(+), 83 deletions(-) diff --git a/adu.c b/adu.c index a586ade..ed1b4fa 100644 --- a/adu.c +++ b/adu.c @@ -23,8 +23,6 @@ struct gengetopt_args_info conf; /** Options passed to --select-options. */ struct select_args_info select_conf; -/** The number of different uids found so far. */ -uint32_t num_uids = 0; /** * The table containing the directory names and statistics. diff --git a/adu.h b/adu.h index 509c0a2..74083ec 100644 --- a/adu.h +++ b/adu.h @@ -134,7 +134,6 @@ enum dir_table_columns { NUM_DT_COLUMNS }; -extern uint32_t num_uids; extern struct osl_table *dir_table; /** The adu command line options. */ diff --git a/create.c b/create.c index d08da1c..a5bd298 100644 --- a/create.c +++ b/create.c @@ -58,9 +58,7 @@ static int update_user_row(struct osl_table *t, uint64_t dir_num, objects[UT_BYTES].size = sizeof(*add); objects[UT_FILES].data = &num_files; objects[UT_FILES].size = sizeof(num_files); - INFO_LOG("######################### ret: %d\n", ret); ret = osl(osl_add_row(t, objects)); - INFO_LOG("######################### ret: %d\n", ret); return ret; } else { /* add size and increment file count */ uint64_t num; @@ -133,7 +131,7 @@ static int scan_dir(char *dirname, uint64_t *parent_dir_num) dir_size += size; dir_files++; uid = s.st_uid; - ret = search_uid(uid, NULL, CREATE_USER_TABLE | OPEN_USER_TABLE, &ui); + ret = create_user_table(uid, &ui); if (ret < 0) goto out; ui->bytes += size; diff --git a/user.c b/user.c index 2b9fb20..2798209 100644 --- a/user.c +++ b/user.c @@ -50,6 +50,9 @@ static struct user_info *uid_hash_table; /** This is always a power of two. It is set in create_hash_table(). */ static uint32_t uid_hash_table_size; +/** The number of used slots in the hash table. */ +static uint32_t num_uids = 0; + /* * The columns of the per-user tables. * @@ -243,8 +246,7 @@ static int open_user_table(struct user_info *ui, int create) if (pw && pw->pw_name) ui->pw_name = adu_strdup(pw->pw_name); - INFO_LOG(".............................uid #%u: %u\n", - (unsigned)num_uids, (unsigned)ui->uid); + DEBUG_LOG("opening table for uid %u\n", (unsigned)ui->uid); if (create) { ret = osl(osl_create_table(ui->desc)); if (ret < 0) @@ -268,15 +270,16 @@ err: return ret; } +#define FOR_EACH_USER(ui) for (ui = uid_hash_table; ui < \ + uid_hash_table + uid_hash_table_size; ui++) + int for_each_admissible_user(int (*func)(struct user_info *, void *), void *data) { - struct user_info *ui = uid_hash_table; - - if (!ui) - return -ERRNO_TO_ERROR(EFAULT); + struct user_info *ui; - for (; ui < uid_hash_table + uid_hash_table_size; ui++) { + assert(uid_hash_table); + FOR_EACH_USER(ui) { int ret; if (!ui_used(ui) || !ui_admissible(ui)) @@ -298,30 +301,30 @@ void create_hash_table(unsigned bits) sizeof(struct user_info)); } -static int close_user_table(struct user_info *ui, __a_unused void *data) +void close_user_tables(void) { - int ret; + struct user_info *ui; - ret = osl(osl_close_table(ui->table, OSL_MARK_CLEAN)); - if (ret < 0) - ERROR_LOG("failed to close user table %u: %s\n", - (unsigned) ui->uid, adu_strerror(-ret)); - free((char *)ui->desc->name); - ui->desc->name = NULL; - free((char *)ui->desc->dir); - ui->desc->dir = NULL; - free(ui->pw_name); - ui->pw_name = NULL; - free(ui->desc); - ui->desc = NULL; - ui->table = NULL; - ui->flags = 0; - return 1; -} + FOR_EACH_USER(ui) { + int ret; -void close_user_tables(void) -{ - for_each_admissible_user(close_user_table, NULL); + if (!ui_used(ui)) + continue; + ret = osl(osl_close_table(ui->table, OSL_MARK_CLEAN)); + if (ret < 0) + ERROR_LOG("failed to close user table %u: %s\n", + (unsigned)ui->uid, adu_strerror(-ret)); + free((char *)ui->desc->name); + ui->desc->name = NULL; + free((char *)ui->desc->dir); + ui->desc->dir = NULL; + free(ui->pw_name); + ui->pw_name = NULL; + free(ui->desc); + ui->desc = NULL; + ui->table = NULL; + ui->flags = 0; + } free(uid_hash_table); uid_hash_table = NULL; } @@ -348,38 +351,32 @@ static uint32_t double_hash(uint32_t uid, uint32_t probe_num) % uid_hash_table_size; } -int search_uid(uint32_t uid, struct uid_range *urs, - enum search_uid_flags flags, struct user_info **ui_ptr) +static struct user_info *lookup_uid(uint32_t uid) { uint32_t p; for (p = 0; p < uid_hash_table_size; p++) { struct user_info *ui = uid_hash_table + double_hash(uid, p); - - if (!ui_used(ui)) { - int ret; - if (!flags) - return -E_BAD_UID; - ui->uid = uid; - ui->flags |= UI_FL_SLOT_USED; - if (!uid_is_admissible(uid, urs)) - return 0; - ui->flags |= UI_FL_ADMISSIBLE; - ret = open_user_table(ui, flags & CREATE_USER_TABLE); - if (ret < 0) - return ret; - - if (ui_ptr) - *ui_ptr = ui; - return 1; - } - if (ui->uid != uid) - continue; - if (ui_ptr) - *ui_ptr = ui; - return 0; + if (!ui_used(ui)) + return ui; + if (ui->uid == uid) + return ui; } - return flags? -E_HASH_TABLE_OVERFLOW : -E_BAD_UID; + return NULL; +} + +int create_user_table(uint32_t uid, struct user_info **ui_ptr) +{ + struct user_info *ui = lookup_uid(uid); + + if (!ui) + return -E_HASH_TABLE_OVERFLOW; + *ui_ptr = ui; + if (ui_used(ui)) + return 1; + ui->uid = uid; + ui->flags |= UI_FL_SLOT_USED; + return open_user_table(ui, 1); } static char *get_uid_list_name(void) @@ -402,7 +399,7 @@ int read_uid_file(struct uid_range *admissible_uids) unsigned bits; if (ret < 0) { - INFO_LOG("failed to map %s\n", filename); + ERROR_LOG("failed to map %s\n", filename); free(filename); return ret; } @@ -419,40 +416,47 @@ int read_uid_file(struct uid_range *admissible_uids) create_hash_table(bits); for (n = 0; n < num_uids; n++) { uint32_t uid = read_u32(map + n * sizeof(uid)); - ret = search_uid(uid, admissible_uids, OPEN_USER_TABLE, NULL); - if (ret < 0) + struct user_info *ui = lookup_uid(uid); + assert(ui); + if (ui_used(ui)) { /* impossible */ + ERROR_LOG("duplicate user id!?\n"); + ret =-EFAULT; goto out; + } + ui->uid = uid; + ui->flags |= UI_FL_SLOT_USED; + if (!uid_is_admissible(uid, admissible_uids)) + continue; + ui->flags |= UI_FL_ADMISSIBLE; + ret = open_user_table(ui, 0); + if (ret < 0) + return ret; } + ret = 1; out: adu_munmap(map, size); return ret; } -static int write_uid(struct user_info *ui, void *data) -{ - char **p = data; - - write_u32(*p, ui->uid); - *p += sizeof(uint32_t); - return 1; -} - int write_uid_file(void) { char *buf, *p, *filename; size_t size = num_uids * sizeof(uint32_t); int ret; + struct user_info *ui; if (!num_uids) return 0; buf = p = adu_malloc(size); - ret = for_each_admissible_user(write_uid, &p); - if (ret < 0) - goto out; + FOR_EACH_USER(ui) { + if (!ui_used(ui)) + continue; + write_u32(p, ui->uid); + p += sizeof(uint32_t); + } filename = get_uid_list_name(); ret = adu_write_file(filename, buf, size); free(filename); -out: free(buf); return ret; } diff --git a/user.h b/user.h index 31f3a62..aa07acc 100644 --- a/user.h +++ b/user.h @@ -33,13 +33,7 @@ struct user_info { /** An opaque struct that contains info about which users are admissible. */ struct uid_range; -enum search_uid_flags { - OPEN_USER_TABLE = 1, - CREATE_USER_TABLE = 2, -}; -int search_uid(uint32_t uid, struct uid_range *urs, - enum search_uid_flags flags, struct user_info **ui_ptr); - +int create_user_table(uint32_t uid, struct user_info **ui_ptr); int read_uid_file(struct uid_range *admissible_uids); int write_uid_file(void); -- 2.39.2