+/* vi: set sw=4 ts=4: */
+ * Copyright (C) 1996 Brian Candler <B.Candler@pobox.com>
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
+/* [date unknown. Perhaps before year 2000]
+ * To achieve a small memory footprint, this version of 'ls' doesn't do any
+ * file sorting, and only has the most essential command line switches
+ * (i.e., the ones I couldn't live without :-) All features which involve
+ * linking in substantial chunks of libc can be disabled.
+ * Although I don't really want to add new features to this program to
+ * keep it small, I *am* interested to receive bug fixes and ways to make
+ * 1. hidden files can make column width too large
+ * NON-OPTIMAL BEHAVIOUR:
+ * 1. autowidth reads directories twice
+ * 2. if you do a short directory listing without filetype characters
+ * appended, there's no need to stat each one
+ * 1. requires lstat (BSD) - how do you do it without?
+ * ls sorts listing now, and supports almost all options.
+//config: ls is used to list the contents of directories.
+//config:config FEATURE_LS_FILETYPES
+//config: bool "Enable filetyping options (-p and -F)"
+//config:config FEATURE_LS_FOLLOWLINKS
+//config: bool "Enable symlinks dereferencing (-L)"
+//config:config FEATURE_LS_RECURSIVE
+//config: bool "Enable recursion (-R)"
+//config:config FEATURE_LS_WIDTH
+//config: bool "Enable -w WIDTH and window size autodetection"
+//config:config FEATURE_LS_SORTFILES
+//config: bool "Sort the file names"
+//config: Allow ls to sort file names alphabetically.
+//config:config FEATURE_LS_TIMESTAMPS
+//config: bool "Show file timestamps"
+//config: Allow ls to display timestamps for files.
+//config:config FEATURE_LS_USERNAME
+//config: bool "Show username/groupnames"
+//config: Allow ls to display username/groupname for files.
+//config:config FEATURE_LS_COLOR
+//config: bool "Allow use of color to identify file types"
+//config: depends on LS && LONG_OPTS
+//config: This enables the --color option to ls.
+//config:config FEATURE_LS_COLOR_IS_DEFAULT
+//config: bool "Produce colored ls output by default"
+//config: depends on FEATURE_LS_COLOR
+//config: Saying yes here will turn coloring on by default,
+//config: even if no "--color" option is given to the ls command.
+//config: This is not recommended, since the colors are not
+//config: configurable, and the output may not be legible on
+//config: many output screens.
+//applet:IF_LS(APPLET_NOEXEC(ls, ls, BB_DIR_BIN, BB_SUID_DROP, ls))
+//kbuild:lib-$(CONFIG_LS) += ls.o
+//usage:#define ls_trivial_usage
+//usage: IF_FEATURE_LS_FOLLOWLINKS("LH")
+//usage: IF_FEATURE_LS_RECURSIVE("R")
+//usage: IF_FEATURE_LS_FILETYPES("Fp") "lins"
+//usage: IF_FEATURE_HUMAN_READABLE("h")
+//usage: IF_FEATURE_LS_SORTFILES("rSXv")
+//usage: IF_FEATURE_LS_TIMESTAMPS("ctu")
+//usage: IF_SELINUX("kZ") "]"
+//usage: IF_FEATURE_LS_WIDTH(" [-w WIDTH]") " [FILE]..."
+//usage:#define ls_full_usage "\n\n"
+//usage: "List directory contents\n"
+//usage: "\n -1 One column output"
+//usage: "\n -a Include entries which start with ."
+//usage: "\n -A Like -a, but exclude . and .."
+////usage: "\n -C List by columns" - don't show, this is a default anyway
+//usage: "\n -x List by lines"
+//usage: "\n -d List directory entries instead of contents"
+//usage: IF_FEATURE_LS_FOLLOWLINKS(
+//usage: "\n -L Follow symlinks"
+//usage: "\n -H Follow symlinks on command line"
+//usage: IF_FEATURE_LS_RECURSIVE(
+//usage: "\n -R Recurse"
+//usage: IF_FEATURE_LS_FILETYPES(
+//usage: "\n -p Append / to dir entries"
+//usage: "\n -F Append indicator (one of */=@|) to entries"
+//usage: "\n -l Long listing format"
+//usage: "\n -i List inode numbers"
+//usage: "\n -n List numeric UIDs and GIDs instead of names"
+//usage: "\n -s List allocated blocks"
+//usage: IF_FEATURE_LS_TIMESTAMPS(
+//usage: "\n -lc List ctime"
+//usage: "\n -lu List atime"
+//usage: IF_FEATURE_LS_TIMESTAMPS(IF_LONG_OPTS(
+//usage: "\n --full-time List full date and time"
+//usage: IF_FEATURE_HUMAN_READABLE(
+//usage: "\n -h Human readable sizes (1K 243M 2G)"
+//usage: IF_FEATURE_LS_SORTFILES(
+//usage: "\n --group-directories-first"
+//usage: "\n -S Sort by size"
+//usage: "\n -X Sort by extension"
+//usage: "\n -v Sort by version"
+//usage: IF_FEATURE_LS_TIMESTAMPS(
+//usage: "\n -t Sort by mtime"
+//usage: "\n -tc Sort by ctime"
+//usage: "\n -tu Sort by atime"
+//usage: "\n -r Reverse sort order"
+//usage: "\n -Z List security context and permission"
+//usage: IF_FEATURE_LS_WIDTH(
+//usage: "\n -w N Format N columns wide"
+//usage: IF_FEATURE_LS_COLOR(
+//usage: "\n --color[={always,never,auto}] Control coloring"
+#include "./branch_distance.h"
+#include "common_bufsiz.h"
+/* This is a NOEXEC applet. Be very careful! */
+/* ftpd uses ls, and without timestamps Mozilla won't understand
+# undef CONFIG_FEATURE_LS_TIMESTAMPS
+# undef ENABLE_FEATURE_LS_TIMESTAMPS
+# undef IF_FEATURE_LS_TIMESTAMPS
+# undef IF_NOT_FEATURE_LS_TIMESTAMPS
+# define CONFIG_FEATURE_LS_TIMESTAMPS 1
+# define ENABLE_FEATURE_LS_TIMESTAMPS 1
+# define IF_FEATURE_LS_TIMESTAMPS(...) __VA_ARGS__
+# define IF_NOT_FEATURE_LS_TIMESTAMPS(...)
+TERMINAL_WIDTH = 80, /* use 79 if terminal has linefold bug */
+/* -Cadi1l Std options, busybox always supports */
+/* -gnsxA Std options, busybox always supports */
+/* -Q GNU option, busybox always supports */
+/* -k Std option, busybox always supports (by ignoring) */
+/* It means "for -s, show sizes in kbytes" */
+/* Seems to only affect "POSIXLY_CORRECT=1 ls -sk" */
+/* since otherwise -s shows kbytes anyway */
+/* -LHRctur Std options, busybox optionally supports */
+/* -Fp Std options, busybox optionally supports */
+/* -SXvhTw GNU options, busybox optionally supports */
+/* -T WIDTH Ignored (we don't use tabs on output) */
+/* -Z SELinux mandated option, busybox optionally supports */
+static const char ls_options[] ALIGN1 =
+ "Cadi1lgnsxAk" /* 12 opts, total 12 */
+ IF_FEATURE_LS_FILETYPES("Fp") /* 2, 14 */
+ IF_FEATURE_LS_RECURSIVE("R") /* 1, 15 */
+ IF_SELINUX("Z") /* 1, 16 */
+ IF_FEATURE_LS_TIMESTAMPS("ctu") /* 3, 20 */
+ IF_FEATURE_LS_SORTFILES("SXrv") /* 4, 24 */
+ IF_FEATURE_LS_FOLLOWLINKS("LH") /* 2, 26 */
+ IF_FEATURE_HUMAN_READABLE("h") /* 1, 27 */
+ IF_FEATURE_LS_WIDTH("T:w:") /* 2, 29 */
+ OPTBIT_R = OPTBIT_F + 2 * ENABLE_FEATURE_LS_FILETYPES,
+ OPTBIT_Z = OPTBIT_R + 1 * ENABLE_FEATURE_LS_RECURSIVE,
+ OPTBIT_Q = OPTBIT_Z + 1 * ENABLE_SELINUX,
+ OPTBIT_S = OPTBIT_c + 3 * ENABLE_FEATURE_LS_TIMESTAMPS,
+ OPTBIT_L = OPTBIT_S + 4 * ENABLE_FEATURE_LS_SORTFILES,
+ OPTBIT_h = OPTBIT_L + 2 * ENABLE_FEATURE_LS_FOLLOWLINKS,
+ OPTBIT_T = OPTBIT_h + 1 * ENABLE_FEATURE_HUMAN_READABLE,
+ OPTBIT_full_time = OPTBIT_T + 2 * ENABLE_FEATURE_LS_WIDTH,
+ /* with long opts, we use all 32 bits */
+ OPT_F = (1 << OPTBIT_F) * ENABLE_FEATURE_LS_FILETYPES,
+ OPT_p = (1 << OPTBIT_p) * ENABLE_FEATURE_LS_FILETYPES,
+ OPT_R = (1 << OPTBIT_R) * ENABLE_FEATURE_LS_RECURSIVE,
+ OPT_Z = (1 << OPTBIT_Z) * ENABLE_SELINUX,
+ OPT_Q = (1 << OPTBIT_Q),
+ OPT_c = (1 << OPTBIT_c) * ENABLE_FEATURE_LS_TIMESTAMPS,
+ OPT_t = (1 << OPTBIT_t) * ENABLE_FEATURE_LS_TIMESTAMPS,
+ OPT_u = (1 << OPTBIT_u) * ENABLE_FEATURE_LS_TIMESTAMPS,
+ OPT_S = (1 << OPTBIT_S) * ENABLE_FEATURE_LS_SORTFILES,
+ OPT_X = (1 << OPTBIT_X) * ENABLE_FEATURE_LS_SORTFILES,
+ OPT_r = (1 << OPTBIT_r) * ENABLE_FEATURE_LS_SORTFILES,
+ OPT_v = (1 << OPTBIT_v) * ENABLE_FEATURE_LS_SORTFILES,
+ OPT_L = (1 << OPTBIT_L) * ENABLE_FEATURE_LS_FOLLOWLINKS,
+ OPT_H = (1 << OPTBIT_H) * ENABLE_FEATURE_LS_FOLLOWLINKS,
+ OPT_h = (1 << OPTBIT_h) * ENABLE_FEATURE_HUMAN_READABLE,
+ OPT_T = (1 << OPTBIT_T) * ENABLE_FEATURE_LS_WIDTH,
+ OPT_w = (1 << OPTBIT_w) * ENABLE_FEATURE_LS_WIDTH,
+ OPT_full_time = (1 << OPTBIT_full_time ) * ENABLE_LONG_OPTS,
+ OPT_dirs_first = (1 << OPTBIT_dirs_first) * ENABLE_LONG_OPTS,
+ OPT_color = (1 << OPTBIT_color ) * ENABLE_FEATURE_LS_COLOR,
+ * a directory entry and its stat info
+ const char *name; /* usually basename, but think "ls -l dir/file" */
+ const char *fullname; /* full name (usable for stat etc) */
+ struct dnode *dn_next; /* for linked list */
+ IF_SELINUX(security_context_t sid;)
+ smallint fname_allocated;
+ /* Used to avoid re-doing [l]stat at printout stage
+ * if we already collected needed data in scan stage:
+ mode_t dn_mode_lstat; /* obtained with lstat, or 0 */
+ mode_t dn_mode_stat; /* obtained with stat, or 0 */
+// struct stat is huge. We don't need it in full.
+// At least we don't need st_dev and st_blksize,
+// but there are invisible fields as well
+// (such as nanosecond-resolution timespamps)
+// and padding, which we also don't want to store.
+// We also can pre-parse dev_t dn_rdev (in glibc, it's huge).
+// On 32-bit uclibc: dnode size went from 112 to 84 bytes.
+ /* Same names as in struct stat, but with dn_ instead of st_ pfx: */
+ mode_t dn_mode; /* obtained with lstat OR stat, depending on -L etc */
+#if ENABLE_FEATURE_LS_TIMESTAMPS || ENABLE_FEATURE_LS_SORTFILES
+// blksize_t dn_blksize;
+#if ENABLE_FEATURE_LS_COLOR
+# define G_show_color (G.show_color)
+#if ENABLE_FEATURE_LS_WIDTH
+ unsigned terminal_width;
+# define G_terminal_width (G.terminal_width)
+# define G_terminal_width TERMINAL_WIDTH
+#if ENABLE_FEATURE_LS_TIMESTAMPS
+ /* Do time() just once. Saves one syscall per file for "ls -l" */
+#define G (*(struct globals*)bb_common_bufsiz1)
+ setup_common_bufsiz(); \
+ /* we have to zero it out because of NOEXEC */ \
+ memset(&G, 0, sizeof(G)); \
+ IF_FEATURE_LS_WIDTH(G_terminal_width = TERMINAL_WIDTH;) \
+ IF_FEATURE_LS_TIMESTAMPS(time(&G.current_time_t);) \
+/* 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)
+ * and we use 0 for unknown and 15 for executables (see below) */
+#define TYPEINDEX(mode) (((mode) >> 12) & 0x0f)
+/* un fi chr - dir - blk - file - link - sock - - exe */
+#define APPCHAR(mode) ("\0""|""\0""\0""/""\0""\0""\0""\0""\0""@""\0""=""\0""\0""\0" [TYPEINDEX(mode)])
+/* 036 black foreground 050 black background
+ 037 red foreground 051 red background
+ 040 green foreground 052 green background
+ 041 brown foreground 053 brown background
+ 042 blue foreground 054 blue background
+ 043 magenta (purple) foreground 055 magenta background
+ 044 cyan (light blue) foreground 056 cyan background
+ 045 gray foreground 057 white background
+ /*un fi chr - dir - blk - file - link - sock - - exe */ \
+ "\037\043\043\045\042\045\043\043\000\045\044\045\043\045\045\040" \
+/* Select normal (0) [actually "reset all"] or bold (1)
+ * (other attributes are 2:dim 4:underline 5:blink 7:reverse,
+ * let's use 7 for "impossible" types, just for fun)
+ * Note: coreutils 6.9 uses inverted red for setuid binaries.
+ /*un fi chr - dir - blk - file- link- sock- - exe */ \
+ "\01\00\01\07\01\07\01\07\00\07\01\07\01\07\07\01" \
+#if ENABLE_FEATURE_LS_COLOR
+/* mode of zero is interpreted as "unknown" (stat failed) */
+char fgcolor(mode_t mode)
+ if (inst(0, l_and(isEqual(((mode)) & 61440, (32768)), isNotEqual(mode & (64 | (64 >> 3) | ((64 >> 3) >> 3)), 0))))
+ return COLOR(0xF000); /* File is executable ... */
+ if (inst(0, l_and(isEqual(((mode)) & 61440, (32768)), isNotEqual(mode & (64 | (64 >> 3) | ((64 >> 3) >> 3)), 0))))
+ return ATTR(0xF000); /* File is executable ... */
+#if ENABLE_FEATURE_LS_FILETYPES
+static char append_char(mode_t mode)
+ if (!(option_mask32 & (OPT_F|OPT_p)))
+ if (!(option_mask32 & OPT_F))
+ if (S_ISREG(mode) && (mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
+static unsigned calc_name_len(const char *name)
+ // TODO: quote tab as \t, etc, if -Q
+ name = printable_string(&uni_stat, name);
+ if (!(option_mask32 & OPT_Q)) {
+ return uni_stat.unicode_width;
+ len = 2 + uni_stat.unicode_width;
+ if (*name == '"' || *name == '\\') {
+/* Return the number of used columns.
+ * Note that only columnar output uses return value.
+ * -l and -1 modes 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)
+ // TODO: quote tab as \t, etc, if -Q
+ name = printable_string(&uni_stat, name);
+ if (!(option_mask32 & OPT_Q)) {
+ return uni_stat.unicode_width;
+ len = 2 + uni_stat.unicode_width;
+ if (*name == '"' || *name == '\\') {
+/* Return the number of used columns.
+ * Note that only columnar output uses return value,
+ * -l and -1 modes don't care.
+static NOINLINE unsigned display_single(const struct dnode *dn)
+#if ENABLE_FEATURE_LS_FILETYPES || ENABLE_FEATURE_LS_COLOR
+#if ENABLE_FEATURE_LS_FILETYPES
+ append = append_char(dn->dn_mode);
+ /* Do readlink early, so that if it fails, error message
+ * does not appear *inside* the "ls -l" line */
+ if (S_ISLNK(dn->dn_mode))
+ lpath = xmalloc_readlink_or_warn(dn->fullname);
+ if (opt & OPT_i) /* show inode# */
+ column += printf("%7llu ", (long long) dn->dn_ino);
+//TODO: -h should affect -s too:
+ if (opt & OPT_s) /* show allocated blocks */
+ column += printf("%6"OFF_FMT"u ", (off_t) (dn->dn_blocks >> 1));
+ /* long listing: show mode */
+ column += printf("%-10s ", (char *) bb_mode_string(dn->dn_mode));
+ /* long listing: show number of links */
+ column += printf("%4lu ", (long) dn->dn_nlink);
+ /* long listing: show user/group */
+ column += printf("%-8u ", (int) dn->dn_gid);
+ column += printf("%-8u %-8u ",
+#if ENABLE_FEATURE_LS_USERNAME
+ column += printf("%-8.8s ",
+ get_cached_groupname(dn->dn_gid));
+ column += printf("%-8.8s %-8.8s ",
+ get_cached_username(dn->dn_uid),
+ get_cached_groupname(dn->dn_gid));
+ column += printf("%-32s ", dn->sid ? dn->sid : "?");
+ /* long listing: show size */
+ if (S_ISBLK(dn->dn_mode) || S_ISCHR(dn->dn_mode)) {
+ column += printf("%4u, %3u ",
+ column += printf("%"HUMAN_READABLE_MAX_WIDTH_STR"s ",
+ /* print size, show one fractional, use suffixes */
+ make_human_readable_str(dn->dn_size, 1, 0)
+ column += printf("%9"OFF_FMT"u ", dn->dn_size);
+#if ENABLE_FEATURE_LS_TIMESTAMPS
+ /* long listing: show {m,c,a}time */
+ if (opt & OPT_full_time) { /* --full-time */
+ /* coreutils 8.4 ls --full-time prints:
+ * 2009-07-13 17:49:27.000000000 +0200
+ * we don't show fractional seconds.
+ char buf[sizeof("YYYY-mm-dd HH:MM:SS TIMEZONE")];
+ strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S %z",
+ localtime(&dn->dn_time));
+ column += printf("%s ", buf);
+ } else { /* ordinary time format */
+ /* G.current_time_t is ~== time(NULL) */
+ char *filetime = ctime(&dn->dn_time);
+ /* filetime's format: "Wed Jun 30 21:49:08 1993\n" */
+ time_t age = G.current_time_t - dn->dn_time;
+ if (age < 3600L * 24 * 365 / 2 && age > -15 * 60) {
+ /* less than 6 months old */
+ printf("%.12s ", filetime + 4);
+ /* "mmm dd yyyyy " after year 9999 :) */
+ strchr(filetime + 20, '\n')[0] = ' ';
+ printf("%.7s%6s", filetime + 4, filetime + 20);
+#if ENABLE_FEATURE_LS_COLOR
+ mode_t mode = dn->dn_mode_lstat;
+ if (lstat(dn->fullname, &statbuf) == 0)
+ mode = statbuf.st_mode;
+ printf("\033[%u;%um", bold(mode), fgcolor(mode));
+ column += print_name(dn->name);
+#if ENABLE_FEATURE_LS_FILETYPES || ENABLE_FEATURE_LS_COLOR
+ if ((opt & (OPT_F|OPT_p))
+ mode_t mode = dn->dn_mode_stat;
+ if (stat(dn->fullname, &statbuf) == 0)
+ mode = statbuf.st_mode;
+# if ENABLE_FEATURE_LS_FILETYPES
+ append = append_char(mode);
+# if ENABLE_FEATURE_LS_COLOR
+ printf("\033[%u;%um", bold(mode), fgcolor(mode));
+ column += print_name(lpath) + 4;
+#if ENABLE_FEATURE_LS_FILETYPES
+ if (opt & (OPT_F|OPT_p)) {
+static void display_files(struct dnode **dn, unsigned nfiles)
+ unsigned i, ncols, nrows, row, nc;
+ unsigned column_width = 0; /* used only by coulmnal output */
+ if (option_mask32 & (OPT_l|OPT_1)) {
+ /* 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)
+ + ((option_mask32 & OPT_Z) ? 33 : 0) /* context width */
+ + ((option_mask32 & OPT_i) ? 8 : 0) /* inode# width */
+ + ((option_mask32 & OPT_s) ? 5 : 0) /* "alloc block" width */
+ ncols = (unsigned)G_terminal_width / column_width;
+ nrows = nfiles / ncols;
+ if (nrows * ncols < nfiles)
+ nrows++; /* round up fractionals */
+ for (row = 0; row < nrows; row++) {
+ for (nc = 0; nc < ncols; nc++) {
+ /* reach into the array based on the column and row */
+ if (option_mask32 & OPT_x)
+ i = (row * ncols) + nc; /* display across row */
+ i = (nc * nrows) + row; /* display by column */
+ printf("%*s", nexttab, "");
+ nexttab = column + column_width;
+ column += display_single(dn[i]);
+/*** Dir scanning code ***/
+struct dnode *my_stat(const char *fullname, const char *name, int force_follow)
+ cur = xzalloc(sizeof(*cur));
+ cur->fullname = fullname;
+ if (inst(0, l_or(isNotEqual(option_mask32 & OPT_L, 0), isNotEqual(force_follow, 0)))) {
+ if (option_mask32 & OPT_Z) {
+ getfilecon(fullname, &cur->sid);
+ if (inst(1, isNotEqual(stat(fullname, &statbuf), 0))) {
+ bb_simple_perror_msg(fullname);
+ G.exit_code = EXIT_FAILURE;
+ cur->dn_mode_stat = statbuf.st_mode;
+ if (option_mask32 & OPT_Z) {
+ lgetfilecon(fullname, &cur->sid);
+ if (inst(2, isNotEqual(lstat(fullname, &statbuf), 0))) {
+ bb_simple_perror_msg(fullname);
+ G.exit_code = EXIT_FAILURE;
+ cur->dn_mode_lstat = statbuf.st_mode;
+ /* cur->dstat = statbuf: */
+ cur->dn_mode = statbuf.st_mode ;
+ cur->dn_size = statbuf.st_size ;
+#if ENABLE_FEATURE_LS_TIMESTAMPS || ENABLE_FEATURE_LS_SORTFILES
+ cur->dn_time = statbuf.st_mtime ;
+ if (inst(3, isNotEqual(option_mask32 & OPT_u, 0)))
+ cur->dn_time = statbuf.st_atime;
+ if (inst(4, isNotEqual(option_mask32 & OPT_c, 0)))
+ cur->dn_time = statbuf.st_ctime;
+ cur->dn_ino = statbuf.st_ino ;
+ cur->dn_blocks = statbuf.st_blocks;
+ cur->dn_nlink = statbuf.st_nlink ;
+ cur->dn_uid = statbuf.st_uid ;
+ cur->dn_gid = statbuf.st_gid ;
+ cur->dn_rdev_maj = major(statbuf.st_rdev);
+ cur->dn_rdev_min = minor(statbuf.st_rdev);
+static unsigned count_dirs(struct dnode **dn, int which)
+ if (!S_ISDIR((*dn)->dn_mode))
+ if (which != SPLIT_SUBDIR /* if not requested to skip . / .. */
+ /* or if it's not . or .. */
+ || (name[1] && (name[1] != '.' || name[2]))
+ return which != SPLIT_FILE ? dirs : all - dirs;
+/* get memory to hold an array of pointers */
+struct dnode **dnalloc(unsigned num)
+ if (inst(0, isLess(num, 1)))
+ num++; /* so that we have terminating NULL */
+ return xzalloc(num * sizeof(struct dnode *));
+#if ENABLE_FEATURE_LS_RECURSIVE
+static void dfree(struct dnode **dnp)
+ for (i = 0; dnp[i]; i++) {
+ struct dnode *cur = dnp[i];
+ if (cur->fname_allocated)
+ free((char*)cur->fullname);
+#define dfree(...) ((void)0)
+/* Returns NULL-terminated malloced vector of pointers (or NULL) */
+static struct dnode **splitdnarray(struct dnode **dn, int which)
+ /* count how many dirs or files there are */
+ dncnt = count_dirs(dn, which);
+ /* allocate a file array and a dir array */
+ /* copy the entrys into the file or dir array */
+ for (d = 0; *dn; dn++) {
+ if (S_ISDIR((*dn)->dn_mode)) {
+ if (which == SPLIT_FILE)
+ if ((which & SPLIT_DIR) /* any dir... */
+ /* ... or not . or .. */
+ || (name[1] && (name[1] != '.' || name[2]))
+ if (which == SPLIT_FILE) {
+#if ENABLE_FEATURE_LS_SORTFILES
+static int sortcmp(const void *a, const void *b)
+ struct dnode *d1 = *(struct dnode **)a;
+ struct dnode *d2 = *(struct dnode **)b;
+ unsigned opt = option_mask32;
+ dif = 0; /* assume sort by name */
+ // TODO: use pre-initialized function pointer
+ // instead of branch forest
+ if (opt & OPT_dirs_first) {
+ dif = S_ISDIR(d2->dn_mode) - S_ISDIR(d1->dn_mode);
+ goto maybe_invert_and_ret;
+ if (opt & OPT_S) { /* sort by size */
+ dif = (d2->dn_size - d1->dn_size);
+ if (opt & OPT_t) { /* sort by time */
+ dif = (d2->dn_time - d1->dn_time);
+#if defined(HAVE_STRVERSCMP) && HAVE_STRVERSCMP == 1
+ if (opt & OPT_v) { /* sort by version */
+ dif = strverscmp(d1->name, d2->name);
+ if (opt & OPT_X) { /* sort by extension */
+ dif = strcmp(strchrnul(d1->name, '.'), strchrnul(d2->name, '.'));
+ /* sort by name, use as tie breaker for other sorts */
+ if (ENABLE_LOCALE_SUPPORT)
+ dif = strcoll(d1->name, d2->name);
+ dif = strcmp(d1->name, d2->name);
+ /* 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 */
+ /* (this requires dif != 0, and here it is nonzero) */
+ dif = 1 | (int)((uoff_t)dif >> BITS_TO_SHIFT);
+ return (opt & OPT_r) ? -(int)dif : (int)dif;
+static void dnsort(struct dnode **dn, int size)
+ qsort(dn, size, sizeof(*dn), sortcmp);
+static void sort_and_display_files(struct dnode **dn, unsigned nfiles)
+ display_files(dn, nfiles);
+# define dnsort(dn, size) ((void)0)
+# define sort_and_display_files(dn, nfiles) display_files(dn, nfiles)
+/* Returns NULL-terminated malloced vector of pointers (or NULL) */
+struct dnode **scan_one_dir(const char *path, unsigned *nfiles_p)
+ struct dnode *dn, *cur, **dnp;
+ dir = warn_opendir(path);
+ if (inst(0, isEqual((void *)dir, (void *)((void *)0)))) {
+ G.exit_code = EXIT_FAILURE;
+ return NULL; /* could not open the dir */
+ while (inst(1, isNotEqual((int)(entry = readdir(dir)), 0))) {
+ /* are we going to list the file- it may be . or .. or a hidden file */
+ if (inst(2, isEqual(entry->d_name[0], '.'))) {
+ if (inst(4, l_not(isNotEqual(option_mask32 & (OPT_a | OPT_A), 0))))
+ continue; /* skip all dotfiles if no -a/-A */
+ if (inst(5, l_and(l_not(isNotEqual(option_mask32 & OPT_a, 0)), l_or(l_not(isNotEqual(entry->d_name[1], 0)), l_and(isEqual(entry->d_name[1], '.'), l_not(isNotEqual(entry->d_name[2], 0))))))
+ continue; /* if only -A, skip . and .. but show other dotfiles */
+ fullname = concat_path_file(path, entry->d_name);
+ cur = my_stat(fullname, bb_basename(fullname), 0);
+ if (inst(3, l_not(isNotEqual((void *)cur, NULL)))) {
+ cur->fname_allocated = 1;
+ if (inst(6, isEqual((void *)dn, (void *)((void *)0))))
+ /* now that we know how many files there are
+ * allocate memory for an array to hold dnode pointers
+ for (i = 0; /* i < nfiles - detected via !dn below */; i++) {
+ dnp[i] = dn; /* save pointer to node in array */
+ if (inst(8, l_not(isNotEqual((void *)dn, NULL))))
+/* 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
+/* by Jorgen Overgaard (jorgen AT antistaten.se) */
+static off_t calculate_blocks(struct dnode **dn)
+ /* st_blocks is in 512 byte blocks */
+ blocks += (*dn)->dn_blocks;
+ /* 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 */
+static void scan_and_display_dirs_recur(struct dnode **dn, int first)
+ if (G.show_dirname || (option_mask32 & OPT_R)) {
+ printf("%s:\n", (*dn)->fullname);
+ subdnp = scan_one_dir((*dn)->fullname, &nfiles);
+ if (option_mask32 & (OPT_s|OPT_l)) {
+ printf("total %"OFF_FMT"u\n", calculate_blocks(subdnp));
+ /* list all files at this level */
+ sort_and_display_files(subdnp, nfiles);
+ if (ENABLE_FEATURE_LS_RECURSIVE
+ && (option_mask32 & OPT_R)
+ /* recursive - list the sub-dirs */
+ dnd = splitdnarray(subdnp, SPLIT_SUBDIR);
+ dndirs = count_dirs(subdnp, SPLIT_SUBDIR);
+ scan_and_display_dirs_recur(dnd, 0);
+ /* free the array of dnode pointers to the dirs */
+ /* free the dnodes and the fullname mem */
+int ls_main(int argc UNUSED_PARAM, char **argv)
+{ /* ^^^^^^^^^^^^^^^^^ note: if FTPD, argc can be wrong, see ftpd.c */
+#if ENABLE_FEATURE_LS_COLOR
+ /* colored LS support by JaWi, janwillem.janssen@lxtreme.nl */
+ * ls: invalid argument 'BOGUS' for '--color'
+ * 'always', 'yes', 'force'
+ * 'never', 'no', 'none'
+ * 'auto', 'tty', 'if-tty'
+ * (and substrings: "--color=alwa" work too)
+ static const char ls_longopts[] ALIGN1 =
+ "full-time\0" No_argument "\xff"
+ "group-directories-first\0" No_argument "\xfe"
+ "color\0" Optional_argument "\xfd"
+ static const char color_str[] ALIGN1 =
+ "always\0""yes\0""force\0"
+ "auto\0""tty\0""if-tty\0";
+ /* need to initialize since --color has _an optional_ argument */
+ const char *color_opt = color_str; /* "always" */
+#if ENABLE_FEATURE_LS_WIDTH
+ /* obtain the terminal width */
+ G_terminal_width = get_terminal_width(STDIN_FILENO);
+ IF_FEATURE_LS_COLOR(applet_long_options = ls_longopts;)
+ /* -n and -g imply -l */
+ /* --full-time implies -l */
+ IF_FEATURE_LS_TIMESTAMPS(IF_LONG_OPTS(":\xff""l"))
+ /* http://pubs.opengroup.org/onlinepubs/9699919799/utilities/ls.html:
+ * in some pairs of opts, only last one takes effect:
+ IF_FEATURE_LS_TIMESTAMPS(IF_FEATURE_LS_SORTFILES(":t-S:S-t")) /* time/size */
+ // ":m-l:l-m" - we don't have -m
+ IF_FEATURE_LS_FOLLOWLINKS(":H-L:L-H")
+ ":C-xl:x-Cl:l-xC" /* bycols/bylines/long */
+ ":C-1:1-C" /* bycols/oneline */
+ ":x-1:1-x" /* bylines/oneline (not in SuS, but in GNU coreutils 8.4) */
+ IF_FEATURE_LS_TIMESTAMPS(":c-u:u-c") /* mtime/atime */
+ IF_FEATURE_LS_WIDTH(":w+");
+ opt = getopt32(argv, ls_options
+ IF_FEATURE_LS_WIDTH(, /*-T*/ NULL, /*-w*/ &G_terminal_width)
+ IF_FEATURE_LS_COLOR(, &color_opt)
+#if 0 /* option bits debug */
+ bb_error_msg("opt:0x%08x l:%x H:%x color:%x dirs:%x", opt, OPT_l, OPT_H, OPT_color, OPT_dirs_first);
+ if (opt & OPT_c ) bb_error_msg("-c");
+ if (opt & OPT_l ) bb_error_msg("-l");
+ if (opt & OPT_H ) bb_error_msg("-H");
+ if (opt & OPT_color ) bb_error_msg("--color");
+ if (opt & OPT_dirs_first) bb_error_msg("--group-directories-first");
+ if (opt & OPT_full_time ) bb_error_msg("--full-time");
+ if (!is_selinux_enabled())
+ option_mask32 &= ~OPT_Z;
+#if ENABLE_FEATURE_LS_COLOR
+ /* set G_show_color = 1/0 */
+ if (ENABLE_FEATURE_LS_COLOR_IS_DEFAULT && isatty(STDOUT_FILENO)) {
+ char *p = getenv("LS_COLORS");
+ /* LS_COLORS is unset, or (not empty && not "none") ? */
+ if (!p || (p[0] && strcmp(p, "none") != 0))
+ if (color_opt[0] == 'n')
+ else switch (index_in_substrings(color_str, color_opt)) {
+ if (isatty(STDOUT_FILENO)) {
+ /* sort out which command line options take precedence */
+ if (ENABLE_FEATURE_LS_RECURSIVE && (opt & OPT_d))
+ option_mask32 &= ~OPT_R; /* no recurse if listing only dir */
+ if (!(opt & OPT_l)) { /* not -l? */
+ if (ENABLE_FEATURE_LS_TIMESTAMPS && ENABLE_FEATURE_LS_SORTFILES) {
+ /* when to sort by time? -t[cu] sorts by time even with -l */
+ /* (this is achieved by opt_flags[] element for -t) */
+ /* without -l, bare -c or -u enable sort too */
+ /* (with -l, bare -c or -u just select which time to show) */
+ if (opt & (OPT_c|OPT_u)) {
+ option_mask32 |= OPT_t;
+ /* choose a display format if one was not already specified by an option */
+ if (!(option_mask32 & (OPT_l|OPT_1|OPT_x|OPT_C)))
+ option_mask32 |= (isatty(STDOUT_FILENO) ? OPT_C : OPT_1);
+ if (ENABLE_FTPD && applet_name[0] == 'f') {
+ /* ftpd secret backdoor. dirs first are much nicer */
+ option_mask32 |= OPT_dirs_first;
+ G.show_dirname = 1; /* 2 or more items? label directories */
+ /* stuff the command line file names into a dnode array */
+ cur = my_stat(*argv, *argv,
+ /* follow links on command line unless -l, -s or -F: */
+ !(option_mask32 & (OPT_l|OPT_s|OPT_F))
+ || (option_mask32 & OPT_H)
+ /* ... or if -L, but my_stat always follows links if -L */
+ /*cur->fname_allocated = 0; - already is */
+ /* nfiles _may_ be 0 here - try "ls doesnt_exist" */
+ /* now that we know how many files there are
+ * allocate memory for an array to hold dnode pointers
+ for (i = 0; /* i < nfiles - detected via !dn below */; i++) {
+ dnp[i] = dn; /* save pointer to node in array */
+ if (option_mask32 & OPT_d) {
+ sort_and_display_files(dnp, nfiles);
+ dnd = splitdnarray(dnp, SPLIT_DIR);
+ dnf = splitdnarray(dnp, SPLIT_FILE);
+ dndirs = count_dirs(dnp, SPLIT_DIR);
+ dnfiles = nfiles - dndirs;
+ sort_and_display_files(dnf, dnfiles);
+ if (ENABLE_FEATURE_CLEAN_UP)
+ scan_and_display_dirs_recur(dnd, dnfiles == 0);
+ if (ENABLE_FEATURE_CLEAN_UP)
+ if (ENABLE_FEATURE_CLEAN_UP)
