X-Git-Url: http://git.tuebingen.mpg.de/?p=adu.git;a=blobdiff_plain;f=user.c;h=dfa1c103a9211e1a78e5e0502b0537e4a22cb885;hp=8959c847b0b2069c76965850fc2acc07a8cfa097;hb=d623adf133aaaee36091b840b8644c1884cd970c;hpb=3bb9b0ca535be1eb28b64972bdf0e205e6afc93e diff --git a/user.c b/user.c index 8959c84..dfa1c10 100644 --- a/user.c +++ b/user.c @@ -10,7 +10,6 @@ #include /* readdir() */ #include #include -#include "cmdline.h" /* TODO: This file should be independent of command line options */ #include "user.h" #include "fd.h" #include "string.h" @@ -52,9 +51,6 @@ 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; -/* Array of indices to the entries of \a uid_hash_table. */ -static int *uid_hash_table_sort_idx; - /** The number of used slots in the hash table. */ static uint32_t num_uids; @@ -261,7 +257,7 @@ static inline int ui_admissible(struct user_info *ui) return ui->flags & UI_FL_ADMISSIBLE; } -static int open_user_table(struct user_info *ui, int create) +static int open_user_table(const char *dirname, struct user_info *ui, int create) { int ret; struct passwd *pw; @@ -270,7 +266,7 @@ static int open_user_table(struct user_info *ui, int create) ui->desc->num_columns = NUM_UT_COLUMNS; ui->desc->flags = 0; ui->desc->column_descriptions = user_table_cols; - ui->desc->dir = adu_strdup(conf.database_dir_arg); + ui->desc->dir = adu_strdup(dirname); ui->desc->name = make_message("%u", (unsigned)ui->uid); pw = getpwuid(ui->uid); if (pw && pw->pw_name) @@ -325,8 +321,7 @@ int for_each_admissible_user(int (*func)(struct user_info *, void *), assert(uid_hash_table); for (i = 0; i < uid_hash_table_size; i++) { int ret; - struct user_info *ui = uid_hash_table + - uid_hash_table_sort_idx[i]; + struct user_info *ui = uid_hash_table + i; if (!ui_used(ui) || !ui_admissible(ui)) continue; @@ -337,21 +332,29 @@ int for_each_admissible_user(int (*func)(struct user_info *, void *), return 1; } +/** Prime number used for calculating the slot for an uid. */ #define PRIME1 0xb11924e1 +/** Prime number used for probe all slots. */ #define PRIME2 0x01000193 +/** + * Create a hash table large enough of given size. + * + * \param bits Sets the maximal number of hash table entries to ^bits. + */ void create_hash_table(unsigned bits) { - int i; - uid_hash_table_size = 1 << bits; uid_hash_table = adu_calloc(uid_hash_table_size * sizeof(struct user_info)); - uid_hash_table_sort_idx = adu_malloc(uid_hash_table_size * sizeof(int)); - for (i = 0; i < uid_hash_table_size; i++) - uid_hash_table_sort_idx[i] = i; } +/** + * Close all open user tables and destroy the uid hash table. + * + * For each used slot in the uid hash table, close the osl user table if it is + * open. Finally, free the uid hash table. + */ void close_user_tables(void) { struct user_info *ui; @@ -381,8 +384,6 @@ void close_user_tables(void) } free(uid_hash_table); uid_hash_table = NULL; - free(uid_hash_table_sort_idx); - uid_hash_table_sort_idx = NULL; } /* @@ -421,7 +422,21 @@ static struct user_info *lookup_uid(uint32_t uid) return NULL; } -int create_user_table(uint32_t uid, struct user_info **ui_ptr) +/** + * Create and open a osl table for the given uid. + * + * \param uid The user ID. + * \param ui_ptr Result pointer + * + * Find out whether \a uid already exists in the uid hash table. If yes, just + * return the user info struct via \a ui_ptr. Otherwise, insert \a uid into the + * uid hash table, create and open the osl user table and also return the user + * info struct via \a ui_ptr. + * + * \return Standard. + */ +int create_user_table(const char *dirname, uint32_t uid, + struct user_info **ui_ptr) { struct user_info *ui = lookup_uid(uid); @@ -432,31 +447,30 @@ int create_user_table(uint32_t uid, struct user_info **ui_ptr) return 1; ui->uid = uid; ui->flags |= UI_FL_SLOT_USED; - return open_user_table(ui, 1); -} - -static char *get_uid_list_name(void) -{ - return make_message("%s/uid_list", conf.database_dir_arg); -} - -static int (*hash_table_comparator)(struct user_info *a, struct user_info *b); - -static int comp_wrapper(const void *a, const void *b) -{ - struct user_info *x = uid_hash_table + *(unsigned *)a; - struct user_info *y = uid_hash_table + *(unsigned *)b; - return hash_table_comparator(x, y); + return open_user_table(dirname, ui, 1); } -void sort_hash_table(int (*comp)(struct user_info *, struct user_info *)) +static char *get_uid_list_name(const char *dirname) { - hash_table_comparator = comp; - qsort(uid_hash_table_sort_idx, uid_hash_table_size, - sizeof(*uid_hash_table_sort_idx), comp_wrapper); + return make_message("%s/uid_list", dirname); } - -int open_admissible_user_tables(struct uid_range *admissible_uids) +/** + * Open the osl tables for all admissible uids. + * + * \param admissible_uids Determines which uids are considered admissible. + * + * Each slot in the hash table contains, among other information, a bit which + * specifies whether the uid of the slot is admissible in the current context. + * + * This function iterates over all entries in the hash table and checks for + * each used slot whether the corresponding uid is admissible with respect to + * \a admissible_uids. If so, it sets the admissible bit for this slot and + * opens the osl table of the uid. + * + * \return Stamdard. + */ +int open_admissible_user_tables(const char *dirname, + struct uid_range *admissible_uids) { struct user_info *ui; @@ -475,18 +489,30 @@ int open_admissible_user_tables(struct uid_range *admissible_uids) ui->flags |= UI_FL_ADMISSIBLE; if (ui->table) continue; - ret = open_user_table(ui, 0); + ret = open_user_table(dirname, ui, 0); if (ret < 0) return ret; } return 1; } -int read_uid_file(void) +/** + * Read the file of all possible uids. + * + * This is called from select/interactive mode. First a large hash table, large + * enough to store all uids contained in the uid file is created. Next, the + * uids are read from the uid file which was created during the creation of the + * database and each uid is inserted into the hash table. + * + * \sa write_uid_file(). + * + * \return Standard. + */ +int read_uid_file(const char *dirname) { size_t size; uint32_t n; - char *filename = get_uid_list_name(), *map; + char *filename = get_uid_list_name(dirname), *map; int ret = mmap_full_file(filename, O_RDONLY, (void **)&map, &size, NULL); unsigned bits; @@ -524,7 +550,19 @@ out: return ret; } -int write_uid_file(void) +/** + * Write the list of uids to permanent storage. + * + * This is called from create mode after the dir table and all uer tables have + * been created. The file simply contains the list of all uids that own at + * least one regular file in the base directory and hence an osl table for this + * uid exists. + * + * \sa read_uid_file(). + * + * \return Standard. + */ +int write_uid_file(const char *dirname) { char *buf, *p, *filename; size_t size = num_uids * sizeof(uint32_t); @@ -540,7 +578,7 @@ int write_uid_file(void) write_u32(p, ui->uid); p += sizeof(uint32_t); } - filename = get_uid_list_name(); + filename = get_uid_list_name(dirname); ret = adu_write_file(filename, buf, size); free(filename); free(buf);