select.c

   1 /*
   2  * Copyright (C) 2008 Andre Noll <maan@systemlinux.org>
   3  *
   4  * Licensed under the GPL v2. For licencing details see COPYING.
   5  */
   6
   7 /** \file select.c The select mode of adu. */
   8
   9 #include <dirent.h> /* readdir() */
  10 #include "format.h"
  11 #include "adu.h"
  12 #include "gcc-compat.h"
  13 #include "cmdline.h"
  14 #include "fd.h"
  15 #include "string.h"
  16 #include "error.h"
  17 #include "user.h"
  18 #include "select.cmdline.h"
  19
  20 /* global list */
  21 #define GLOBAL_LIST_ATOMS \
  22         ATOM(size, SIZE) \
  23         ATOM(files, COUNT) \
  24         ATOM(dirname, STRING) \
  25
  26 #define ATOM(x, y) { .name = #x, .type = AT_ ## y},
  27 struct atom global_list_atoms[] = {
  28         GLOBAL_LIST_ATOMS
  29         {.name = NULL}
  30 };
  31 #undef ATOM
  32 #define ATOM(x, y) gla_ ## x,
  33 enum global_list_atoms {GLOBAL_LIST_ATOMS};
  34 #undef ATOM
  35
  36 /* global summary */
  37 #define GLOBAL_SUMMARY_ATOMS \
  38         ATOM(dirs, COUNT) \
  39         ATOM(files, COUNT) \
  40         ATOM(size, SIZE)
  41
  42 #define ATOM(x, y) { .name = #x, .type = AT_ ## y},
  43 struct atom global_summary_atoms[] = {
  44         GLOBAL_SUMMARY_ATOMS
  45         {.name = NULL}
  46 };
  47 #undef ATOM
  48 #define ATOM(x, y) gsa_ ## x,
  49 enum global_summary_atoms {GLOBAL_SUMMARY_ATOMS};
  50 #undef ATOM
  51
  52 /* user list */
  53 #define USER_LIST_ATOMS \
  54         ATOM(pw_name, STRING) \
  55         ATOM(uid, ID) \
  56         ATOM(size, SIZE) \
  57         ATOM(files, COUNT) \
  58         ATOM(dirname, STRING) \
  59
  60 #define ATOM(x, y) { .name = #x, .type = AT_ ## y},
  61 struct atom user_list_atoms[] = {
  62         USER_LIST_ATOMS
  63         {.name = NULL}
  64 };
  65 #undef ATOM
  66 #define ATOM(x, y) ula_ ## x,
  67 enum user_list_atoms {USER_LIST_ATOMS};
  68 #undef ATOM
  69
  70 /* user list header */
  71 #define USER_LIST_HEADER_ATOMS \
  72         ATOM(pw_name, STRING) \
  73         ATOM(uid, ID)
  74
  75 #define ATOM(x, y) { .name = #x, .type = AT_ ## y},
  76 struct atom user_list_header_atoms[] = {
  77         USER_LIST_HEADER_ATOMS
  78         {.name = NULL}
  79 };
  80 #undef ATOM
  81 #define ATOM(x, y) ulha_ ## x,
  82 enum user_list_header_atoms {USER_LIST_HEADER_ATOMS};
  83 #undef ATOM
  84
  85 /* user summary */
  86 #define USER_SUMMARY_ATOMS \
  87         ATOM(pw_name, STRING) \
  88         ATOM(uid, ID) \
  89         ATOM(dirs, COUNT) \
  90         ATOM(files, COUNT) \
  91         ATOM(size, SIZE)
  92
  93 #define ATOM(x, y) { .name = #x, .type = AT_ ## y},
  94 struct atom user_summary_atoms[] = {
  95         USER_SUMMARY_ATOMS
  96         {.name = NULL}
  97 };
  98 #undef ATOM
  99 #define ATOM(x, y) usa_ ## x,
 100 enum user_summary_atoms {USER_SUMMARY_ATOMS};
 101 #undef ATOM
 102
 103 struct global_list_info {
 104         uint32_t count;
 105         int ret;
 106         int osl_errno;
 107         struct format_info *fi;
 108 };
 109
 110 struct global_summary_info {
 111         /** Global dir count. */
 112         uint64_t num_dirs;
 113         /** Global files count. */
 114         uint64_t num_files;
 115         /** Global bytes count. */
 116         uint64_t num_bytes;
 117         int ret;
 118         int osl_errno;
 119 };
 120
 121 struct user_list_info {
 122         uint32_t count;
 123         struct user_info *ui;
 124         struct format_info *fi;
 125         int ret;
 126         int osl_errno;
 127 };
 128
 129 struct user_list_format_info {
 130         struct format_info *fi;
 131         struct format_info *header_fi;
 132 };
 133
 134 struct user_summary_info {
 135         struct user_info *ui;
 136         int ret;
 137         int osl_errno;
 138 };
 139
 140 struct user_summary_line_info {
 141         struct format_info *fi;
 142         uint32_t count;
 143 };
 144
 145 static FILE *output_file;
 146
 147 __printf_1_2 static int output(const char const *fmt, ...)
 148 {
 149         va_list argp;
 150         int ret;
 151
 152         va_start(argp, fmt);
 153         ret = vfprintf(output_file, fmt, argp);
 154         va_end(argp);
 155         return ret < 0? -E_OUTPUT : 1;
 156 }
 157
 158 static int get_dir_name_by_number(uint64_t *dirnum, char **name)
 159 {
 160         char *result = NULL, *tmp;
 161         struct osl_row *row;
 162         uint64_t val = *dirnum;
 163         struct osl_object obj;
 164         int ret;
 165         char *pfx;
 166
 167 again:
 168         obj.data = &val;
 169         obj.size = sizeof(val);
 170         ret = osl(osl_get_row(dir_table, DT_NUM, &obj, &row));
 171         if (ret < 0)
 172                 goto out;
 173         ret = osl(osl_get_object(dir_table, row, DT_PARENT_NUM, &obj));
 174         if (ret < 0)
 175                 goto out;
 176         val = *(uint64_t *)obj.data;
 177         ret = osl(osl_get_object(dir_table, row, DT_NAME, &obj));
 178         if (ret < 0)
 179                 goto out;
 180         pfx = (select_conf.print_base_dir_given || val)? (char *)obj.data :  ".";
 181         tmp = make_message("%s/%s", pfx, result? result : "");
 182         free(result);
 183         result = tmp;
 184         if (val)
 185                 goto again;
 186 out:
 187         if (ret < 0) {
 188                 free(result);
 189                 *name = NULL;
 190         } else {
 191                 assert(result);
 192                 *name = result;
 193         }
 194         return ret;
 195 }
 196
 197 static int get_dir_name_of_row(struct osl_row *dir_table_row, char **name)
 198 {
 199         struct osl_object obj;
 200         int ret;
 201
 202         *name = NULL;
 203         ret = osl(osl_get_object(dir_table, dir_table_row, DT_NUM, &obj));
 204         if (ret < 0)
 205                 return ret;
 206         return get_dir_name_by_number((uint64_t *)obj.data, name);
 207 }
 208
 209 static int get_dir_name_of_user_row(struct osl_row *user_table_row,
 210                 struct user_info *ui, char **dirname)
 211 {
 212         struct osl_object obj;
 213         int ret = osl(osl_get_object(ui->table, user_table_row,
 214                 UT_DIR_NUM, &obj));
 215
 216         if (ret < 0)
 217                 return ret;
 218         return get_dir_name_by_number((uint64_t *)obj.data, dirname);
 219 }
 220
 221 static int get_num_files_of_row(struct osl_row *row, uint64_t *num_files)
 222 {
 223         struct osl_object obj;
 224         int ret = osl(osl_get_object(dir_table, row, DT_FILES, &obj));
 225         if (ret < 0)
 226                 return ret;
 227         *num_files = *(uint64_t *)obj.data;
 228         return 1;
 229 }
 230
 231 static int get_num_user_files(struct osl_row *row, struct user_info *ui,
 232                 uint64_t *num_files)
 233 {
 234         struct osl_object obj;
 235         int ret = osl(osl_get_object(ui->table, row, UT_FILES, &obj));
 236
 237         if (ret < 0)
 238                 return ret;
 239         *num_files = *(uint64_t *)obj.data;
 240         return 1;
 241 }
 242
 243 static int get_num_bytes_of_row(struct osl_row *row, uint64_t *num_bytes)
 244 {
 245         struct osl_object obj;
 246         int ret = osl(osl_get_object(dir_table, row, DT_BYTES, &obj));
 247         if (ret < 0)
 248                 return ret;
 249         *num_bytes = *(uint64_t *)obj.data;
 250         return 1;
 251 }
 252
 253 static int get_num_user_bytes(struct osl_row *row, struct user_info *ui,
 254                 uint64_t *num_bytes)
 255 {
 256         struct osl_object obj;
 257         int ret = osl(osl_get_object(ui->table, row, UT_BYTES, &obj));
 258
 259         if (ret < 0)
 260                 return ret;
 261         *num_bytes = *(uint64_t *)obj.data;
 262         return 1;
 263 }
 264
 265 static int check_loop_return(int ret, int loop_ret, int loop_osl_errno)
 266 {
 267         if (ret >= 0)
 268                 return ret;
 269         assert(ret == -E_OSL);
 270         if (osl_errno != E_OSL_LOOP)
 271                 /* error not caused by loop function returning negative. */
 272                 return ret;
 273         assert(loop_ret < 0);
 274         if (loop_ret == -E_LOOP_COMPLETE) /* no error */
 275                 return 1;
 276         if (loop_ret == -E_OSL) { /* osl error in loop function */
 277                 assert(loop_osl_errno);
 278                 osl_errno = loop_osl_errno;
 279         }
 280         return loop_ret;
 281 }
 282
 283 static int adu_loop_reverse(struct osl_table *t, unsigned col_num, void *private_data,
 284                 osl_rbtree_loop_func *func, int *loop_ret, int *loop_osl_errno)
 285 {
 286         int ret = osl(osl_rbtree_loop_reverse(t, col_num, private_data, func));
 287         return check_loop_return(ret, *loop_ret, *loop_osl_errno);
 288 }
 289
 290 static int global_summary_loop_function(struct osl_row *row, void *data)
 291 {
 292         struct global_summary_info *gsi = data;
 293         int ret;
 294         uint64_t num;
 295
 296         ret = get_num_files_of_row(row, &num);
 297         if (ret < 0)
 298                 goto err;
 299         gsi->num_files += num;
 300
 301         ret = get_num_bytes_of_row(row, &num);
 302         if (ret < 0)
 303                 goto err;
 304         gsi->num_bytes += num;
 305         gsi->num_dirs++;
 306         return 1;
 307 err:
 308         gsi->ret = ret;
 309         gsi->osl_errno = (ret == -E_OSL)? osl_errno : 0;
 310         return ret;
 311 }
 312
 313 static int print_global_summary(struct format_info *fi)
 314 {
 315         int ret;
 316         char *buf;
 317         struct global_summary_info gsi = {.num_dirs = 0};
 318         char *header = select_conf.header_given? select_conf.header_arg :
 319                 "Global summary\n";
 320
 321         union atom_value values[] = {
 322                 [gsa_dirs] = {.num_value = 0ULL},
 323                 [gsa_files] = {.num_value =  0ULL},
 324                 [gsa_size] = {.num_value =  0ULL}
 325         };
 326
 327         ret = adu_loop_reverse(dir_table, DT_BYTES, &gsi,
 328                 global_summary_loop_function, &gsi.ret, &gsi.osl_errno);
 329         if (ret < 0)
 330                 return ret;
 331         values[gsa_dirs].num_value = (long long unsigned)gsi.num_dirs;
 332         values[gsa_files].num_value = (long long unsigned)gsi.num_files;
 333         values[gsa_size].num_value = (long long unsigned)gsi.num_bytes;
 334
 335         ret = output("%s", header);
 336         if (ret < 0)
 337                 return ret;
 338         buf = format_items(fi, values);
 339         ret = output("%s", buf);
 340         free(buf);
 341         return ret;
 342 }
 343
 344 static int user_summary_loop_function(struct osl_row *row, void *data)
 345 {
 346         struct user_summary_info *usi = data;
 347         uint64_t num;
 348         int ret;
 349
 350         ret = get_num_user_files(row, usi->ui, &num);
 351         if (ret < 0)
 352                 goto err;
 353         usi->ui->files += num;
 354         ret = get_num_user_bytes(row, usi->ui, &num);
 355         if (ret < 0)
 356                 goto err;
 357         usi->ui->bytes += num;
 358         usi->ui->dirs++;
 359         return 1;
 360 err:
 361         usi->ret = ret;
 362         usi->osl_errno = (ret == -E_OSL)? osl_errno : 0;
 363         return ret;
 364 }
 365
 366 static int compute_user_summary(struct user_info *ui, __a_unused void *data)
 367 {
 368         struct user_summary_info usi = {.ui = ui};
 369
 370         return adu_loop_reverse(ui->table, UT_BYTES, &usi, user_summary_loop_function,
 371                 &usi.ret, &usi.osl_errno);
 372 }
 373
 374 static int print_user_summary_line(struct user_info *ui, void *data)
 375 {
 376         struct user_summary_line_info *usli = data;
 377         union atom_value values[] = {
 378                 [usa_pw_name] = {.string_value = ui->pw_name?
 379                         ui->pw_name : "?"},
 380                 [usa_uid] = {.num_value = (long long unsigned)ui->uid},
 381                 [usa_dirs] = {.num_value = (long long unsigned)ui->dirs},
 382                 [usa_files] = {.num_value = (long long unsigned)ui->files},
 383                 [usa_size] = {.num_value =  (long long unsigned)ui->bytes}
 384         };
 385         char *buf;
 386         int ret = -E_LOOP_COMPLETE;
 387
 388         if (!usli->count)
 389                 return ret;
 390
 391         buf = format_items(usli->fi, values);
 392         ret = output("%s", buf);
 393         free(buf);
 394         usli->count--;
 395         return ret;
 396 }
 397
 398 static int name_comp(struct user_info *a, struct user_info *b)
 399 {
 400         char *x = a->pw_name;
 401         char *y = b->pw_name;
 402
 403         if (!x)
 404                 return 1;
 405         if (!y)
 406                 return -1;
 407         return strcmp(x, y);
 408 }
 409
 410 static int uid_comp(struct user_info *a, struct user_info *b)
 411 {
 412         return -NUM_COMPARE(a->uid, b->uid);
 413 }
 414
 415 static int dir_count_comp(struct user_info *a, struct user_info *b)
 416 {
 417         return NUM_COMPARE(a->dirs, b->dirs);
 418 }
 419
 420 static int file_count_comp(struct user_info *a, struct user_info *b)
 421 {
 422         return NUM_COMPARE(a->files, b->files);
 423 }
 424
 425 static int size_comp(struct user_info *a, struct user_info *b)
 426 {
 427         return NUM_COMPARE(a->bytes, b->bytes);
 428 }
 429
 430 static int print_user_summary(struct format_info *fi)
 431 {
 432         int ret;
 433         int (*comp)(struct user_info *a, struct user_info *b);
 434         struct user_summary_line_info usli = {
 435                 .fi = fi,
 436                 .count = select_conf.limit_arg
 437         };
 438         char *header = select_conf.header_given? select_conf.header_arg :
 439                 "User summary\n";
 440
 441         ret = output("%s", header);
 442         if (ret < 0)
 443                 return ret;
 444         ret = for_each_admissible_user(compute_user_summary, NULL);
 445         if (ret < 0)
 446                 return ret;
 447         switch (select_conf.user_summary_sort_arg) {
 448         case user_summary_sort_arg_name:
 449                 comp = name_comp;
 450                 break;
 451         case user_summary_sort_arg_uid:
 452                 comp = uid_comp;
 453                 break;
 454         case user_summary_sort_arg_dir_count:
 455                 comp = dir_count_comp;
 456                 break;
 457         case user_summary_sort_arg_file_count:
 458                 comp = file_count_comp;
 459                 break;
 460         case user_summary_sort_arg_size:
 461                 comp = size_comp;
 462                 break;
 463         }
 464         sort_hash_table(comp);
 465         ret = for_each_admissible_user(print_user_summary_line, &usli);
 466         if (ret == -E_LOOP_COMPLETE)
 467                 ret = 1;
 468         return ret;
 469 }
 470
 471 static int user_list_loop_function(struct osl_row *row, void *data)
 472 {
 473         struct user_list_info *uli = data;
 474         union atom_value values[] = {
 475                 [ula_pw_name] = {.string_value = uli->ui->pw_name?
 476                         uli->ui->pw_name : "?"},
 477                 [ula_uid] = {.num_value = (long long unsigned)uli->ui->uid},
 478                 [ula_files] = {.num_value = 0ULL},
 479                 [ula_size] = {.num_value =  0ULL},
 480                 [ula_dirname] = {.string_value = NULL}
 481         };
 482         uint64_t num;
 483         int ret;
 484         char *dirname, *buf;
 485
 486         check_signals();
 487         ret = -E_LOOP_COMPLETE;
 488         if (!uli->count)
 489                 goto err;
 490
 491         ret = get_num_user_files(row, uli->ui, &num);
 492         if (ret < 0)
 493                 goto err;
 494         values[ula_files].num_value = num;
 495
 496         ret = get_num_user_bytes(row, uli->ui, &num);
 497         if (ret < 0)
 498                 goto err;
 499         values[ula_size].num_value = num;
 500
 501         ret = get_dir_name_of_user_row(row, uli->ui, &dirname);
 502         if (ret < 0)
 503                 goto err;
 504         values[ula_dirname].string_value = dirname;
 505
 506         buf = format_items(uli->fi, values);
 507         free(dirname);
 508         ret = output("%s", buf);
 509         free(buf);
 510         if (ret < 0)
 511                 goto err;
 512         uli->count--;
 513         return ret;
 514 err:
 515         uli->ret = ret;
 516         uli->osl_errno = (ret == -E_OSL)? osl_errno : 0;
 517         return ret;
 518 }
 519
 520 static int print_user_list(struct user_info *ui, void *data)
 521 {
 522         struct user_list_format_info *ulfi = data;
 523         int ret;
 524         enum user_table_columns sort_column;
 525         struct user_list_info uli = {
 526                 .ui = ui,
 527                 .fi = ulfi->fi,
 528                 .count = select_conf.limit_arg
 529         };
 530         union atom_value header_values[] = {
 531                 [ulha_uid] = {.num_value = (long long unsigned)ui->uid},
 532                 [ulha_pw_name] = {.string_value = ui->pw_name?
 533                         ui->pw_name : "?"}
 534         };
 535         char *buf = format_items(ulfi->header_fi, header_values);
 536
 537         ret = output("%s", buf);
 538         free(buf);
 539         if (ret < 0)
 540                 return ret;
 541         if (select_conf.list_sort_arg == list_sort_arg_file_count)
 542                 sort_column = UT_FILES;
 543         else
 544                 sort_column = UT_BYTES;
 545         return adu_loop_reverse(ui->table, sort_column, &uli, user_list_loop_function,
 546                 &uli.ret, &uli.osl_errno);
 547 }
 548
 549 static int print_user_lists(struct format_info *fi)
 550 {
 551         struct user_list_format_info ulfi = {.fi = fi};
 552         char *header_fmt = select_conf.header_given?
 553                 select_conf.header_arg : "uid %(uid)(%(pw_name)):\n";
 554         int ret = parse_format_string(header_fmt,
 555                 user_list_header_atoms, &ulfi.header_fi);
 556         if (ret < 0)
 557                 return ret;
 558         ret = for_each_admissible_user(print_user_list, &ulfi);
 559         free_format_info(ulfi.header_fi);
 560         return ret;
 561 }
 562
 563 static int global_list_loop_function(struct osl_row *row, void *data)
 564 {
 565         struct global_list_info *gli = data;
 566         union atom_value values[] = {
 567                 [gla_size] = {.num_value = 0ULL},
 568                 [gla_files] = {.num_value =  0ULL},
 569                 [gla_dirname] = {.string_value = NULL}
 570         };
 571         uint64_t num_files, num_bytes;
 572         char *dirname, *buf;
 573         int ret;
 574
 575         check_signals();
 576         ret = -E_LOOP_COMPLETE;
 577         if (!gli->count)
 578                 goto err;
 579
 580         ret = get_num_files_of_row(row, &num_files);
 581         if (ret < 0)
 582                 goto err;
 583         values[gla_files].num_value = (long long unsigned)num_files;
 584
 585         ret = get_num_bytes_of_row(row, &num_bytes);
 586         if (ret < 0)
 587                 goto err;
 588         values[gla_size].num_value = (long long unsigned)num_bytes;
 589
 590         ret = get_dir_name_of_row(row, &dirname);
 591         if (ret < 0)
 592                 goto err;
 593         values[gla_dirname].string_value = dirname;
 594
 595         buf = format_items(gli->fi, values);
 596         free(dirname);
 597         ret = output("%s", buf);
 598         free(buf);
 599         if (ret < 0)
 600                 goto err;
 601         if (gli->count > 0)
 602                 gli->count--;
 603         return ret;
 604 err:
 605         gli->ret = ret;
 606         gli->osl_errno = (ret == -E_OSL)? osl_errno : 0;
 607         return -1;
 608 }
 609
 610 static int print_global_list(struct format_info *fi)
 611 {
 612         int ret;
 613         enum dir_table_columns sort_column;
 614         struct global_list_info gli = {
 615                 .fi = fi,
 616                 .count = select_conf.limit_arg
 617         };
 618         char *header = select_conf.header_given?
 619                 select_conf.header_arg : "Global list\n";
 620         ret = output("%s", header);
 621         if (ret < 0)
 622                 return ret;
 623         if (select_conf.list_sort_arg == list_sort_arg_file_count)
 624                 sort_column = DT_FILES;
 625         else
 626                 sort_column = DT_BYTES;
 627         return adu_loop_reverse(dir_table, sort_column, &gli,
 628                 global_list_loop_function, &gli.ret, &gli.osl_errno);
 629 }
 630
 631 static int print_statistics(struct format_info *fi)
 632 {
 633         switch (select_conf.select_mode_arg) {
 634         case select_mode_arg_global_list:
 635                 return print_global_list(fi);
 636         case select_mode_arg_global_summary:
 637                 return print_global_summary(fi);
 638         case select_mode_arg_user_list:
 639                 return print_user_lists(fi);
 640         case select_mode_arg_user_summary:
 641                 return print_user_summary(fi);
 642         };
 643         ERROR_LOG("bad select mode\n");
 644         return -ERRNO_TO_ERROR(EINVAL);
 645 }
 646
 647 static int open_pipe(char *path)
 648 {
 649         int p[2], ret, argc;
 650         char **argv;
 651
 652         ret = pipe(p);
 653         if (ret < 0)
 654                 return ERRNO_TO_ERROR(errno);
 655         ret = fork();
 656         if (ret < 0)
 657                 return ERRNO_TO_ERROR(errno);
 658         if (ret) { /* parent */
 659                 DEBUG_LOG("created process %d\n", ret);
 660                 close(p[0]);
 661                 output_file = fdopen(p[1], "w");
 662                 if (!output_file)
 663                         return ERRNO_TO_ERROR(errno);
 664                 return 1;
 665         }
 666         close(p[1]);
 667         if (p[0] != STDIN_FILENO)
 668                 dup2(p[0], STDIN_FILENO);
 669         DEBUG_LOG("executing %s\n", path);
 670         argc = split_args(path, &argv, " \t");
 671         execvp(argv[0], argv);
 672         ERROR_LOG("error executing %s: %s\n", path,
 673                 adu_strerror(ERRNO_TO_ERROR(errno)));
 674         _exit(EXIT_FAILURE);
 675 }
 676
 677 static int open_output_stream(void)
 678 {
 679         char *p;
 680         int ret, flags = O_WRONLY | O_CREAT;
 681
 682         if (!select_conf.output_given)
 683                 goto use_stdout;
 684         p = select_conf.output_arg;
 685         switch (p[0]) {
 686         case '\0': /* empty string */
 687                 goto bad_output_arg;
 688         case '-':
 689                 if (!p[1]) /* "-" means stdout */
 690                         goto use_stdout;
 691                 /* string starting with a dash */
 692                 flags |= O_EXCL;
 693                 goto open_file;
 694         case '>':
 695                 if (!p[1]) /* ">" is invalid */
 696                         goto bad_output_arg;
 697                 if (p[1] != '>') {
 698                         p++;
 699                         flags |= O_TRUNC;
 700                         goto open_file;
 701                 }
 702                 /* string starting with ">>" */
 703                 if (!p[2]) /* ">>" is invalid */
 704                         goto bad_output_arg;
 705                 flags |= O_APPEND;
 706                 p += 2;
 707                 goto open_file;
 708         case '|':
 709                 if (!p[1]) /* "|" is invalid */
 710                         goto bad_output_arg;
 711                 p++;
 712                 return open_pipe(p);
 713         default: /* args starts with no magic character */
 714                 flags |= O_EXCL;
 715                 goto open_file;
 716         }
 717 use_stdout:
 718         output_file = stdout;
 719         return 1;
 720 bad_output_arg:
 721         output_file = NULL;
 722         return -E_BAD_OUTPUT_ARG;
 723 open_file:
 724         /*
 725          * glibc's 'x' mode to fopen is not portable, so use open() and
 726          * fdopen().
 727          */
 728         ret = open(p, flags, 0644);
 729         if (ret < 0)
 730                 return -ERRNO_TO_ERROR(errno);
 731         output_file = fdopen(ret, "w");
 732         if (!output_file)
 733                 return -ERRNO_TO_ERROR(errno);
 734         return 1;
 735 }
 736
 737 int run_select_query(struct uid_range *admissible_uids, struct format_info *fi)
 738 {
 739         int ret = open_output_stream();
 740
 741         if (ret < 0)
 742                 goto out;
 743         ret = open_dir_table(0);
 744         if (ret < 0)
 745                 goto out;
 746         check_signals();
 747         ret = open_admissible_user_tables(admissible_uids);
 748         if (ret < 0)
 749                 goto out;
 750         check_signals();
 751         ret = print_statistics(fi);
 752 out:
 753         if (output_file && output_file != stdout) {
 754                 fclose(output_file);
 755                 output_file = NULL;
 756         }
 757         return ret;
 758 }
 759
 760 #define GLOBAL_LIST_DFLT_FMT "%(size:r:8) %(files:r:8) %(dirname)\n"
 761 #define GLOBAL_SUMMARY_DFLT_FMT "#directories: %(dirs), #files: %(files), size: %(size)\n\n"
 762 #define USER_LIST_DFLT_FMT "%(size:r:5) %(files:r:5) %(dirname)\n"
 763 #define USER_SUMMARY_DFLT_FMT "%(pw_name:l:16) %(uid:r:5) %(dirs:r:5) %(files:r:5) %(size:r:5)\n"
 764
 765 static int setup_format_string(char *fmt, struct format_info **fi)
 766 {
 767         struct atom *atoms;
 768
 769         if (!fmt)
 770                 INFO_LOG("using default format string\n");
 771         switch (select_conf.select_mode_arg) {
 772         case select_mode_arg_global_list:
 773                 if (!fmt)
 774                         fmt = GLOBAL_LIST_DFLT_FMT;
 775                 atoms = global_list_atoms;
 776                 break;
 777         case select_mode_arg_global_summary:
 778                 if (!fmt)
 779                         fmt = GLOBAL_SUMMARY_DFLT_FMT;
 780                 atoms = global_summary_atoms;
 781                 break;
 782         case select_mode_arg_user_list:
 783                 if (!fmt)
 784                         fmt = USER_LIST_DFLT_FMT;
 785                 atoms = user_list_atoms;
 786                 break;
 787         case select_mode_arg_user_summary:
 788                 if (!fmt)
 789                         fmt = USER_SUMMARY_DFLT_FMT;
 790                 atoms = user_summary_atoms;
 791                 break;
 792         default:
 793                 ERROR_LOG("bad select mode\n");
 794                 return -ERRNO_TO_ERROR(EINVAL);
 795         };
 796         INFO_LOG("format string: %s\n", fmt);
 797         return parse_format_string(fmt, atoms, fi);
 798 }
 799
 800 /* return: < 0: error, >0: OK, == 0: help given */
 801 int parse_select_options(char *string, struct select_cmdline_parser_params *params,
 802                 struct uid_range **admissible_uids, struct format_info **fi)
 803 {
 804         int ret, num_uid_ranges;
 805         const char **line;
 806         char *fmt = NULL;
 807
 808         if (string) {
 809                 int argc;
 810                 char **argv;
 811
 812                 ret = create_argv(string, &argv);
 813                 if (ret < 0)
 814                         return ret;
 815                 argc = ret;
 816                 ret = select_cmdline_parser_ext(argc, argv, &select_conf, params);
 817                 free_argv(argv);
 818                 if (ret)
 819                         return -E_SYNTAX;
 820                 if (select_conf.help_given || select_conf.detailed_help_given)
 821                         goto help;
 822                 fmt = select_conf.format_arg;
 823         }
 824         ret = parse_uid_arg(select_conf.uid_arg, admissible_uids);
 825         if (ret < 0)
 826                 return ret;
 827         num_uid_ranges = ret;
 828         ret = append_users(select_conf.user_arg, select_conf.user_given,
 829                 admissible_uids, num_uid_ranges);
 830         if (ret < 0)
 831                 return ret;
 832         return setup_format_string(fmt, fi);
 833 help:
 834         line = select_conf.detailed_help_given?
 835                 select_args_info_detailed_help : select_args_info_help;
 836         if (!output_file)
 837                 output_file = stdout;
 838         for (; *line; line++) {
 839                 ret = output("%s\n", *line);
 840                 if (ret < 0)
 841                         return ret;
 842         }
 843         return 0;
 844 }
 845
 846 int com_select(void)
 847 {
 848         struct uid_range *admissible_uids = NULL;
 849         int ret;
 850         struct format_info *fi;
 851         struct select_cmdline_parser_params params = {
 852                 .override = 1,
 853                 .initialize = 1,
 854                 .check_required = 1,
 855                 .check_ambiguity = 1,
 856                 .print_errors = 1
 857         };
 858
 859         ret = parse_select_options(conf.select_options_arg, &params,
 860                 &admissible_uids, &fi);
 861         if (ret > 0) {
 862                 ret = read_uid_file();
 863                 if (ret < 0)
 864                         goto out;
 865                 ret = run_select_query(admissible_uids, fi);
 866                 free_format_info(fi);
 867         }
 868 out:
 869         select_cmdline_parser_free(&select_conf);
 870         return ret;
 871 }