appl/ftp/ftpd/ls.c

   1 /*
   2  * Copyright (c) 1999 - 2002 Kungliga Tekniska Högskolan
   3  * (Royal Institute of Technology, Stockholm, Sweden).
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  *
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * 3. Neither the name of KTH nor the names of its contributors may be
  18  *    used to endorse or promote products derived from this software without
  19  *    specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY KTH AND ITS CONTRIBUTORS ``AS IS'' AND ANY
  22  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  24  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL KTH OR ITS CONTRIBUTORS BE
  25  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  26  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  27  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  28  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  29  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  30  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  31  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
  32
  33 #ifndef TEST
  34 #include "ftpd_locl.h"
  35
  36 RCSID("$Id$");
  37
  38 #else
  39 #include <stdio.h>
  40 #include <string.h>
  41 #include <stdlib.h>
  42 #include <time.h>
  43 #include <dirent.h>
  44 #include <sys/stat.h>
  45 #include <unistd.h>
  46 #include <pwd.h>
  47 #include <grp.h>
  48 #include <errno.h>
  49
  50 #define sec_fprintf2 fprintf
  51 #define sec_fflush fflush
  52 static void list_files(FILE *out, const char **files, int n_files, int flags);
  53 static int parse_flags(const char *options);
  54
  55 int
  56 main(int argc, char **argv)
  57 {
  58     int i = 1;
  59     int flags;
  60     if(argc > 1 && argv[1][0] == '-') {
  61         flags = parse_flags(argv[1]);
  62         i = 2;
  63     } else
  64         flags = parse_flags(NULL);
  65
  66     list_files(stdout, (const char **)argv + i, argc - i, flags);
  67     return 0;
  68 }
  69 #endif
  70
  71 struct fileinfo {
  72     struct stat st;
  73     int inode;
  74     int bsize;
  75     char mode[11];
  76     int n_link;
  77     char *user;
  78     char *group;
  79     char *size;
  80     char *major;
  81     char *minor;
  82     char *date;
  83     char *filename;
  84     char *link;
  85 };
  86
  87 static void
  88 free_fileinfo(struct fileinfo *f)
  89 {
  90     free(f->user);
  91     free(f->group);
  92     free(f->size);
  93     free(f->major);
  94     free(f->minor);
  95     free(f->date);
  96     free(f->filename);
  97     free(f->link);
  98 }
  99
 100 #define LS_DIRS         (1 << 0)
 101 #define LS_IGNORE_DOT   (1 << 1)
 102 #define LS_SORT_MODE    (3 << 2)
 103 #define SORT_MODE(f) ((f) & LS_SORT_MODE)
 104 #define LS_SORT_NAME    (1 << 2)
 105 #define LS_SORT_MTIME   (2 << 2)
 106 #define LS_SORT_SIZE    (3 << 2)
 107 #define LS_SORT_REVERSE (1 << 4)
 108
 109 #define LS_SIZE         (1 << 5)
 110 #define LS_INODE        (1 << 6)
 111 #define LS_TYPE         (1 << 7)
 112 #define LS_DISP_MODE    (3 << 8)
 113 #define DISP_MODE(f) ((f) & LS_DISP_MODE)
 114 #define LS_DISP_LONG    (1 << 8)
 115 #define LS_DISP_COLUMN  (2 << 8)
 116 #define LS_DISP_CROSS   (3 << 8)
 117 #define LS_SHOW_ALL     (1 << 10)
 118 #define LS_RECURSIVE    (1 << 11)
 119 #define LS_EXTRA_BLANK  (1 << 12)
 120 #define LS_SHOW_DIRNAME (1 << 13)
 121 #define LS_DIR_FLAG     (1 << 14)       /* these files come via list_dir */
 122
 123 #ifndef S_ISTXT
 124 #define S_ISTXT S_ISVTX
 125 #endif
 126
 127 #if !defined(_S_IFMT) && defined(S_IFMT)
 128 #define _S_IFMT S_IFMT
 129 #endif
 130
 131 #ifndef S_ISSOCK
 132 #define S_ISSOCK(mode)  (((mode) & _S_IFMT) == S_IFSOCK)
 133 #endif
 134
 135 #ifndef S_ISLNK
 136 #define S_ISLNK(mode)   (((mode) & _S_IFMT) == S_IFLNK)
 137 #endif
 138
 139 static size_t
 140 block_convert(size_t blocks)
 141 {
 142 #ifdef S_BLKSIZE
 143     return blocks * S_BLKSIZE / 1024;
 144 #else
 145     return blocks * 512 / 1024;
 146 #endif
 147 }
 148
 149 static int
 150 make_fileinfo(FILE *out, const char *filename, struct fileinfo *file, int flags)
 151 {
 152     char buf[128];
 153     int file_type = 0;
 154     struct stat *st = &file->st;
 155
 156     file->inode = st->st_ino;
 157     file->bsize = block_convert(st->st_blocks);
 158
 159     if(S_ISDIR(st->st_mode)) {
 160         file->mode[0] = 'd';
 161         file_type = '/';
 162     }
 163     else if(S_ISCHR(st->st_mode))
 164         file->mode[0] = 'c';
 165     else if(S_ISBLK(st->st_mode))
 166         file->mode[0] = 'b';
 167     else if(S_ISREG(st->st_mode)) {
 168         file->mode[0] = '-';
 169         if(st->st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))
 170             file_type = '*';
 171     }
 172     else if(S_ISFIFO(st->st_mode)) {
 173         file->mode[0] = 'p';
 174         file_type = '|';
 175     }
 176     else if(S_ISLNK(st->st_mode)) {
 177         file->mode[0] = 'l';
 178         file_type = '@';
 179     }
 180     else if(S_ISSOCK(st->st_mode)) {
 181         file->mode[0] = 's';
 182         file_type = '=';
 183     }
 184 #ifdef S_ISWHT
 185     else if(S_ISWHT(st->st_mode)) {
 186         file->mode[0] = 'w';
 187         file_type = '%';
 188     }
 189 #endif
 190     else
 191         file->mode[0] = '?';
 192     {
 193         char *x[] = { "---", "--x", "-w-", "-wx",
 194                       "r--", "r-x", "rw-", "rwx" };
 195         strcpy(file->mode + 1, x[(st->st_mode & S_IRWXU) >> 6]);
 196         strcpy(file->mode + 4, x[(st->st_mode & S_IRWXG) >> 3]);
 197         strcpy(file->mode + 7, x[(st->st_mode & S_IRWXO) >> 0]);
 198         if((st->st_mode & S_ISUID)) {
 199             if((st->st_mode & S_IXUSR))
 200                 file->mode[3] = 's';
 201             else
 202                 file->mode[3] = 'S';
 203         }
 204         if((st->st_mode & S_ISGID)) {
 205             if((st->st_mode & S_IXGRP))
 206                 file->mode[6] = 's';
 207             else
 208                 file->mode[6] = 'S';
 209         }
 210         if((st->st_mode & S_ISTXT)) {
 211             if((st->st_mode & S_IXOTH))
 212                 file->mode[9] = 't';
 213             else
 214                 file->mode[9] = 'T';
 215         }
 216     }
 217     file->n_link = st->st_nlink;
 218     {
 219         struct passwd *pwd;
 220         pwd = getpwuid(st->st_uid);
 221         if(pwd == NULL) {
 222             if (asprintf(&file->user, "%u", (unsigned)st->st_uid) == -1)
 223                 file->user = NULL;
 224         } else
 225             file->user = strdup(pwd->pw_name);
 226         if (file->user == NULL) {
 227             syslog(LOG_ERR, "out of memory");
 228             return -1;
 229         }
 230     }
 231     {
 232         struct group *grp;
 233         grp = getgrgid(st->st_gid);
 234         if(grp == NULL) {
 235             if (asprintf(&file->group, "%u", (unsigned)st->st_gid) == -1)
 236                 file->group = NULL;
 237         } else
 238             file->group = strdup(grp->gr_name);
 239         if (file->group == NULL) {
 240             syslog(LOG_ERR, "out of memory");
 241             return -1;
 242         }
 243     }
 244
 245     if(S_ISCHR(st->st_mode) || S_ISBLK(st->st_mode)) {
 246 #if defined(major) && defined(minor)
 247         if (asprintf(&file->major, "%u", (unsigned)major(st->st_rdev)) == -1)
 248             file->major = NULL;
 249         if (asprintf(&file->minor, "%u", (unsigned)minor(st->st_rdev)) == -1)
 250             file->minor = NULL;
 251 #else
 252         /* Don't want to use the DDI/DKI crap. */
 253         if (asprintf(&file->major, "%u", (unsigned)st->st_rdev) == -1)
 254             file->major = NULL;
 255         if (asprintf(&file->minor, "%u", 0) == -1)
 256             file->minor = NULL;
 257 #endif
 258         if (file->major == NULL || file->minor == NULL) {
 259             syslog(LOG_ERR, "out of memory");
 260             return -1;
 261         }
 262     } else {
 263         if (asprintf(&file->size, "%lu", (unsigned long)st->st_size) == -1)
 264             file->size = NULL;
 265     }
 266
 267     {
 268         time_t t = time(NULL);
 269         time_t mtime = st->st_mtime;
 270         struct tm *tm = localtime(&mtime);
 271         if((t - mtime > 6*30*24*60*60) ||
 272            (mtime - t > 6*30*24*60*60))
 273             strftime(buf, sizeof(buf), "%b %e  %Y", tm);
 274         else
 275             strftime(buf, sizeof(buf), "%b %e %H:%M", tm);
 276         file->date = strdup(buf);
 277         if (file->date == NULL) {
 278             syslog(LOG_ERR, "out of memory");
 279             return -1;
 280         }
 281     }
 282     {
 283         const char *p = strrchr(filename, '/');
 284         if(p)
 285             p++;
 286         else
 287             p = filename;
 288         if((flags & LS_TYPE) && file_type != 0) {
 289             if (asprintf(&file->filename, "%s%c", p, file_type) == -1)
 290                 file->filename = NULL;
 291         } else
 292             file->filename = strdup(p);
 293         if (file->filename == NULL) {
 294             syslog(LOG_ERR, "out of memory");
 295             return -1;
 296         }
 297     }
 298     if(S_ISLNK(st->st_mode)) {
 299         int n;
 300         n = readlink((char *)filename, buf, sizeof(buf) - 1);
 301         if(n >= 0) {
 302             buf[n] = '\0';
 303             file->link = strdup(buf);
 304             if (file->link == NULL) {
 305                 syslog(LOG_ERR, "out of memory");
 306                 return -1;
 307             }
 308         } else
 309             sec_fprintf2(out, "readlink(%s): %s", filename, strerror(errno));
 310     }
 311     return 0;
 312 }
 313
 314 static void
 315 print_file(FILE *out,
 316            int flags,
 317            struct fileinfo *f,
 318            int max_inode,
 319            int max_bsize,
 320            int max_n_link,
 321            int max_user,
 322            int max_group,
 323            int max_size,
 324            int max_major,
 325            int max_minor,
 326            int max_date)
 327 {
 328     if(f->filename == NULL)
 329         return;
 330
 331     if(flags & LS_INODE) {
 332         sec_fprintf2(out, "%*d", max_inode, f->inode);
 333         sec_fprintf2(out, "  ");
 334     }
 335     if(flags & LS_SIZE) {
 336         sec_fprintf2(out, "%*d", max_bsize, f->bsize);
 337         sec_fprintf2(out, "  ");
 338     }
 339     sec_fprintf2(out, "%s", f->mode);
 340     sec_fprintf2(out, "  ");
 341     sec_fprintf2(out, "%*d", max_n_link, f->n_link);
 342     sec_fprintf2(out, " ");
 343     sec_fprintf2(out, "%-*s", max_user, f->user);
 344     sec_fprintf2(out, "  ");
 345     sec_fprintf2(out, "%-*s", max_group, f->group);
 346     sec_fprintf2(out, "  ");
 347     if(f->major != NULL && f->minor != NULL)
 348         sec_fprintf2(out, "%*s, %*s", max_major, f->major, max_minor, f->minor);
 349     else
 350         sec_fprintf2(out, "%*s", max_size, f->size);
 351     sec_fprintf2(out, " ");
 352     sec_fprintf2(out, "%*s", max_date, f->date);
 353     sec_fprintf2(out, " ");
 354     sec_fprintf2(out, "%s", f->filename);
 355     if(f->link)
 356         sec_fprintf2(out, " -> %s", f->link);
 357     sec_fprintf2(out, "\r\n");
 358 }
 359
 360 static int
 361 compare_filename(struct fileinfo *a, struct fileinfo *b)
 362 {
 363     if(a->filename == NULL)
 364         return 1;
 365     if(b->filename == NULL)
 366         return -1;
 367     return strcmp(a->filename, b->filename);
 368 }
 369
 370 static int
 371 compare_mtime(struct fileinfo *a, struct fileinfo *b)
 372 {
 373     if(a->filename == NULL)
 374         return 1;
 375     if(b->filename == NULL)
 376         return -1;
 377     return b->st.st_mtime - a->st.st_mtime;
 378 }
 379
 380 static int
 381 compare_size(struct fileinfo *a, struct fileinfo *b)
 382 {
 383     if(a->filename == NULL)
 384         return 1;
 385     if(b->filename == NULL)
 386         return -1;
 387     return b->st.st_size - a->st.st_size;
 388 }
 389
 390 static int list_dir(FILE*, const char*, int);
 391
 392 static int
 393 find_log10(int num)
 394 {
 395     int i = 1;
 396     while(num > 10) {
 397         i++;
 398         num /= 10;
 399     }
 400     return i;
 401 }
 402
 403 /*
 404  * Operate as lstat but fake up entries for AFS mount points so we don't
 405  * have to fetch them.
 406  */
 407
 408 static int
 409 lstat_file (const char *file, struct stat *sb)
 410 {
 411 #if defined(KRB5) && !defined(NO_AFS)
 412     if (k_hasafs()
 413         && strcmp(file, ".")
 414         && strcmp(file, "..")
 415         && strcmp(file, "/"))
 416     {
 417         struct ViceIoctl    a_params;
 418         char               *dir, *last;
 419         char               *path_bkp;
 420         static ino_t       ino_counter = 0, ino_last = 0;
 421         int                ret;
 422         const int          maxsize = 2048;
 423
 424         path_bkp = strdup (file);
 425         if (path_bkp == NULL)
 426             return -1;
 427
 428         a_params.out = malloc (maxsize);
 429         if (a_params.out == NULL) {
 430             free (path_bkp);
 431             return -1;
 432         }
 433
 434         /* If path contains more than the filename alone - split it */
 435
 436         last = strrchr (path_bkp, '/');
 437         if (last != NULL) {
 438             if(last[1] == '\0')
 439                 /* if path ended in /, replace with `.' */
 440                 a_params.in = ".";
 441             else
 442                 a_params.in = last + 1;
 443             while(last > path_bkp && *--last == '/');
 444             if(*last != '/' || last != path_bkp) {
 445                 *++last = '\0';
 446                 dir = path_bkp;
 447             } else
 448                 /* we got to the start, so this must be the root dir */
 449                 dir = "/";
 450         } else {
 451             /* file is relative to cdir */
 452             dir = ".";
 453             a_params.in = path_bkp;
 454         }
 455
 456         a_params.in_size  = strlen (a_params.in) + 1;
 457         a_params.out_size = maxsize;
 458
 459         ret = k_pioctl (dir, VIOC_AFS_STAT_MT_PT, &a_params, 0);
 460         free (a_params.out);
 461         if (ret < 0) {
 462             free (path_bkp);
 463
 464             if (errno != EINVAL)
 465                 return ret;
 466             else
 467                 /* if we get EINVAL this is probably not a mountpoint */
 468                 return lstat (file, sb);
 469         }
 470
 471         /*
 472          * wow this was a mountpoint, lets cook the struct stat
 473          * use . as a prototype
 474          */
 475
 476         ret = lstat (dir, sb);
 477         free (path_bkp);
 478         if (ret < 0)
 479             return ret;
 480
 481         if (ino_last == sb->st_ino)
 482             ino_counter++;
 483         else {
 484             ino_last    = sb->st_ino;
 485             ino_counter = 0;
 486         }
 487         sb->st_ino += ino_counter;
 488         sb->st_nlink = 3;
 489
 490         return 0;
 491     }
 492 #endif /* KRB5 */
 493     return lstat (file, sb);
 494 }
 495
 496 #define IS_DOT_DOTDOT(X) ((X)[0] == '.' && ((X)[1] == '\0' || \
 497                                 ((X)[1] == '.' && (X)[2] == '\0')))
 498
 499 static int
 500 list_files(FILE *out, const char **files, int n_files, int flags)
 501 {
 502     struct fileinfo *fi;
 503     int i;
 504     int *dirs = NULL;
 505     size_t total_blocks = 0;
 506     int n_print = 0;
 507     int ret = 0;
 508
 509     if(n_files == 0)
 510         return 0;
 511
 512     if(n_files > 1)
 513         flags |= LS_SHOW_DIRNAME;
 514
 515     fi = calloc(n_files, sizeof(*fi));
 516     if (fi == NULL) {
 517         syslog(LOG_ERR, "out of memory");
 518         return -1;
 519     }
 520     for(i = 0; i < n_files; i++) {
 521         if(lstat_file(files[i], &fi[i].st) < 0) {
 522             sec_fprintf2(out, "%s: %s\r\n", files[i], strerror(errno));
 523             fi[i].filename = NULL;
 524         } else {
 525             int include_in_list = 1;
 526             total_blocks += block_convert(fi[i].st.st_blocks);
 527             if(S_ISDIR(fi[i].st.st_mode)) {
 528                 if(dirs == NULL)
 529                     dirs = calloc(n_files, sizeof(*dirs));
 530                 if(dirs == NULL) {
 531                     syslog(LOG_ERR, "%s: %m", files[i]);
 532                     ret = -1;
 533                     goto out;
 534                 }
 535                 dirs[i] = 1;
 536                 if((flags & LS_DIRS) == 0)
 537                     include_in_list = 0;
 538             }
 539             if(include_in_list) {
 540                 ret = make_fileinfo(out, files[i], &fi[i], flags);
 541                 if (ret)
 542                     goto out;
 543                 n_print++;
 544             }
 545         }
 546     }
 547     switch(SORT_MODE(flags)) {
 548     case LS_SORT_NAME:
 549         qsort(fi, n_files, sizeof(*fi),
 550               (int (*)(const void*, const void*))compare_filename);
 551         break;
 552     case LS_SORT_MTIME:
 553         qsort(fi, n_files, sizeof(*fi),
 554               (int (*)(const void*, const void*))compare_mtime);
 555         break;
 556     case LS_SORT_SIZE:
 557         qsort(fi, n_files, sizeof(*fi),
 558               (int (*)(const void*, const void*))compare_size);
 559         break;
 560     }
 561     if(DISP_MODE(flags) == LS_DISP_LONG) {
 562         int max_inode = 0;
 563         int max_bsize = 0;
 564         int max_n_link = 0;
 565         int max_user = 0;
 566         int max_group = 0;
 567         int max_size = 0;
 568         int max_major = 0;
 569         int max_minor = 0;
 570         int max_date = 0;
 571         for(i = 0; i < n_files; i++) {
 572             if(fi[i].filename == NULL)
 573                 continue;
 574             if(fi[i].inode > max_inode)
 575                 max_inode = fi[i].inode;
 576             if(fi[i].bsize > max_bsize)
 577                 max_bsize = fi[i].bsize;
 578             if(fi[i].n_link > max_n_link)
 579                 max_n_link = fi[i].n_link;
 580             if(strlen(fi[i].user) > max_user)
 581                 max_user = strlen(fi[i].user);
 582             if(strlen(fi[i].group) > max_group)
 583                 max_group = strlen(fi[i].group);
 584             if(fi[i].major != NULL && strlen(fi[i].major) > max_major)
 585                 max_major = strlen(fi[i].major);
 586             if(fi[i].minor != NULL && strlen(fi[i].minor) > max_minor)
 587                 max_minor = strlen(fi[i].minor);
 588             if(fi[i].size != NULL && strlen(fi[i].size) > max_size)
 589                 max_size = strlen(fi[i].size);
 590             if(strlen(fi[i].date) > max_date)
 591                 max_date = strlen(fi[i].date);
 592         }
 593         if(max_size < max_major + max_minor + 2)
 594             max_size = max_major + max_minor + 2;
 595         else if(max_size - max_minor - 2 > max_major)
 596             max_major = max_size - max_minor - 2;
 597         max_inode = find_log10(max_inode);
 598         max_bsize = find_log10(max_bsize);
 599         max_n_link = find_log10(max_n_link);
 600
 601         if(n_print > 0)
 602             sec_fprintf2(out, "total %lu\r\n", (unsigned long)total_blocks);
 603         if(flags & LS_SORT_REVERSE)
 604             for(i = n_files - 1; i >= 0; i--)
 605                 print_file(out,
 606                            flags,
 607                            &fi[i],
 608                            max_inode,
 609                            max_bsize,
 610                            max_n_link,
 611                            max_user,
 612                            max_group,
 613                            max_size,
 614                            max_major,
 615                            max_minor,
 616                            max_date);
 617         else
 618             for(i = 0; i < n_files; i++)
 619                 print_file(out,
 620                            flags,
 621                            &fi[i],
 622                            max_inode,
 623                            max_bsize,
 624                            max_n_link,
 625                            max_user,
 626                            max_group,
 627                            max_size,
 628                            max_major,
 629                            max_minor,
 630                            max_date);
 631     } else if(DISP_MODE(flags) == LS_DISP_COLUMN ||
 632               DISP_MODE(flags) == LS_DISP_CROSS) {
 633         int max_len = 0;
 634         int size_len = 0;
 635         int num_files = n_files;
 636         int columns;
 637         int j;
 638         for(i = 0; i < n_files; i++) {
 639             if(fi[i].filename == NULL) {
 640                 num_files--;
 641                 continue;
 642             }
 643             if(strlen(fi[i].filename) > max_len)
 644                 max_len = strlen(fi[i].filename);
 645             if(find_log10(fi[i].bsize) > size_len)
 646                 size_len = find_log10(fi[i].bsize);
 647         }
 648         if(num_files == 0)
 649             goto next;
 650         if(flags & LS_SIZE) {
 651             columns = 80 / (size_len + 1 + max_len + 1);
 652             max_len = 80 / columns - size_len - 1;
 653         } else {
 654             columns = 80 / (max_len + 1); /* get space between columns */
 655             max_len = 80 / columns;
 656         }
 657         if(flags & LS_SIZE)
 658             sec_fprintf2(out, "total %lu\r\n",
 659                          (unsigned long)total_blocks);
 660         if(DISP_MODE(flags) == LS_DISP_CROSS) {
 661             for(i = 0, j = 0; i < n_files; i++) {
 662                 if(fi[i].filename == NULL)
 663                     continue;
 664                 if(flags & LS_SIZE)
 665                     sec_fprintf2(out, "%*u %-*s", size_len, fi[i].bsize,
 666                                  max_len, fi[i].filename);
 667                 else
 668                     sec_fprintf2(out, "%-*s", max_len, fi[i].filename);
 669                 j++;
 670                 if(j == columns) {
 671                     sec_fprintf2(out, "\r\n");
 672                     j = 0;
 673                 }
 674             }
 675             if(j > 0)
 676                 sec_fprintf2(out, "\r\n");
 677         } else {
 678             int skip = (num_files + columns - 1) / columns;
 679
 680             for(i = 0; i < skip; i++) {
 681                 for(j = i; j < n_files;) {
 682                     while(j < n_files && fi[j].filename == NULL)
 683                         j++;
 684                     if(flags & LS_SIZE)
 685                         sec_fprintf2(out, "%*u %-*s", size_len, fi[j].bsize,
 686                                      max_len, fi[j].filename);
 687                     else
 688                         sec_fprintf2(out, "%-*s", max_len, fi[j].filename);
 689                     j += skip;
 690                 }
 691                 sec_fprintf2(out, "\r\n");
 692             }
 693         }
 694     } else {
 695         for(i = 0; i < n_files; i++) {
 696             if(fi[i].filename == NULL)
 697                 continue;
 698             sec_fprintf2(out, "%s\r\n", fi[i].filename);
 699         }
 700     }
 701  next:
 702     if(((flags & LS_DIRS) == 0 || (flags & LS_RECURSIVE)) && dirs != NULL) {
 703         for(i = 0; i < n_files; i++) {
 704             if(dirs[i]) {
 705                 const char *p = strrchr(files[i], '/');
 706                 if(p == NULL)
 707                     p = files[i];
 708                 else
 709                     p++;
 710                 if(!(flags & LS_DIR_FLAG) || !IS_DOT_DOTDOT(p)) {
 711                     if((flags & LS_SHOW_DIRNAME)) {
 712                         if ((flags & LS_EXTRA_BLANK))
 713                             sec_fprintf2(out, "\r\n");
 714                         sec_fprintf2(out, "%s:\r\n", files[i]);
 715                     }
 716                     list_dir(out, files[i], flags | LS_DIRS | LS_EXTRA_BLANK);
 717                 }
 718             }
 719         }
 720     }
 721  out:
 722     for(i = 0; i < n_files; i++)
 723         free_fileinfo(&fi[i]);
 724     free(fi);
 725     if(dirs != NULL)
 726         free(dirs);
 727     return ret;
 728 }
 729
 730 static void
 731 free_files (char **files, int n)
 732 {
 733     int i;
 734
 735     for (i = 0; i < n; ++i)
 736         free (files[i]);
 737     free (files);
 738 }
 739
 740 static int
 741 hide_file(const char *filename, int flags)
 742 {
 743     if(filename[0] != '.')
 744         return 0;
 745     if((flags & LS_IGNORE_DOT))
 746         return 1;
 747     if(filename[1] == '\0' || (filename[1] == '.' && filename[2] == '\0')) {
 748         if((flags & LS_SHOW_ALL))
 749             return 0;
 750         else
 751             return 1;
 752     }
 753     return 0;
 754 }
 755
 756 static int
 757 list_dir(FILE *out, const char *directory, int flags)
 758 {
 759     DIR *d = opendir(directory);
 760     struct dirent *ent;
 761     char **files = NULL;
 762     int n_files = 0;
 763     int ret;
 764
 765     if(d == NULL) {
 766         syslog(LOG_ERR, "%s: %m", directory);
 767         return -1;
 768     }
 769     while((ent = readdir(d)) != NULL) {
 770         void *tmp;
 771
 772         if(hide_file(ent->d_name, flags))
 773             continue;
 774         tmp = realloc(files, (n_files + 1) * sizeof(*files));
 775         if (tmp == NULL) {
 776             syslog(LOG_ERR, "%s: out of memory", directory);
 777             free_files (files, n_files);
 778             closedir (d);
 779             return -1;
 780         }
 781         files = tmp;
 782         ret = asprintf(&files[n_files], "%s/%s", directory, ent->d_name);
 783         if (ret == -1) {
 784             syslog(LOG_ERR, "%s: out of memory", directory);
 785             free_files (files, n_files);
 786             closedir (d);
 787             return -1;
 788         }
 789         ++n_files;
 790     }
 791     closedir(d);
 792     return list_files(out, (const char**)files, n_files, flags | LS_DIR_FLAG);
 793 }
 794
 795 static int
 796 parse_flags(const char *options)
 797 {
 798 #ifdef TEST
 799     int flags = LS_SORT_NAME | LS_IGNORE_DOT | LS_DISP_COLUMN;
 800 #else
 801     int flags = LS_SORT_NAME | LS_IGNORE_DOT | LS_DISP_LONG;
 802 #endif
 803
 804     const char *p;
 805     if(options == NULL || *options != '-')
 806         return flags;
 807     for(p = options + 1; *p; p++) {
 808         switch(*p) {
 809         case '1':
 810             flags = (flags & ~LS_DISP_MODE);
 811             break;
 812         case 'a':
 813             flags |= LS_SHOW_ALL;
 814             /*FALLTHROUGH*/
 815         case 'A':
 816             flags &= ~LS_IGNORE_DOT;
 817             break;
 818         case 'C':
 819             flags = (flags & ~LS_DISP_MODE) | LS_DISP_COLUMN;
 820             break;
 821         case 'd':
 822             flags |= LS_DIRS;
 823             break;
 824         case 'f':
 825             flags = (flags & ~LS_SORT_MODE);
 826             break;
 827         case 'F':
 828             flags |= LS_TYPE;
 829             break;
 830         case 'i':
 831             flags |= LS_INODE;
 832             break;
 833         case 'l':
 834             flags = (flags & ~LS_DISP_MODE) | LS_DISP_LONG;
 835             break;
 836         case 'r':
 837             flags |= LS_SORT_REVERSE;
 838             break;
 839         case 'R':
 840             flags |= LS_RECURSIVE;
 841             break;
 842         case 's':
 843             flags |= LS_SIZE;
 844             break;
 845         case 'S':
 846             flags = (flags & ~LS_SORT_MODE) | LS_SORT_SIZE;
 847             break;
 848         case 't':
 849             flags = (flags & ~LS_SORT_MODE) | LS_SORT_MTIME;
 850             break;
 851         case 'x':
 852             flags = (flags & ~LS_DISP_MODE) | LS_DISP_CROSS;
 853             break;
 854             /* these are a bunch of unimplemented flags from BSD ls */
 855         case 'k': /* display sizes in kB */
 856         case 'c': /* last change time */
 857         case 'L': /* list symlink target */
 858         case 'm': /* stream output */
 859         case 'o': /* BSD file flags */
 860         case 'p': /* display / after directories */
 861         case 'q': /* print non-graphic characters */
 862         case 'u': /* use last access time */
 863         case 'T': /* display complete time */
 864         case 'W': /* include whiteouts */
 865             break;
 866         }
 867     }
 868     return flags;
 869 }
 870
 871 int
 872 builtin_ls(FILE *out, const char *file)
 873 {
 874     int flags;
 875     int ret;
 876
 877     if(*file == '-') {
 878         flags = parse_flags(file);
 879         file = ".";
 880     } else
 881         flags = parse_flags("");
 882
 883     ret = list_files(out, &file, 1, flags);
 884     sec_fflush(out);
 885     return ret;
 886 }