X-Git-Url: http://git.tuebingen.mpg.de/?p=adu.git;a=blobdiff_plain;f=adu.c;h=dd74ca46f4932ec39a89d070092eb4705f5cbfe5;hp=b311a386690de22071921950cb7a35b29d3d3b2f;hb=5008f98a8208d96c3c777476d6df7534c6d2ca49;hpb=df32293ac0a021f4d46c924e842c2d89a2463ae6 diff --git a/adu.c b/adu.c index b311a38..dd74ca4 100644 --- a/adu.c +++ b/adu.c @@ -1,118 +1,76 @@ +/* + * Copyright (C) 2008 Andre Noll + * + * Licensed under the GPL v2. For licencing details see COPYING. + */ + +/** \file adu.c \brief The main functions used by all modes of operation. */ + +/** + * \mainpage adu API reference + * + * - Modes of operation: \ref select.c, \ref create.c, \ref interactive.c + * - User handling: \ref user.c + * - Error handling: \ref error.h + * - Library-type functions: \ref fd.c, \ref format.c, \ref string.c, \ref portable_io.h + */ + #include "adu.h" #include /* readdir() */ - -#include "gcc-compat.h" -#include "osl.h" +#include +#include "format.h" +#include "user.h" +#include "select.cmdline.h" +#include "select.h" +#include "cmdline.h" #include "fd.h" -#include "hash.h" #include "string.h" #include "error.h" +/** Define the array of error descriptions. */ DEFINE_ERRLIST; -/** evaluates to 1 if x < y, to -1 if x > y and to 0 if x == y */ -#define NUM_COMPARE(x, y) ((int)((x) < (y)) - (int)((x) > (y))) - - /** - * The log function. - * - * \param ll Loglevel. - * \param fml Usual format string. + * The error code of the last called osl library function. * - * All XXX_LOG() macros use this function. + * \sa osl(). */ -__printf_2_3 void __log(int ll, const char* fmt,...) -{ - va_list argp; - FILE *outfd; - struct tm *tm; - time_t t1; - char str[255] = ""; +int osl_errno; - if (ll < 4) - return; - outfd = stderr; - time(&t1); - tm = localtime(&t1); - strftime(str, sizeof(str), "%b %d %H:%M:%S", tm); - fprintf(outfd, "%s ", str); - va_start(argp, fmt); - vfprintf(outfd, fmt, argp); - va_end(argp); -} +/** In case a signal is received, its number is stored here. */ +static int signum; -/** - * Compare the size of two directories - * - * \param obj1 Pointer to the first object. - * \param obj2 Pointer to the second object. - * - * This function first compares the size values as usual integers. If they compare as - * equal, the address of \a obj1 and \a obj2 are compared. So this compare function - * returns zero if and only if \a obj1 and \a obj2 point to the same memory area. - */ -static int size_compare(const struct osl_object *obj1, const struct osl_object *obj2) -{ - uint64_t d1 = *(uint64_t *)obj1->data; - uint64_t d2 = *(uint64_t *)obj2->data; - int ret = NUM_COMPARE(d2, d1); +/** Command line and config file options. */ +struct gengetopt_args_info conf; + +/** Options passed to --select-options. */ +struct select_args_info select_conf; - if (ret) - return ret; - //INFO_LOG("addresses: %p, %p\n", obj1->data, obj2->data); - return NUM_COMPARE(obj2->data, obj1->data); -} /** - * Compare two osl objects of string type. - * - * \param obj1 Pointer to the first object. - * \param obj2 Pointer to the second object. - * - * In any case, only \p MIN(obj1->size, obj2->size) characters of each string - * are taken into account. - * - * \return It returns an integer less than, equal to, or greater than zero if - * \a obj1 is found, respectively, to be less than, to match, or be greater than - * obj2. - * - * \sa strcmp(3), strncmp(3), osl_compare_func. + * The table containing the directory names and statistics. */ -int string_compare(const struct osl_object *obj1, const struct osl_object *obj2) -{ - const char *str1 = (const char *)obj1->data; - const char *str2 = (const char *)obj2->data; - return strncmp(str1, str2, MIN(obj1->size, obj2->size)); -} - -/** The columns of the directory table. */ -enum dir_table_columns { - /** The name of the directory. */ - DT_NAME, - /** The dir count number. */ - DT_NUM, - /** The number of bytes of all regular files. */ - DT_BYTES, - /** The number of all regular files. */ - DT_FILES, - /** Number of columns in this table. */ - NUM_DT_COLUMNS -}; +struct osl_table *dir_table = NULL; static struct osl_column_description dir_table_cols[] = { [DT_NAME] = { .storage_type = OSL_MAPPED_STORAGE, - .storage_flags = OSL_RBTREE | OSL_UNIQUE, + .storage_flags = 0, .name = "dir", - .compare_function = string_compare, }, [DT_NUM] = { .storage_type = OSL_MAPPED_STORAGE, .storage_flags = OSL_RBTREE | OSL_FIXED_SIZE | OSL_UNIQUE, .name = "num", - .compare_function = uint32_compare, - .data_size = sizeof(uint32_t) + .compare_function = uint64_compare, + .data_size = sizeof(uint64_t) + }, + [DT_PARENT_NUM] = { + .storage_type = OSL_MAPPED_STORAGE, + .storage_flags = OSL_RBTREE | OSL_FIXED_SIZE | OSL_UNIQUE, + .name = "parent_num", + .compare_function = size_compare, + .data_size = sizeof(uint64_t) }, [DT_BYTES] = { .storage_type = OSL_MAPPED_STORAGE, @@ -135,511 +93,221 @@ static struct osl_table_description dir_table_desc = { .num_columns = NUM_DT_COLUMNS, .flags = 0, .column_descriptions = dir_table_cols, - .dir = "/tmp/adu" }; -/** The columns of the id table. */ -enum id_table_columns { - /** The user id. */ - IDT_UID, - /** The number of bytes of all regular files owned by this id. */ - IDT_BYTES, - /** The number of regular files owned by this id. */ - IDT_FILES, - /** The user table for this uid. */ - IDT_TABLE, - /** Number of columns in this table. */ - NUM_IDT_COLUMNS -}; - -static struct osl_column_description id_table_cols[] = { - [IDT_UID] = { - .storage_type = OSL_MAPPED_STORAGE, - .storage_flags = OSL_RBTREE | OSL_FIXED_SIZE | OSL_UNIQUE, - .name = "uid", - .compare_function = uint32_compare, - .data_size = sizeof(uint32_t) - }, - [IDT_BYTES] = { - .storage_type = OSL_MAPPED_STORAGE, - .storage_flags = OSL_RBTREE | OSL_FIXED_SIZE, - .compare_function = size_compare, - .name = "num_bytes", - .data_size = sizeof(uint64_t) - }, - [IDT_FILES] = { - .storage_type = OSL_MAPPED_STORAGE, - .storage_flags = OSL_RBTREE | OSL_FIXED_SIZE, - .compare_function = size_compare, - .name = "num_filess", - .data_size = sizeof(uint64_t) - }, - [IDT_TABLE] = { - .storage_type = OSL_NO_STORAGE, - .storage_flags = OSL_FIXED_SIZE | OSL_UNIQUE, - .name = "user_table", - .data_size = sizeof(void *) - } -}; - -static struct osl_table_description id_table_desc = { - .name = "id_table", - .num_columns = NUM_IDT_COLUMNS, - .flags = 0, - .column_descriptions = id_table_cols, - .dir = "/tmp/adu" -}; - -/** The columns of the id table. */ -enum user_table_columns { - /** The numer of the directory. */ - UT_DIR_NUM, - /** The number of bytes of all regular files in this dir owned by this id. */ - UT_BYTES, - /** The number of files in this dir owned by this id. */ - UT_FILES, - /** Number of columns in this table. */ - NUM_UT_COLUMNS -}; - -static struct osl_column_description user_table_cols[] = { - [UT_DIR_NUM] = { - .storage_type = OSL_MAPPED_STORAGE, - .storage_flags = OSL_RBTREE | OSL_FIXED_SIZE | OSL_UNIQUE, - .name = "dir_num", - .compare_function = uint32_compare, - .data_size = sizeof(uint32_t) - }, - [IDT_BYTES] = { - .storage_type = OSL_MAPPED_STORAGE, - .storage_flags = OSL_RBTREE | OSL_FIXED_SIZE, - .compare_function = size_compare, - .name = "num_bytes", - .data_size = sizeof(uint64_t) - }, - [IDT_FILES] = { - .storage_type = OSL_MAPPED_STORAGE, - .storage_flags = OSL_RBTREE | OSL_FIXED_SIZE, - .compare_function = size_compare, - .name = "num_files", - .data_size = sizeof(uint64_t) - }, -}; - -static struct osl_table_description user_table_desc = { - .num_columns = NUM_UT_COLUMNS, - .flags = 0, - .column_descriptions = user_table_cols, - .dir = "/tmp/adu" -}; -static struct osl_table *dir_table; -static struct osl_table *id_table; - -static int create_tables(void) +/** + * The log function. + * + * \param ll Loglevel. + * \param fmt Usual format string. + * + * All XXX_LOG() macros use this function. + */ +__printf_2_3 void __log(int ll, const char* fmt,...) { - int ret = osl_create_table(&dir_table_desc); - if (ret < 0) - return ret; - ret = osl_create_table(&id_table_desc); - if (ret < 0) - return ret; - return 1; -} + va_list argp; + FILE *outfd; + struct tm *tm; + time_t t1; + char str[255] = ""; -int add_directory(char *dirname, uint32_t dir_num, uint64_t *dir_size, - uint64_t *dir_files) -{ - struct osl_object dir_objects[NUM_DT_COLUMNS]; - - INFO_LOG("adding #%u: %s\n", dir_num, dirname); - dir_objects[DT_NAME].data = dirname; - dir_objects[DT_NAME].size = strlen(dirname) + 1; - dir_objects[DT_NUM].data = &dir_num; - dir_objects[DT_NUM].size = sizeof(dir_num); - dir_objects[DT_BYTES].data = dir_size; - dir_objects[DT_BYTES].size = sizeof(*dir_size); - dir_objects[DT_FILES].data = dir_files; - dir_objects[DT_FILES].size = sizeof(*dir_files); - - return osl_add_row(dir_table, dir_objects); + if (ll < conf.loglevel_arg) + return; + outfd = stderr; + time(&t1); + tm = localtime(&t1); + strftime(str, sizeof(str), "%b %d %H:%M:%S", tm); + fprintf(outfd, "%s ", str); + va_start(argp, fmt); + vfprintf(outfd, fmt, argp); + va_end(argp); } -int create_and_open_user_table(uint32_t uid, struct osl_table **t) +static void close_dir_table(void) { int ret; - struct osl_table_description *desc = para_malloc(sizeof(*desc)); - - desc->num_columns = NUM_UT_COLUMNS; - desc->flags = 0; - desc->column_descriptions = user_table_cols; - desc->dir = para_strdup("/tmp/adu"); - desc->name = make_message("%u", uid); - INFO_LOG("................................. %u\n", uid); -// user_table_desc.name = make_message("%u", uid); - ret = osl_create_table(desc); - if (ret < 0) - return ret; - return osl_open_table(desc, t); -} - -static int insert_id_row(uint32_t uid, struct osl_table *t, struct osl_row **row) -{ - struct osl_object objects[NUM_IDT_COLUMNS]; - uint64_t num = 0; - - struct osl_table **table_ptr = para_malloc(sizeof(*table_ptr)); - *table_ptr = t; - - INFO_LOG("§§§§§§§§§§§§§§§§§§§§§ uid: %d, t: %p\n", uid, t); - objects[IDT_UID].data = &uid; - objects[IDT_UID].size = sizeof(uid); - objects[IDT_BYTES].data = # - objects[IDT_BYTES].size = sizeof(num); - objects[IDT_FILES].data = # - objects[IDT_FILES].size = sizeof(num); - objects[IDT_TABLE].data = table_ptr; - objects[IDT_TABLE].size = sizeof(*table_ptr); - return osl_add_and_get_row(id_table, objects, row); -} -static int get_user_table(struct osl_row *row, struct osl_table **t) -{ - struct osl_object obj; - - int ret = osl_get_object(id_table, row, IDT_TABLE, &obj); - if (ret < 0) - return ret; - *t = *(struct osl_table **)obj.data; - INFO_LOG("^^^^^^^^^^^^^^^^^^ t: %p\n", *t); - return 1; -} - -static int add_id_bytes(struct osl_row *row, uint64_t *add) -{ - uint64_t num; - struct osl_object obj1, obj2 = {.data = &num, .size = sizeof(num)}; - - /* update number of bytes */ - int ret = osl_get_object(id_table, row, IDT_BYTES, &obj1); - if (ret < 0) - return ret; - num = *(uint64_t *)obj1.data + *add; - ret = osl_update_object(id_table, row, IDT_BYTES, &obj2); - if (ret < 0) - return ret; - /* increment number of files */ - ret = osl_get_object(id_table, row, IDT_FILES, &obj1); + if (!dir_table) + return; + NOTICE_LOG("closing dir table\n"); + ret = osl(osl_close_table(dir_table, OSL_MARK_CLEAN)); if (ret < 0) - return ret; - num = *(uint64_t *)obj1.data + 1; - return osl_update_object(id_table, row, IDT_FILES, &obj2); + ERROR_LOG("failed to close dir table: %s\n", adu_strerror(-ret)); + free((char *)dir_table_desc.dir); + dir_table = NULL; } -static int update_user_row(struct osl_table *t, uint32_t dir_num, - uint64_t *add) +static void close_all_tables(void) { - struct osl_row *row; - struct osl_object obj = {.data = &dir_num, .size = sizeof(dir_num)}; - - int ret = osl_get_row(t, UT_DIR_NUM, &obj, &row); - - if (ret < 0 && ret != -E_RB_KEY_NOT_FOUND) - return ret; - if (ret < 0) { /* this is the first file we add */ - struct osl_object objects[NUM_UT_COLUMNS]; - uint64_t num_files = 1; - - objects[UT_DIR_NUM].data = &dir_num; - objects[UT_DIR_NUM].size = sizeof(dir_num); - objects[UT_BYTES].data = add; - 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_add_row(t, objects); - INFO_LOG("######################### ret: %d\n", ret); - return ret; - } else { /* add size and increment file count */ - uint64_t num; - struct osl_object obj1, obj2 = {.data = &num, .size = sizeof(num)}; - - ret = osl_get_object(t, row, UT_BYTES, &obj1); - if (ret < 0) - return ret; - num = *(uint64_t *)obj1.data + *add; - ret = osl_update_object(t, row, UT_BYTES, &obj2); - if (ret < 0) - return ret; - ret = osl_get_object(t, row, UT_FILES, &obj1); - if (ret < 0) - return ret; - num = *(uint64_t *)obj1.data + 1; - return osl_update_object(t, row, UT_FILES, &obj2); - } + close_dir_table(); + close_user_tables(); } -static uint32_t dir_num; - -int scan_dir(char *dirname) +static void signal_handler(int s) { - DIR *dir; - struct dirent *entry; - int ret, cwd_fd, ret2; - uint64_t dir_size = 0, dir_files = 0; - struct osl_object obj; - - INFO_LOG("----------------- %s\n", dirname); - ret = para_opendir(dirname, &dir, &cwd_fd); - if (ret < 0) { - if (ret != -ERRNO_TO_ERROR(EACCES)) - return ret; - WARNING_LOG("permission denied for %s\n", dirname); - return 1; - } - while ((entry = readdir(dir))) { - mode_t m; - char *tmp; - struct stat s; - uint32_t uid; - uint64_t size; - struct osl_row *id_row; - struct osl_table *user_table; - - if (!strcmp(entry->d_name, ".")) - continue; - if (!strcmp(entry->d_name, "..")) - continue; - if (lstat(entry->d_name, &s) == -1) - continue; - m = s.st_mode; - if (!S_ISREG(m) && !S_ISDIR(m)) - continue; - tmp = make_message("%s/%s", dirname, entry->d_name); - if (S_ISDIR(m)) { - ret = scan_dir(tmp); - free(tmp); - if (ret < 0) - goto out; - continue; - } - /* regular file */ - size = s.st_size; - dir_size += size; - dir_files++; - uid = s.st_uid; - INFO_LOG("++++++++++++++++++++++++++ %s, uid: %u\n", entry->d_name, uid); - obj.data = &uid; - obj.size = sizeof(uid); - ret = osl_get_row(id_table, IDT_UID, &obj, &id_row); - if (ret < 0 && ret != -E_RB_KEY_NOT_FOUND) - goto out; - if (ret < 0) { - ret = create_and_open_user_table(uid, &user_table); - if (ret < 0) - goto out; - ret = insert_id_row(uid, user_table, &id_row); - if (ret < 0) - goto out; - } else { - ret = get_user_table(id_row, &user_table); - if (ret < 0) - goto out; - } - ret = add_id_bytes(id_row, &size); - if (ret < 0) - goto out; - INFO_LOG("user_table: %p\n", user_table); - ret = update_user_row(user_table, dir_num, &size); - INFO_LOG("update_user ret: %d\n", ret); - if (ret < 0) - goto out; - } - ret = add_directory(dirname, dir_num++, &dir_size, &dir_files); -out: - closedir(dir); - ret2 = para_fchdir(cwd_fd); - if (ret2 < 0 && ret >= 0) - ret = ret2; - close(cwd_fd); - return ret; + signum = s; } -static int get_dir_name(struct osl_row *row, char **name) -{ - struct osl_object obj; - int ret = osl_get_object(dir_table, row, DT_NAME, &obj); - - if (ret < 0) - return ret; - *name = obj.data; - return 1; -} - -static int print_dirname_and_size(struct osl_row *row, void *data) +/** + * Check whether to terminate adu. + * + * Check whether a signal was caught that should terminate the + * adu process. If yes, close all osl tables and exit gracefully. + */ +void check_signals(void) { - unsigned *count = data; - struct osl_object obj; - char *name; - int ret; - - if ((*count)++ > 100) - return -E_LOOP_COMPLETE; - ret = get_dir_name(row, &name); - if (ret < 0) - return ret; - ret = osl_get_object(dir_table, row, DT_BYTES, &obj); - if (ret < 0) - return ret; - printf("%s\t%llu\n", name, *(long long unsigned *)obj.data); - return 1; + if (likely(!signum)) + return; + EMERG_LOG("caught signal %d\n", signum); + close_all_tables(); + exit(EXIT_FAILURE); } -static int print_dirname_and_file_count(struct osl_row *row, void *data) +static int init_signals(void) { - unsigned *count = data; - struct osl_object obj; - char *name; - int ret; - - if ((*count)++ > 100) - return -E_LOOP_COMPLETE; - ret = get_dir_name(row, &name); - if (ret < 0) - return ret; - ret = osl_get_object(dir_table, row, DT_FILES, &obj); - if (ret < 0) - return ret; - printf("%s\t%llu\n", name, *(long long unsigned *)obj.data); + if (signal(SIGINT, &signal_handler) == SIG_ERR) + return -E_SIGNAL_SIG_ERR; + if (signal(SIGTERM, &signal_handler) == SIG_ERR) + return -E_SIGNAL_SIG_ERR; + if (signal(SIGPIPE, &signal_handler) == SIG_ERR) + return -E_SIGNAL_SIG_ERR; return 1; } -static int print_id_stats(struct osl_row *row, __a_unused void *data) +/** + * Open the directory table. + * + * \param create If non-zero, create the table first. + * + * \return Standard. + */ +int open_dir_table(int create) { - struct osl_object obj; - uint32_t uid; - uint64_t bytes, files; - int ret = osl_get_object(id_table, row, IDT_UID, &obj); - if (ret < 0) - return ret; - uid = *(uint32_t *)obj.data; - ret = osl_get_object(id_table, row, IDT_BYTES, &obj); - if (ret < 0) - return ret; - bytes = *(uint64_t *)obj.data; - ret = osl_get_object(id_table, row, IDT_FILES, &obj); - if (ret < 0) - return ret; - files = *(uint64_t *)obj.data; + if (dir_table) + return 1; + dir_table_desc.dir = adu_strdup(conf.database_dir_arg); - printf("%u\t%llu\t%llu\n", (unsigned)uid, (long long unsigned)files, - (long long unsigned)bytes); - return 1; + if (create) { + NOTICE_LOG("creating dir table\n"); + int ret = osl(osl_create_table(&dir_table_desc)); + if (ret < 0) { + free((char *)dir_table_desc.dir); + return ret; + } + } + INFO_LOG("opening dir table\n"); + return osl(osl_open_table(&dir_table_desc, &dir_table)); } -struct id_dir_stat_info { - unsigned count; - struct osl_table *user_table; -}; - -static int print_big_dir(struct osl_row *row, void *data) +static int check_args(void) { - struct id_dir_stat_info *info = data; - info->count++; - int ret; - struct osl_row *dir_row; - char *dirname; - uint64_t bytes; - struct osl_object obj; - - if (info->count > 10) - return -E_LOOP_COMPLETE; - ret = osl_get_object(info->user_table, row, UT_BYTES, &obj); - if (ret < 0) - return ret; - bytes = *(uint64_t *)obj.data; - ret = osl_get_object(info->user_table, row, UT_DIR_NUM, &obj); - if (ret < 0) - return ret; - ret = osl_get_row(dir_table, DT_NUM, &obj, &dir_row); - if (ret < 0) - return ret; - ret = osl_get_object(dir_table, dir_row, DT_NAME, &obj); - if (ret < 0) - return ret; - dirname = obj.data; - printf("%s: %llu\n", dirname, (long long unsigned)bytes); + if (conf.create_given && !conf.base_dir_given) + return -E_SYNTAX; + + /* remove trailing slashes from base-dir arg */ + if (conf.base_dir_given) { + size_t len = strlen(conf.base_dir_arg); + for (;;) { + if (!len) /* empty string */ + return -ERRNO_TO_ERROR(EINVAL); + if (!--len) /* length 1 is always OK */ + break; + if (conf.base_dir_arg[len] != '/') + break; /* no trailing slash, also OK */ + conf.base_dir_arg[len] = '\0'; + } + } return 1; } -static int print_id_dir_stats(struct osl_row *row, __a_unused void *data) +static int print_complete_help_and_die(void) { - struct osl_object obj; - uint32_t uid; - int ret = osl_get_object(id_table, row, IDT_UID, &obj); - struct id_dir_stat_info info = {.count = 0}; - - if (ret < 0) - return ret; - uid = *(uint32_t *)obj.data; - - ret = osl_get_object(id_table, row, IDT_TABLE, &obj); - if (ret < 0) - return ret; - info.user_table = *(struct osl_table **)obj.data; - - printf("************************* Big dirs owned by uid %u\n", (unsigned) uid); - osl_rbtree_loop_reverse(info.user_table, IDT_BYTES, &info, print_big_dir); - return 1; + const char **line; + + printf("%s-%s\n", CMDLINE_PARSER_PACKAGE, CMDLINE_PARSER_VERSION); + printf("%s\n\n", gengetopt_args_info_purpose); + printf("%s\n\n", gengetopt_args_info_usage); + + if (conf.help_given) + line = gengetopt_args_info_help; + else + line = gengetopt_args_info_detailed_help; + for (; *line; line++) + printf("%s\n", *line); + + if (conf.help_given) + line = select_args_info_help; + else + line = select_args_info_detailed_help; + printf("Select options:\n"); + for (; *line; line++) + printf("%s\n", *line); + + printf("Interactive commands:\n"); + print_interactive_help(); + cmdline_parser_free(&conf); + select_cmdline_parser_free(&select_conf); + exit(EXIT_FAILURE); } -static int print_statistics(void) +/** + * The main function of adu. + * + * \param argc Usual argument count. + * \param argv Usual argument vector. + * + * Check command line options, init the signal handlers and + * call the main function of the selected mode. + * + * \return \p EXIT_SUCCESS on success, \p EXIT_FAILURE otherwise. + */ +int main(int argc, char **argv) { - unsigned count = 0; int ret; + struct cmdline_parser_params params = { + .override = 1, + .initialize = 1, + .check_required = 0, + .check_ambiguity = 0, + .print_errors = 0 + }; + select_cmdline_parser_init(&select_conf); + cmdline_parser_init(&conf); + /* ignore errors and print complete help if --help was given */ + cmdline_parser_ext(argc, argv, &conf, ¶ms); + if (conf.help_given || conf.detailed_help_given) + print_complete_help_and_die(); + cmdline_parser_free(&conf); + params.check_required = 1; + params.check_ambiguity = 1; + params.print_errors = 1; + ret = cmdline_parser_ext(argc, argv, &conf, ¶ms); + if (ret) + exit(EXIT_FAILURE); - printf("************************* Biggest dirs\n"); - ret = osl_rbtree_loop_reverse(dir_table, DT_BYTES, &count, print_dirname_and_size); - if (ret < 0 && ret != -E_LOOP_COMPLETE) - return ret; - count = 0; - printf("************************* dirs containing many files\n"); - ret = osl_rbtree_loop_reverse(dir_table, DT_FILES, &count, print_dirname_and_file_count); - if (ret < 0 && ret != -E_LOOP_COMPLETE) - return ret; - - printf("************************* dirs stats by owner\n"); - ret = osl_rbtree_loop(id_table, IDT_BYTES, NULL, print_id_stats); - if (ret < 0) - return ret; - - return osl_rbtree_loop(id_table, IDT_BYTES, NULL, print_id_dir_stats); -} - - -int main(int argc, char **argv) -{ - int ret = create_tables(); - if (ret < 0) - goto out; - ret = osl_open_table(&dir_table_desc, &dir_table); + ret = check_args(); if (ret < 0) goto out; - ret = osl_open_table(&id_table_desc, &id_table); + ret = init_signals(); if (ret < 0) goto out; ret = -E_SYNTAX; - if (argc != 2) - goto out; - ret = scan_dir(argv[1]); + if (conf.select_given) + ret = com_select(); + else if (conf.create_given) + ret = com_create(); + else + ret = com_interactive(); if (ret < 0) goto out; - print_statistics(); out: + close_all_tables(); if (ret < 0) { - ERROR_LOG("%s\n", error_txt(-ret)); + ERROR_LOG("%s\n", adu_strerror(-ret)); return -EXIT_FAILURE; } + cmdline_parser_free(&conf); + select_cmdline_parser_free(&select_conf); return EXIT_SUCCESS; } -