diff options
Diffstat (limited to 'command/ls.c')
| -rw-r--r-- | command/ls.c | 563 |
1 files changed, 563 insertions, 0 deletions
diff --git a/command/ls.c b/command/ls.c new file mode 100644 index 0000000..8ed796f --- /dev/null +++ b/command/ls.c @@ -0,0 +1,563 @@ +#include "command.h" +#include "lslib.h" + +#include <grp.h> +#include <pwd.h> +#include <dirent.h> +#include <ftw.h> +#include <limits.h> +#include <stdlib.h> +#include <string.h> +#include <errno.h> +#include <unistd.h> +#include <sys/ioctl.h> + +#define FILE_COLOR ANSCII BLACK COLOR +#define DIR_COLOR ANSCII BOLD NEXT NORMAL BLUE COLOR +#define DIR_COLOR_EXEC ANSCII BACKGROUND GREEN NEXT NORMAL BLACK COLOR +#define LINK_COLOR ANSCII BOLD NEXT NORMAL TURQUOISE COLOR +#define SET_UID_COLOR ANSCII BACKGROUND RED NEXT NORMAL WHITE COLOR +#define SET_GID_COLOR ANSCII BACKGROUND YELLOW NEXT NORMAL BLACK COLOR +#define EXEC_COLOR ANSCII BOLD NEXT NORMAL GREEN COLOR +#define BLK_COLOR ANSCII BOLD NEXT NORMAL YELLOW COLOR +#define SOCK_COLOR ANSCII BOLD NEXT NORMAL MAGENTA COLOR + +enum When { + YES, + NO, + AUTO +}; + +static struct { + bool hidden; + bool hide_dot; + bool more_info; + bool one_column; + bool recurse; + enum When colored; +} flags; + +struct FileInfo { + struct passwd* usr; + struct group* grp; + char* name; + char date[13]; + char mode[11]; + char size[5]; + int links; + int bytes; + bool set_uid; + bool set_gid; + bool exec; + unsigned char type; +}; + +struct FileListInfo { + int max_link; + int max_usr; + int max_grp; + int max_size; + int max_name; + int total_len; + int total_size; +}; + +static DIR* get_directory(char* path) { + DIR* d = opendir(path); + if (d == NULL) { + if (errno == ENOTDIR) { + error_s("`%s` is a a file\n", path); + } else { + error_s("failed to open directory '%s': %s\n", path, strerror(errno)); + } + } + return d; +} + +static bool get_file_info(const char* file_name, struct FileInfo* info) { + + uid_t uid; + gid_t gid; + int save, ty; + struct stat s; + size_t file_len; + + uid = getuid(); + gid = getgid(); + + memset(&s, 0, sizeof(struct stat)); + + save = push_path_buffer(file_name); + + if (lstat(get_path_buffer(), &s) < 0) { + error_s("failed to read file '%s': %s\n", get_path_buffer(), strerror(errno)); + pop_path_buffer(save); + return false; + } + + ty = (s.st_mode & S_IFMT) >> 12; + + info->set_uid = false; + info->set_gid = false; + info->exec = false; + + switch (ty) { + case DT_BLK: + info->mode[0] = 'b'; + break; + case DT_CHR: + info->mode[0] = 'c'; + break; + case DT_DIR: + info->mode[0] = 'd'; + break; + case DT_FIFO: + info->mode[0] = 'f'; + break; + case DT_LNK: + info->mode[0] = 'l'; + break; + case DT_SOCK: + info->mode[0] = 's'; + break; + case DT_UNKNOWN: + info->mode[0] = 'u'; + break; + case DT_WHT: + info->mode[0] = 'w'; + break; + default: + info->mode[0] = '-'; + break; + } + + info->mode[1] = (s.st_mode & S_IRUSR) ? 'r' : '-'; + info->mode[2] = (s.st_mode & S_IWUSR) ? 'w' : '-'; + if (s.st_mode & S_IXUSR) { + if (s.st_mode & S_ISUID) { + info->mode[3] = 's'; + info->set_uid = true; + } else { + info->mode[3] = 'x'; + } + if (!info->exec) info->exec = s.st_uid == uid; + } else { + info->mode[3] = '-'; + } + + info->mode[4] = (s.st_mode & S_IRGRP) ? 'r' : '-'; + info->mode[5] = (s.st_mode & S_IWGRP) ? 'w' : '-'; + if (s.st_mode & S_IXGRP) { + if (s.st_mode & S_ISGID) { + info->mode[6] = 's'; + info->set_gid = true; + } else { + info->mode[6] = 'x'; + } + if (!info->exec) info->exec = s.st_gid == gid; + } else { + info->mode[6] = '-'; + } + + info->mode[7] = (s.st_mode & S_IROTH) ? 'r' : '-'; + info->mode[8] = (s.st_mode & S_IWOTH) ? 'w' : '-'; + if (s.st_mode & S_IXOTH) { + info->mode[9] = 'x'; + info->exec = true; + } else { + info->mode[9] = '-'; + } + + info->mode[10] = '\0'; + + info->usr = getpwuid(s.st_uid); + if (info->usr == NULL) { + error_s("failed to get user from `%s`\n", get_path_buffer()); + pop_path_buffer(save); + return false; + } + + info->grp = getgrgid(s.st_gid); + if (info->grp == NULL) { + error_s("failed to get user from `%s`\n", get_path_buffer()); + pop_path_buffer(save); + return false; + } + + info->links = s.st_nlink; + info->type = ty; + + file_len = strlen(file_name) + 1; + info->name = malloc(file_len); + memcpy(info->name, file_name, file_len); + + print_file_size(s.st_size, info->size); + print_date_time(s.st_mtim.tv_sec + s.st_mtim.tv_nsec / 1000000000, info->date); + + info->bytes = (s.st_size + s.st_blksize - 1) / s.st_blksize; + + pop_path_buffer(save); + return true; +} + +static char* get_file_color(struct FileInfo* info) { + char* color; + if (info->type == DT_DIR) { + if (info->mode[8] == 'w') { + color = DIR_COLOR_EXEC; + } else { + color = DIR_COLOR; + } + } else if (info->type == DT_LNK) { + color = LINK_COLOR; + } else if (info->type == DT_SOCK) { + color = SOCK_COLOR; + } else if ( + info->type == DT_CHR || + info->type == DT_BLK + ) { + color = BLK_COLOR; + } else { + if (info->set_uid) { + color = SET_UID_COLOR; + } else if (info->set_gid) { + color = SET_GID_COLOR; + } else if (info->exec) { + color = EXEC_COLOR; + } else { + color = FILE_COLOR; + } + } + return color; +} + +static void list_files(struct FileInfo* files, int file_len, struct FileListInfo info) { + + struct winsize w; + char* color; + int column_width, row_count, i; + + if (flags.more_info) { + char total[13]; + print_file_size(info.total_size, total); + printf("total %s\n", total); + } + + ioctl(STDOUT_FILENO, TIOCGWINSZ, &w); + + if (!isatty(1)) { + flags.one_column = true; + if (flags.colored == AUTO) + flags.colored = NO; + } + + column_width = info.max_name + 1; + row_count = w.ws_col / column_width; + + for (i = 0; i < file_len; i++) { + struct FileInfo finfo = files[i]; + color = get_file_color(&finfo); + if (flags.more_info) { + printf("%s %*d %*s %*s %*s %s %s%s%s", + finfo.mode, + info.max_link, + finfo.links, + info.max_usr, + finfo.usr->pw_name, + info.max_grp, + finfo.grp->gr_name, + info.max_size, + finfo.size, + finfo.date, + flags.colored != NO ? color : "", + finfo.name, + flags.colored != NO ? "\x1b[0m" : "" + ); + if (finfo.type == DT_LNK) { + int save = push_path_buffer(finfo.name); + + char lnk[PATH_MAX]; + ssize_t n; + if ((n = readlink(get_path_buffer(), lnk, PATH_MAX)) != -1) { + printf(" -> %.*s\n", (int)n, lnk); + } else { + putchar('\n'); + } + + pop_path_buffer(save); + } else { + putchar('\n'); + } + } else if (flags.one_column) { + printf("%s%s%s\n", flags.colored != NO ? color : "", finfo.name, flags.colored != NO ? "\x1b[0m" : ""); + } else { + if (info.total_len > w.ws_col) { + if (i != 0 && i % row_count == 0) putchar('\n'); + printf("%s%*s%s", flags.colored != NO ? color : "", -column_width, + finfo.name, flags.colored != NO ? "\x1b[0m" : ""); + } else { + printf("%s%s%s ", flags.colored != NO ? color : "", finfo.name, + flags.colored != NO ? "\x1b[0m" : ""); + } + } + free(finfo.name); + } + + if (!flags.more_info) printf("\n"); +} + +static int num_places (int n) { + int r = 1; + if (n < 0) n = (n == INT_MIN) ? INT_MAX: -n; + while (n > 9) { + n /= 10; + r++; + } + return r; +} + +static void push_file( + struct FileInfo** files, + struct FileListInfo* info, + int* size, int* capacity, + const char* file_path +) { + struct FileInfo finfo; + int user_len, group_len, name_len, size_len, link_len; + + if (!get_file_info(file_path, &finfo)) return; + + if (*size == *capacity) { + *capacity *= 2; + *files = realloc(*files, sizeof(struct FileInfo) * *capacity); + } + + user_len = strlen(finfo.usr->pw_name); + if (user_len > info->max_usr) info->max_usr = user_len; + + group_len = strlen(finfo.grp->gr_name); + if (group_len > info->max_grp) info->max_grp = group_len; + + name_len = strlen(file_path); + if (name_len > info->max_name) info->max_name = name_len; + + size_len = strlen(finfo.size); + if (size_len > info->max_size) info->max_size = size_len; + + link_len = num_places(finfo.links); + if (link_len > info->max_link) info->max_link = link_len; + + info->total_len += name_len + 2; + info->total_size += finfo.bytes; + + (*files)[*size] = finfo; + (*size)++; +} + +static void recurse_directory(char* dir_name) { + DIR* d; + int capacity, size, save; + struct dirent* file; + struct FileInfo* files; + struct FileListInfo info; + + save = push_path_buffer(dir_name); + + d = get_directory(get_path_buffer()); + if (d == NULL) { + return; + } + + capacity = 8; + size = 0; + + files = malloc(sizeof(struct FileInfo) * capacity); + memset(&info, 0, sizeof(struct FileListInfo)); + + while((file = readdir(d)) != NULL) { + if (!flags.hidden && prefix(".", file->d_name)) continue; + if (flags.hide_dot && is_dot_dir(file->d_name)) continue; + if (file->d_type == DT_DIR && !is_dot_dir(file->d_name)) { + recurse_directory(file->d_name); + } else { + push_file(&files, &info, &size, &capacity, file->d_name); + } + } + + + if (flags.colored == NO) { + printf("\n%s:\n", get_path_buffer()); + } else { + printf("\n%s%s:%s\n", DIR_COLOR, get_path_buffer(), FILE_COLOR); + } + + list_files(files, size, info); + + free(files); + + if (!flags.more_info) printf("\n"); + + closedir(d); + + pop_path_buffer(save); +} + +static void list_directory(char* path) { + + DIR* d; + int capacity, size, save; + struct FileInfo* files; + struct FileListInfo info; + struct dirent* file; + + if (flags.recurse) { + recurse_directory(path); + return; + } + + d = get_directory(path); + if (d == NULL) return; + + save = push_path_buffer(path); + + capacity = 8; + size = 0; + + files = malloc(sizeof(struct FileInfo) * capacity); + memset(&info, 0, sizeof(struct FileListInfo)); + + while ((file = readdir(d)) != NULL) { + if (!flags.hidden && prefix(".", file->d_name)) continue; + if (flags.hide_dot && is_dot_dir(file->d_name)) continue; + push_file(&files, &info, &size, &capacity, file->d_name); + } + + if (size > 0) list_files(files, size, info); + free(files); + + pop_path_buffer(save); + + closedir(d); +} + +static bool is_dir(const char* path) { + struct stat s; + if (stat(path, &s) < 0) return false; + return S_ISDIR(s.st_mode); +} + +static void list_file_args(int start, int argc, char** argv) { + + int capacity, size, i; + struct FileInfo* files; + struct FileListInfo info; + + capacity = 8; + size = 0; + + files = malloc(sizeof(struct FileInfo) * capacity); + memset(&info, 0, sizeof(struct FileListInfo)); + + for (i = start; i < argc; i++) { + if (is_dir(argv[i])) continue; + push_file(&files, &info, &size, &capacity, argv[i]); + } + + if (size > 0) list_files(files, size, info); + + free(files); +} + +static void help(void) { + printf("Usage: ls [FILE]...\n\n"); + printf("List directory contents\n\n"); + printf("\t-1\tOne column output\n"); + printf("\t-l\tLong format\n"); + printf("\t-a\tInclude names starting with .\n"); + printf("\t-A\tLike -a but without . and ..\n"); + printf("\t-R\tRecurse\n"); +} + +static int short_arg(char c, char* next) { + UNUSED(next); + switch (c) { + case 'R': + flags.recurse = true; + break; + case '1': + flags.one_column = true; + break; + case 'A': + flags.hide_dot = true; + flags.hidden = true; + break; + case 'a': + flags.hidden = true; + break; + case 'l': + flags.more_info = true; + break; + default: + return ARG_INVALID; + } + return ARG_UNUSED; +} + +static int long_arg(char* cur, char* next) { + UNUSED(next); + if (prefix("--color=", cur)) { + char* arg = cur + 8; + if (streql("yes", arg) || streql("always", arg)) { + flags.colored = YES; + } else if (streql("auto", arg)) { + flags.colored = AUTO; + } else if (streql("no", arg) || streql("never", arg)) { + flags.colored = NO; + } else { + error("invalid color options: %s", arg); + } + } else { + return ARG_IGNORE; + } + return ARG_UNUSED; +} + +COMMAND(ls) { + + int start, i; + bool titled; + + flags.hidden = false; + flags.more_info = false; + flags.hide_dot = false; + flags.one_column = false; + flags.recurse = false; + flags.colored = NO; + + start = parse_args(argc, argv, help, short_arg, long_arg); + + if (argc - start == 0) { + list_directory("."); + return EXIT_SUCCESS; + } + + list_file_args(start, argc, argv); + + titled = argc - start > 1; + for (i = start; i < argc; i++) { + + if (!is_dir(argv[i])) continue; + + if (titled && !flags.recurse) { + if (flags.colored != NO) { + printf("\n%s%s:%s\n", DIR_COLOR, argv[i], FILE_COLOR); + } else { + printf("\n%s:\n", argv[i]); + } + } + + list_directory(argv[i]); + } + + return EXIT_SUCCESS; +} |