| /* vi: set sw=4 ts=4: |
| * |
| * ls.c - list files |
| * |
| * Copyright 2012 Andre Renaud <andre@bluewatersys.com> |
| * |
| * See http://pubs.opengroup.org/onlinepubs/9699919799/utilities/ls.html |
| |
| USE_LS(NEWTOY(ls, "nRlF1a", TOYFLAG_BIN)) |
| |
| config LS |
| bool "ls" |
| default n |
| help |
| usage: ls [-l] [-F] [-a] [-1] [directory...] |
| list files |
| |
| -F append a character as a file type indicator |
| -a list all files |
| -1 list one file per line |
| -l show full details for each file |
| */ |
| |
| /* So that we can do 64-bit stat etc... */ |
| #define _FILE_OFFSET_BITS 64 |
| |
| #include <unistd.h> |
| #include <sys/types.h> |
| #include <grp.h> |
| #include <pwd.h> |
| |
| #include "toys.h" |
| |
| #define FLAG_a 1 |
| #define FLAG_1 2 |
| #define FLAG_F 4 |
| #define FLAG_l 8 |
| #define FLAG_R 16 |
| #define FLAG_n 32 |
| |
| static int dir_filter(const struct dirent *d) |
| { |
| /* Skip over the . & .. entries unless -a is given */ |
| if (!(toys.optflags & FLAG_a)) |
| if (d->d_name[0] == '.') |
| return 0; |
| return 1; |
| } |
| |
| static void do_ls(int fd, char *name) |
| { |
| struct dirent **entries; |
| int nentries; |
| int i; |
| int maxwidth = -1; |
| int ncolumns = 1; |
| struct dirent file_dirent; |
| struct dirent *file_direntp; |
| |
| if (!name || strcmp(name, "-") == 0) |
| name = "."; |
| |
| if (toys.optflags & FLAG_R) |
| xprintf("\n%s:\n", name); |
| |
| /* Get all the files in this directory */ |
| nentries = scandir(name, &entries, dir_filter, alphasort); |
| if (nentries < 0) { |
| /* We've just selected a single file, so create a single-length list */ |
| /* FIXME: This means that ls *.x results in a whole bunch of single |
| * listings, not one combined listing. |
| */ |
| if (errno == ENOTDIR) { |
| nentries = 1; |
| strcpy(file_dirent.d_name, name); |
| file_direntp = &file_dirent; |
| entries = &file_direntp; |
| } else |
| perror_exit("ls: cannot access %s'", name); |
| } |
| |
| |
| /* Determine the widest entry so we can flow them properly */ |
| if (!(toys.optflags & FLAG_1)) { |
| int columns; |
| char *columns_str; |
| |
| for (i = 0; i < nentries; i++) { |
| struct dirent *ent = entries[i]; |
| int width; |
| |
| width = strlen(ent->d_name); |
| if (width > maxwidth) |
| maxwidth = width; |
| } |
| /* We always want at least a single space for each entry */ |
| maxwidth++; |
| if (toys.optflags & FLAG_F) |
| maxwidth++; |
| |
| columns_str = getenv("COLUMNS"); |
| columns = columns_str ? atoi(columns_str) : 80; |
| ncolumns = maxwidth ? columns / maxwidth : 1; |
| } |
| |
| for (i = 0; i < nentries; i++) { |
| struct dirent *ent = entries[i]; |
| int len = strlen(ent->d_name); |
| struct stat st; |
| int stat_valid = 0; |
| |
| sprintf(toybuf, "%s/%s", name, ent->d_name); |
| |
| /* Provide the ls -l long output */ |
| if (toys.optflags & FLAG_l) { |
| char type; |
| char timestamp[64]; |
| struct tm mtime; |
| |
| if (lstat(toybuf, &st)) |
| perror_exit("Can't stat %s", toybuf); |
| stat_valid = 1; |
| if (S_ISDIR(st.st_mode)) |
| type = 'd'; |
| else if (S_ISCHR(st.st_mode)) |
| type = 'c'; |
| else if (S_ISBLK(st.st_mode)) |
| type = 'b'; |
| else if (S_ISLNK(st.st_mode)) |
| type = 'l'; |
| else |
| type = '-'; |
| |
| xprintf("%c%c%c%c%c%c%c%c%c%c ", type, |
| (st.st_mode & S_IRUSR) ? 'r' : '-', |
| (st.st_mode & S_IWUSR) ? 'w' : '-', |
| (st.st_mode & S_IXUSR) ? 'x' : '-', |
| (st.st_mode & S_IRGRP) ? 'r' : '-', |
| (st.st_mode & S_IWGRP) ? 'w' : '-', |
| (st.st_mode & S_IXGRP) ? 'x' : '-', |
| (st.st_mode & S_IROTH) ? 'r' : '-', |
| (st.st_mode & S_IWOTH) ? 'w' : '-', |
| (st.st_mode & S_IXOTH) ? 'x' : '-'); |
| |
| xprintf("%2d ", st.st_nlink); |
| if (toys.optflags & FLAG_n) { |
| xprintf("%4d ", st.st_uid); |
| xprintf("%4d ", st.st_gid); |
| } else { |
| struct passwd *pwd = getpwuid(st.st_uid); |
| struct group *grp = getgrgid(st.st_gid); |
| if (!pwd) |
| xprintf("%4d ", st.st_uid); |
| else |
| xprintf("%-10s ", pwd->pw_name); |
| if (!grp) |
| xprintf("%4d ", st.st_gid); |
| else |
| xprintf("%-10s ", grp->gr_name); |
| } |
| if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) |
| xprintf("%3d, %3d ", major(st.st_rdev), minor(st.st_rdev)); |
| else |
| xprintf("%12lld ", st.st_size); |
| |
| localtime_r(&st.st_mtime, &mtime); |
| |
| strftime(timestamp, sizeof(timestamp), "%b %e %H:%M", &mtime); |
| xprintf("%s ", timestamp); |
| } |
| |
| xprintf("%s", ent->d_name); |
| |
| /* Append the file-type indicator character */ |
| if (toys.optflags & FLAG_F) { |
| if (!stat_valid) { |
| if (lstat(toybuf, &st)) |
| perror_exit("Can't stat %s", toybuf); |
| stat_valid = 1; |
| } |
| if (S_ISDIR(st.st_mode)) { |
| xprintf("/"); |
| len++; |
| } else if (S_ISREG(st.st_mode) && |
| (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))) { |
| xprintf("*"); |
| len++; |
| } else if (S_ISLNK(st.st_mode)) { |
| xprintf("@"); |
| len++; |
| } |
| } |
| if (toys.optflags & FLAG_1) { |
| xprintf("\n"); |
| } else { |
| if (i % ncolumns == ncolumns - 1) |
| xprintf("\n"); |
| else |
| xprintf("%*s", maxwidth - len, ""); |
| } |
| } |
| /* Make sure we put at a trailing new line in */ |
| if (!(toys.optflags & FLAG_1) && (i % ncolumns)) |
| xprintf("\n"); |
| |
| if (toys.optflags & FLAG_R) { |
| for (i = 0; i < nentries; i++) { |
| struct dirent *ent = entries[i]; |
| struct stat st; |
| char dirname[PATH_MAX]; |
| |
| sprintf(dirname, "%s/%s", name, ent->d_name); |
| if (lstat(dirname, &st)) |
| perror_exit("Can't stat %s", dirname); |
| if (S_ISDIR(st.st_mode)) |
| do_ls(0, dirname); |
| } |
| } |
| } |
| |
| void ls_main(void) |
| { |
| /* If the output is not a TTY, then just do one-file per line |
| * This makes ls easier to use with other command line tools (grep/awk etc...) |
| */ |
| if (!isatty(fileno(stdout))) |
| toys.optflags |= FLAG_1; |
| /* Long output must be one-file per line */ |
| if (toys.optflags & FLAG_l) |
| toys.optflags |= FLAG_1; |
| loopfiles(toys.optargs, do_ls); |
| } |
