* tiny-ls.c version 0.1.0: A minimalist 'ls'
* Copyright (C) 1996 Brian Candler <B.Candler@pobox.com>
*
- * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
*/
/* [date unknown. Perhaps before year 2000]
enum {
-
TERMINAL_WIDTH = 80, /* use 79 if terminal has linefold bug */
COLUMN_GAP = 2, /* includes the file type char */
SPLIT_DIR = 1,
SPLIT_FILE = 0,
SPLIT_SUBDIR = 2,
-
};
/* "[-]Cadil1", POSIX mandated options, busybox always supports */
/*
* a directory entry and its stat info are stored here
*/
-struct dnode { /* the basic node */
- const char *name; /* the dir entry name */
- const char *fullname; /* the dir entry name */
- int allocated;
+struct dnode {
+ const char *name; /* the dir entry name */
+ const char *fullname; /* the dir entry name */
+ struct dnode *next; /* point at the next node */
+ smallint fname_allocated;
struct stat dstat; /* the file stat info */
IF_SELINUX(security_context_t sid;)
- struct dnode *next; /* point at the next node */
};
-static struct dnode **list_dir(const char *);
-static struct dnode **dnalloc(int);
-static int list_single(const struct dnode *);
-
-
struct globals {
#if ENABLE_FEATURE_LS_COLOR
smallint show_color;
/* Do time() just once. Saves one syscall per file for "ls -l" */
time_t current_time_t;
#endif
-};
+} FIX_ALIASING;
#define G (*(struct globals*)&bb_common_bufsiz1)
#if ENABLE_FEATURE_LS_COLOR
# define show_color (G.show_color )
}
}
- cur = xmalloc(sizeof(struct dnode));
+ cur = xmalloc(sizeof(*cur));
cur->fullname = fullname;
cur->name = name;
cur->dstat = dstat;
return cur;
}
-
/* FYI type values: 1:fifo 2:char 4:dir 6:blk 8:file 10:link 12:socket
* (various wacky OSes: 13:Sun door 14:BSD whiteout 5:XENIX named file
* 3/7:multiplexed char/block device)
}
#endif
-
-#define countdirs(A, B) count_dirs((A), (B), 1)
-#define countsubdirs(A, B) count_dirs((A), (B), 0)
-static int count_dirs(struct dnode **dn, int nfiles, int notsubdirs)
+static unsigned count_dirs(struct dnode **dn, int which)
{
- int i, dirs;
+ unsigned dirs, all;
if (!dn)
return 0;
- dirs = 0;
- for (i = 0; i < nfiles; i++) {
+
+ dirs = all = 0;
+ for (; *dn; dn++) {
const char *name;
- if (!S_ISDIR(dn[i]->dstat.st_mode))
+
+ all++;
+ if (!S_ISDIR((*dn)->dstat.st_mode))
continue;
- name = dn[i]->name;
- if (notsubdirs
- || name[0]!='.' || (name[1] && (name[1]!='.' || name[2]))
+ name = (*dn)->name;
+ if (which != SPLIT_SUBDIR /* if not requested to skip . / .. */
+ /* or if it's not . or .. */
+ || name[0] != '.' || (name[1] && (name[1] != '.' || name[2]))
) {
dirs++;
}
}
- return dirs;
-}
-
-static int countfiles(struct dnode **dnp)
-{
- int nfiles;
- struct dnode *cur;
-
- if (dnp == NULL)
- return 0;
- nfiles = 0;
- for (cur = dnp[0]; cur->next; cur = cur->next)
- nfiles++;
- nfiles++;
- return nfiles;
+ return which != SPLIT_FILE ? dirs : all - dirs;
}
/* get memory to hold an array of pointers */
-static struct dnode **dnalloc(int num)
+static struct dnode **dnalloc(unsigned num)
{
if (num < 1)
return NULL;
+ num++; /* so that we have terminating NULL */
return xzalloc(num * sizeof(struct dnode *));
}
#if ENABLE_FEATURE_LS_RECURSIVE
-static void dfree(struct dnode **dnp, int nfiles)
+static void dfree(struct dnode **dnp)
{
- int i;
+ unsigned i;
if (dnp == NULL)
return;
- for (i = 0; i < nfiles; i++) {
+ for (i = 0; dnp[i]; i++) {
struct dnode *cur = dnp[i];
- if (cur->allocated)
- free((char*)cur->fullname); /* free the filename */
- free(cur); /* free the dnode */
+ if (cur->fname_allocated)
+ free((char*)cur->fullname);
+ free(cur);
}
- free(dnp); /* free the array holding the dnode pointers */
+ free(dnp);
}
#else
#define dfree(...) ((void)0)
#endif
-static struct dnode **splitdnarray(struct dnode **dn, int nfiles, int which)
+/* Returns NULL-terminated malloced vector of pointers (or NULL) */
+static struct dnode **splitdnarray(struct dnode **dn, int which)
{
- int dncnt, i, d;
+ unsigned dncnt, d;
struct dnode **dnp;
- if (dn == NULL || nfiles < 1)
+ if (dn == NULL)
return NULL;
- /* count how many dirs and regular files there are */
- if (which == SPLIT_SUBDIR)
- dncnt = countsubdirs(dn, nfiles);
- else {
- dncnt = countdirs(dn, nfiles); /* assume we are looking for dirs */
- if (which == SPLIT_FILE)
- dncnt = nfiles - dncnt; /* looking for files */
- }
+ /* count how many dirs or files there are */
+ dncnt = count_dirs(dn, which);
/* allocate a file array and a dir array */
dnp = dnalloc(dncnt);
/* copy the entrys into the file or dir array */
- for (d = i = 0; i < nfiles; i++) {
- if (S_ISDIR(dn[i]->dstat.st_mode)) {
+ for (d = 0; *dn; dn++) {
+ if (S_ISDIR((*dn)->dstat.st_mode)) {
const char *name;
+
if (!(which & (SPLIT_DIR|SPLIT_SUBDIR)))
continue;
- name = dn[i]->name;
+ name = (*dn)->name;
if ((which & SPLIT_DIR)
|| name[0]!='.' || (name[1] && (name[1]!='.' || name[2]))
) {
- dnp[d++] = dn[i];
+ dnp[d++] = *dn;
}
} else if (!(which & (SPLIT_DIR|SPLIT_SUBDIR))) {
- dnp[d++] = dn[i];
+ dnp[d++] = *dn;
}
}
return dnp;
struct dnode *d1 = *(struct dnode **)a;
struct dnode *d2 = *(struct dnode **)b;
unsigned sort_opts = all_fmt & SORT_MASK;
- int dif;
+ off_t dif;
dif = 0; /* assume SORT_NAME */
// TODO: use pre-initialized function pointer
// instead of branch forest
if (sort_opts == SORT_SIZE) {
- dif = (int) (d2->dstat.st_size - d1->dstat.st_size);
+ dif = (d2->dstat.st_size - d1->dstat.st_size);
} else if (sort_opts == SORT_ATIME) {
- dif = (int) (d2->dstat.st_atime - d1->dstat.st_atime);
+ dif = (d2->dstat.st_atime - d1->dstat.st_atime);
} else if (sort_opts == SORT_CTIME) {
- dif = (int) (d2->dstat.st_ctime - d1->dstat.st_ctime);
+ dif = (d2->dstat.st_ctime - d1->dstat.st_ctime);
} else if (sort_opts == SORT_MTIME) {
- dif = (int) (d2->dstat.st_mtime - d1->dstat.st_mtime);
+ dif = (d2->dstat.st_mtime - d1->dstat.st_mtime);
} else if (sort_opts == SORT_DIR) {
dif = S_ISDIR(d2->dstat.st_mode) - S_ISDIR(d1->dstat.st_mode);
/* } else if (sort_opts == SORT_VERSION) { */
/* } else if (sort_opts == SORT_EXT) { */
}
-
if (dif == 0) {
- /* sort by name - may be a tie_breaker for time or size cmp */
- if (ENABLE_LOCALE_SUPPORT) dif = strcoll(d1->name, d2->name);
- else dif = strcmp(d1->name, d2->name);
+ /* sort by name, or tie_breaker for other sorts */
+ if (ENABLE_LOCALE_SUPPORT)
+ dif = strcoll(d1->name, d2->name);
+ else
+ dif = strcmp(d1->name, d2->name);
}
- if (all_fmt & SORT_REVERSE) {
- dif = -dif;
+ /* Make dif fit into an int */
+ if (sizeof(dif) > sizeof(int)) {
+ enum { BITS_TO_SHIFT = 8 * (sizeof(dif) - sizeof(int)) };
+ /* shift leaving only "int" worth of bits */
+ if (dif != 0) {
+ dif = 1 | (int)((uoff_t)dif >> BITS_TO_SHIFT);
+ }
}
- return dif;
+
+ return (all_fmt & SORT_REVERSE) ? -(int)dif : (int)dif;
}
static void dnsort(struct dnode **dn, int size)
#endif
-static void showfiles(struct dnode **dn, int nfiles)
+static unsigned calc_name_len(const char *name)
{
- int i, ncols, nrows, row, nc;
- int column = 0;
- int nexttab = 0;
- int column_width = 0; /* for STYLE_LONG and STYLE_SINGLE not used */
+ unsigned len;
+ uni_stat_t uni_stat;
- if (dn == NULL || nfiles < 1)
- return;
+ // TODO: quote tab as \t, etc, if -Q
+ name = printable_string(&uni_stat, name);
- if (all_fmt & STYLE_LONG) {
- ncols = 1;
- } else {
- /* find the longest file name, use that as the column width */
- for (i = 0; i < nfiles; i++) {
- int len = bb_mbstrlen(dn[i]->name);
- if (column_width < len)
- column_width = len;
- }
- column_width += tabstops +
- IF_SELINUX( ((all_fmt & LIST_CONTEXT) ? 33 : 0) + )
- ((all_fmt & LIST_INO) ? 8 : 0) +
- ((all_fmt & LIST_BLOCKS) ? 5 : 0);
- ncols = (int) (terminal_width / column_width);
+ if (!(option_mask32 & OPT_Q)) {
+ return uni_stat.unicode_width;
}
- if (ncols > 1) {
- nrows = nfiles / ncols;
- if (nrows * ncols < nfiles)
- nrows++; /* round up fractionals */
- } else {
- nrows = nfiles;
- ncols = 1;
- }
-
- for (row = 0; row < nrows; row++) {
- for (nc = 0; nc < ncols; nc++) {
- /* reach into the array based on the column and row */
- i = (nc * nrows) + row; /* assume display by column */
- if (all_fmt & DISP_ROWS)
- i = (row * ncols) + nc; /* display across row */
- if (i < nfiles) {
- if (column > 0) {
- nexttab -= column;
- printf("%*s", nexttab, "");
- column += nexttab;
- }
- nexttab = column + column_width;
- column += list_single(dn[i]);
- }
- }
- putchar('\n');
- column = 0;
- }
-}
-
-
-#if ENABLE_DESKTOP
-static off_t calculate_blocks(struct dnode **dn, int nfiles)
-{
- uoff_t blocks = 1;
- while (nfiles) {
- blocks += (*dn)->dstat.st_blocks; /* in 512 byte blocks */
- dn++;
- nfiles--;
- }
-
- /* Even though POSIX says use 512 byte blocks, coreutils use 1k */
- /* Actually, we round up by calculating (blocks + 1) / 2,
- * "+ 1" was done when we initialized blocks to 1 */
- return blocks >> 1;
-}
-#endif
-
-
-static void showdirs(struct dnode **dn, int ndirs, int first)
-{
- int i, nfiles;
- struct dnode **subdnp;
- int dndirs;
- struct dnode **dnd;
-
- if (dn == NULL || ndirs < 1)
- return;
-
- for (i = 0; i < ndirs; i++) {
- if (all_fmt & (DISP_DIRNAME | DISP_RECURSIVE)) {
- if (!first)
- bb_putchar('\n');
- first = 0;
- printf("%s:\n", dn[i]->fullname);
- }
- subdnp = list_dir(dn[i]->fullname);
- nfiles = countfiles(subdnp);
-#if ENABLE_DESKTOP
- if (all_fmt & STYLE_LONG)
- printf("total %"OFF_FMT"u\n", calculate_blocks(subdnp, nfiles));
-#endif
- if (nfiles > 0) {
- /* list all files at this level */
- dnsort(subdnp, nfiles);
- showfiles(subdnp, nfiles);
- if (ENABLE_FEATURE_LS_RECURSIVE) {
- if (all_fmt & DISP_RECURSIVE) {
- /* recursive- list the sub-dirs */
- dnd = splitdnarray(subdnp, nfiles, SPLIT_SUBDIR);
- dndirs = countsubdirs(subdnp, nfiles);
- if (dndirs > 0) {
- dnsort(dnd, dndirs);
- showdirs(dnd, dndirs, 0);
- /* free the array of dnode pointers to the dirs */
- free(dnd);
- }
- }
- /* free the dnodes and the fullname mem */
- dfree(subdnp, nfiles);
- }
+ len = 2 + uni_stat.unicode_width;
+ while (*name) {
+ if (*name == '"' || *name == '\\') {
+ len++;
}
+ name++;
}
+ return len;
}
-static struct dnode **list_dir(const char *path)
+/* Return the number of used columns.
+ * Note that only STYLE_COLUMNS uses return value.
+ * STYLE_SINGLE and STYLE_LONG don't care.
+ * coreutils 7.2 also supports:
+ * ls -b (--escape) = octal escapes (although it doesn't look like working)
+ * ls -N (--literal) = not escape at all
+ */
+static unsigned print_name(const char *name)
{
- struct dnode *dn, *cur, **dnp;
- struct dirent *entry;
- DIR *dir;
- int i, nfiles;
+ unsigned len;
+ uni_stat_t uni_stat;
- if (path == NULL)
- return NULL;
+ // TODO: quote tab as \t, etc, if -Q
+ name = printable_string(&uni_stat, name);
- dn = NULL;
- nfiles = 0;
- dir = warn_opendir(path);
- if (dir == NULL) {
- exit_code = EXIT_FAILURE;
- return NULL; /* could not open the dir */
+ if (!(option_mask32 & OPT_Q)) {
+ fputs(name, stdout);
+ return uni_stat.unicode_width;
}
- while ((entry = readdir(dir)) != NULL) {
- char *fullname;
- /* are we going to list the file- it may be . or .. or a hidden file */
- if (entry->d_name[0] == '.') {
- if ((!entry->d_name[1] || (entry->d_name[1] == '.' && !entry->d_name[2]))
- && !(all_fmt & DISP_DOT)
- ) {
- continue;
- }
- if (!(all_fmt & DISP_HIDDEN))
- continue;
+ len = 2 + uni_stat.unicode_width;
+ putchar('"');
+ while (*name) {
+ if (*name == '"' || *name == '\\') {
+ putchar('\\');
+ len++;
}
- fullname = concat_path_file(path, entry->d_name);
- cur = my_stat(fullname, bb_basename(fullname), 0);
- if (!cur) {
- free(fullname);
- continue;
- }
- cur->allocated = 1;
- cur->next = dn;
- dn = cur;
- nfiles++;
+ putchar(*name++);
}
- closedir(dir);
-
- /* now that we know how many files there are
- * allocate memory for an array to hold dnode pointers
- */
- if (dn == NULL)
- return NULL;
- dnp = dnalloc(nfiles);
- for (i = 0, cur = dn; i < nfiles; i++) {
- dnp[i] = cur; /* save pointer to node in array */
- cur = cur->next;
- }
-
- return dnp;
+ putchar('"');
+ return len;
}
-
-static int print_name(const char *name)
-{
- if (option_mask32 & OPT_Q) {
-#if ENABLE_FEATURE_ASSUME_UNICODE
- int len = 2 + bb_mbstrlen(name);
-#else
- int len = 2;
-#endif
- putchar('"');
- while (*name) {
- if (*name == '"') {
- putchar('\\');
- len++;
- }
- putchar(*name++);
- if (!ENABLE_FEATURE_ASSUME_UNICODE)
- len++;
- }
- putchar('"');
- return len;
- }
- /* No -Q: */
-#if ENABLE_FEATURE_ASSUME_UNICODE
- fputs(name, stdout);
- return bb_mbstrlen(name);
-#else
- return printf("%s", name);
-#endif
-}
-
-
-static int list_single(const struct dnode *dn)
+/* Return the number of used columns.
+ * Note that only STYLE_COLUMNS uses return value,
+ * STYLE_SINGLE and STYLE_LONG don't care.
+ */
+static NOINLINE unsigned list_single(const struct dnode *dn)
{
- int column = 0;
+ unsigned column = 0;
char *lpath = lpath; /* for compiler */
-#if ENABLE_FEATURE_LS_TIMESTAMPS
- char *filetime;
- time_t ttime, age;
-#endif
#if ENABLE_FEATURE_LS_FILETYPES || ENABLE_FEATURE_LS_COLOR
struct stat info;
char append;
#endif
+ /* Never happens:
if (dn->fullname == NULL)
return 0;
+ */
-#if ENABLE_FEATURE_LS_TIMESTAMPS
- ttime = dn->dstat.st_mtime; /* the default time */
- if (all_fmt & TIME_ACCESS)
- ttime = dn->dstat.st_atime;
- if (all_fmt & TIME_CHANGE)
- ttime = dn->dstat.st_ctime;
- filetime = ctime(&ttime);
-#endif
#if ENABLE_FEATURE_LS_FILETYPES
append = append_char(dn->dstat.st_mode);
#endif
/* Do readlink early, so that if it fails, error message
- * does not appear *inside* of the "ls -l" line */
+ * does not appear *inside* the "ls -l" line */
if (all_fmt & LIST_SYMLINK)
if (S_ISLNK(dn->dstat.st_mode))
lpath = xmalloc_readlink_or_warn(dn->fullname);
if (all_fmt & LIST_INO)
- column += printf("%7lu ", (long) dn->dstat.st_ino);
+ column += printf("%7llu ", (long long) dn->dstat.st_ino);
if (all_fmt & LIST_BLOCKS)
- column += printf("%4"OFF_FMT"u ", (off_t) dn->dstat.st_blocks >> 1);
+ column += printf("%4"OFF_FMT"u ", (off_t) (dn->dstat.st_blocks >> 1));
if (all_fmt & LIST_MODEBITS)
column += printf("%-10s ", (char *) bb_mode_string(dn->dstat.st_mode));
if (all_fmt & LIST_NLINKS)
#if ENABLE_FEATURE_LS_USERNAME
if (all_fmt & LIST_ID_NAME) {
if (option_mask32 & OPT_g) {
- column += printf("%-8.8s",
+ column += printf("%-8.8s ",
get_cached_username(dn->dstat.st_uid));
} else {
- column += printf("%-8.8s %-8.8s",
+ column += printf("%-8.8s %-8.8s ",
get_cached_username(dn->dstat.st_uid),
get_cached_groupname(dn->dstat.st_gid));
}
#endif
if (all_fmt & LIST_ID_NUMERIC) {
if (option_mask32 & OPT_g)
- column += printf("%-8u", (int) dn->dstat.st_uid);
+ column += printf("%-8u ", (int) dn->dstat.st_uid);
else
- column += printf("%-8u %-8u",
+ column += printf("%-8u %-8u ",
(int) dn->dstat.st_uid,
(int) dn->dstat.st_gid);
}
(int) minor(dn->dstat.st_rdev));
} else {
if (all_fmt & LS_DISP_HR) {
- column += printf("%9s ",
- make_human_readable_str(dn->dstat.st_size, 1, 0));
+ column += printf("%"HUMAN_READABLE_MAX_WIDTH_STR"s ",
+ /* print st_size, show one fractional, use suffixes */
+ make_human_readable_str(dn->dstat.st_size, 1, 0)
+ );
} else {
column += printf("%9"OFF_FMT"u ", (off_t) dn->dstat.st_size);
}
}
}
#if ENABLE_FEATURE_LS_TIMESTAMPS
- if (all_fmt & LIST_FULLTIME)
- column += printf("%24.24s ", filetime);
- if (all_fmt & LIST_DATE_TIME)
- if ((all_fmt & LIST_FULLTIME) == 0) {
+ if (all_fmt & (LIST_FULLTIME|LIST_DATE_TIME)) {
+ char *filetime;
+ time_t ttime = dn->dstat.st_mtime;
+ if (all_fmt & TIME_ACCESS)
+ ttime = dn->dstat.st_atime;
+ if (all_fmt & TIME_CHANGE)
+ ttime = dn->dstat.st_ctime;
+ filetime = ctime(&ttime);
+ /* filetime's format: "Wed Jun 30 21:49:08 1993\n" */
+ if (all_fmt & LIST_FULLTIME)
+ column += printf("%.24s ", filetime);
+ else { /* LIST_DATE_TIME */
/* current_time_t ~== time(NULL) */
- age = current_time_t - ttime;
- printf("%6.6s ", filetime + 4);
+ time_t age = current_time_t - ttime;
+ printf("%.6s ", filetime + 4); /* "Jun 30" */
if (age < 3600L * 24 * 365 / 2 && age > -15 * 60) {
/* hh:mm if less than 6 months old */
- printf("%5.5s ", filetime + 11);
- } else {
- printf(" %4.4s ", filetime + 20);
+ printf("%.5s ", filetime + 11);
+ } else { /* year. buggy if year > 9999 ;) */
+ printf(" %.4s ", filetime + 20);
}
column += 13;
}
+ }
#endif
#if ENABLE_SELINUX
if (all_fmt & LIST_CONTEXT) {
return column;
}
+static void showfiles(struct dnode **dn, unsigned nfiles)
+{
+ unsigned i, ncols, nrows, row, nc;
+ unsigned column = 0;
+ unsigned nexttab = 0;
+ unsigned column_width = 0; /* used only by STYLE_COLUMNS */
+
+ if (all_fmt & STYLE_LONG) { /* STYLE_LONG or STYLE_SINGLE */
+ ncols = 1;
+ } else {
+ /* find the longest file name, use that as the column width */
+ for (i = 0; dn[i]; i++) {
+ int len = calc_name_len(dn[i]->name);
+ if (column_width < len)
+ column_width = len;
+ }
+ column_width += tabstops +
+ IF_SELINUX( ((all_fmt & LIST_CONTEXT) ? 33 : 0) + )
+ ((all_fmt & LIST_INO) ? 8 : 0) +
+ ((all_fmt & LIST_BLOCKS) ? 5 : 0);
+ ncols = (int) (terminal_width / column_width);
+ }
+
+ if (ncols > 1) {
+ nrows = nfiles / ncols;
+ if (nrows * ncols < nfiles)
+ nrows++; /* round up fractionals */
+ } else {
+ nrows = nfiles;
+ ncols = 1;
+ }
+
+ for (row = 0; row < nrows; row++) {
+ for (nc = 0; nc < ncols; nc++) {
+ /* reach into the array based on the column and row */
+ if (all_fmt & DISP_ROWS)
+ i = (row * ncols) + nc; /* display across row */
+ else
+ i = (nc * nrows) + row; /* display by column */
+ if (i < nfiles) {
+ if (column > 0) {
+ nexttab -= column;
+ printf("%*s", nexttab, "");
+ column += nexttab;
+ }
+ nexttab = column + column_width;
+ column += list_single(dn[i]);
+ }
+ }
+ putchar('\n');
+ column = 0;
+ }
+}
+
+
+#if ENABLE_DESKTOP
+/* http://www.opengroup.org/onlinepubs/9699919799/utilities/ls.html
+ * If any of the -l, -n, -s options is specified, each list
+ * of files within the directory shall be preceded by a
+ * status line indicating the number of file system blocks
+ * occupied by files in the directory in 512-byte units if
+ * the -k option is not specified, or 1024-byte units if the
+ * -k option is specified, rounded up to the next integral
+ * number of units.
+ */
+/* by Jorgen Overgaard (jorgen AT antistaten.se) */
+static off_t calculate_blocks(struct dnode **dn)
+{
+ uoff_t blocks = 1;
+ if (dn) {
+ while (*dn) {
+ /* st_blocks is in 512 byte blocks */
+ blocks += (*dn)->dstat.st_blocks;
+ dn++;
+ }
+ }
+
+ /* Even though standard says use 512 byte blocks, coreutils use 1k */
+ /* Actually, we round up by calculating (blocks + 1) / 2,
+ * "+ 1" was done when we initialized blocks to 1 */
+ return blocks >> 1;
+}
+#endif
+
+
+static struct dnode **list_dir(const char *, unsigned *);
+
+static void showdirs(struct dnode **dn, int first)
+{
+ unsigned nfiles;
+ unsigned dndirs;
+ struct dnode **subdnp;
+ struct dnode **dnd;
+
+ /* Never happens:
+ if (dn == NULL || ndirs < 1) {
+ return;
+ }
+ */
+
+ for (; *dn; dn++) {
+ if (all_fmt & (DISP_DIRNAME | DISP_RECURSIVE)) {
+ if (!first)
+ bb_putchar('\n');
+ first = 0;
+ printf("%s:\n", (*dn)->fullname);
+ }
+ subdnp = list_dir((*dn)->fullname, &nfiles);
+#if ENABLE_DESKTOP
+ if ((all_fmt & STYLE_MASK) == STYLE_LONG)
+ printf("total %"OFF_FMT"u\n", calculate_blocks(subdnp));
+#endif
+ if (nfiles > 0) {
+ /* list all files at this level */
+ dnsort(subdnp, nfiles);
+ showfiles(subdnp, nfiles);
+ if (ENABLE_FEATURE_LS_RECURSIVE
+ && (all_fmt & DISP_RECURSIVE)
+ ) {
+ /* recursive - list the sub-dirs */
+ dnd = splitdnarray(subdnp, SPLIT_SUBDIR);
+ dndirs = count_dirs(subdnp, SPLIT_SUBDIR);
+ if (dndirs > 0) {
+ dnsort(dnd, dndirs);
+ showdirs(dnd, 0);
+ /* free the array of dnode pointers to the dirs */
+ free(dnd);
+ }
+ }
+ /* free the dnodes and the fullname mem */
+ dfree(subdnp);
+ }
+ }
+}
+
+
+/* Returns NULL-terminated malloced vector of pointers (or NULL) */
+static struct dnode **list_dir(const char *path, unsigned *nfiles_p)
+{
+ struct dnode *dn, *cur, **dnp;
+ struct dirent *entry;
+ DIR *dir;
+ unsigned i, nfiles;
+
+ /* Never happens:
+ if (path == NULL)
+ return NULL;
+ */
+
+ *nfiles_p = 0;
+ dir = warn_opendir(path);
+ if (dir == NULL) {
+ exit_code = EXIT_FAILURE;
+ return NULL; /* could not open the dir */
+ }
+ dn = NULL;
+ nfiles = 0;
+ while ((entry = readdir(dir)) != NULL) {
+ char *fullname;
+
+ /* are we going to list the file- it may be . or .. or a hidden file */
+ if (entry->d_name[0] == '.') {
+ if ((!entry->d_name[1] || (entry->d_name[1] == '.' && !entry->d_name[2]))
+ && !(all_fmt & DISP_DOT)
+ ) {
+ continue;
+ }
+ if (!(all_fmt & DISP_HIDDEN))
+ continue;
+ }
+ fullname = concat_path_file(path, entry->d_name);
+ cur = my_stat(fullname, bb_basename(fullname), 0);
+ if (!cur) {
+ free(fullname);
+ continue;
+ }
+ cur->fname_allocated = 1;
+ cur->next = dn;
+ dn = cur;
+ nfiles++;
+ }
+ closedir(dir);
+
+ if (dn == NULL)
+ return NULL;
+
+ /* now that we know how many files there are
+ * allocate memory for an array to hold dnode pointers
+ */
+ *nfiles_p = nfiles;
+ dnp = dnalloc(nfiles);
+ for (i = 0; /* i < nfiles - detected via !dn below */; i++) {
+ dnp[i] = dn; /* save pointer to node in array */
+ dn = dn->next;
+ if (!dn)
+ break;
+ }
+
+ return dnp;
+}
+
int ls_main(int argc UNUSED_PARAM, char **argv)
{
struct dnode *dn;
struct dnode *cur;
unsigned opt;
- int nfiles;
- int dnfiles;
- int dndirs;
- int i;
+ unsigned nfiles;
+ unsigned dnfiles;
+ unsigned dndirs;
+ unsigned i;
#if ENABLE_FEATURE_LS_COLOR
/* colored LS support by JaWi, janwillem.janssen@lxtreme.nl */
/* coreutils 6.10:
INIT_G();
- check_unicode_in_env();
+ init_unicode();
all_fmt = LIST_SHORT |
(ENABLE_FEATURE_LS_SORTFILES * (SORT_NAME | SORT_FORWARD));
argv++;
if (!cur)
continue;
- cur->allocated = 0;
+ cur->fname_allocated = 0;
cur->next = dn;
dn = cur;
nfiles++;
} while (*argv);
+ /* nfiles _may_ be 0 here - try "ls doesnt_exist" */
+ if (nfiles == 0)
+ return exit_code;
+
/* now that we know how many files there are
* allocate memory for an array to hold dnode pointers
*/
dnp = dnalloc(nfiles);
- for (i = 0, cur = dn; i < nfiles; i++) {
- dnp[i] = cur; /* save pointer to node in array */
- cur = cur->next;
+ for (i = 0; /* i < nfiles - detected via !dn below */; i++) {
+ dnp[i] = dn; /* save pointer to node in array */
+ dn = dn->next;
+ if (!dn)
+ break;
}
if (all_fmt & DISP_NOLIST) {
dnsort(dnp, nfiles);
- if (nfiles > 0)
- showfiles(dnp, nfiles);
+ showfiles(dnp, nfiles);
} else {
- dnd = splitdnarray(dnp, nfiles, SPLIT_DIR);
- dnf = splitdnarray(dnp, nfiles, SPLIT_FILE);
- dndirs = countdirs(dnp, nfiles);
+ dnd = splitdnarray(dnp, SPLIT_DIR);
+ dnf = splitdnarray(dnp, SPLIT_FILE);
+ dndirs = count_dirs(dnp, SPLIT_DIR);
dnfiles = nfiles - dndirs;
if (dnfiles > 0) {
dnsort(dnf, dnfiles);
}
if (dndirs > 0) {
dnsort(dnd, dndirs);
- showdirs(dnd, dndirs, dnfiles == 0);
+ showdirs(dnd, dnfiles == 0);
if (ENABLE_FEATURE_CLEAN_UP)
free(dnd);
}
}
if (ENABLE_FEATURE_CLEAN_UP)
- dfree(dnp, nfiles);
+ dfree(dnp);
return exit_code;
}