447 lines
8.2 KiB
C
447 lines
8.2 KiB
C
#include <pwd.h>
|
|
#include <grp.h>
|
|
#include <time.h>
|
|
#include <stdio.h>
|
|
#include <errno.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <stdint.h>
|
|
#include <unistd.h>
|
|
#include <dirent.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
#include <sys/ioctl.h>
|
|
#include "mode_to_str.h"
|
|
#include "make_path.h"
|
|
#include "get_stat.h"
|
|
#include "config.h"
|
|
#include "human.h"
|
|
|
|
char O_flag;
|
|
char a_flag;
|
|
char l_flag;
|
|
char F_flag;
|
|
char c_flag;
|
|
char R_flag;
|
|
char d_flag;
|
|
char L_flag;
|
|
char h_flag;
|
|
char s_flag;
|
|
char i_flag;
|
|
char p_flag;
|
|
|
|
int sortd(const void *p1, const void *p2);
|
|
int (*sorter)(const void *p1, const void *p2) = sortd;
|
|
|
|
struct d_node {
|
|
/* basename */
|
|
char *name;
|
|
|
|
/* For free */
|
|
char *full_name;
|
|
|
|
struct d_node *next;
|
|
struct stat stats;
|
|
};
|
|
|
|
/* Work with dir */
|
|
struct d_node *stat_file(char *filename, int lfile) {
|
|
/* lfile its flag. 1 if passed file from list_one() */
|
|
struct d_node *file = malloc(sizeof(struct d_node));
|
|
if (file == NULL)
|
|
return NULL;
|
|
|
|
if (mu_get_stats("ls", !L_flag, filename, &file->stats)) {
|
|
free(file);
|
|
return NULL;
|
|
}
|
|
|
|
file->full_name = filename;
|
|
file->name = strrchr(filename, '/');
|
|
if (file->name == NULL || lfile)
|
|
file->name = filename;
|
|
|
|
else
|
|
file->name++;
|
|
|
|
return file;
|
|
}
|
|
|
|
struct d_node **list(const char *path, size_t *nfiles, int *ret) {
|
|
DIR *dp = opendir(path);
|
|
if (dp == NULL) {
|
|
fprintf(stderr, "ls: %s: %s\n", path, strerror(errno));
|
|
return NULL;
|
|
}
|
|
|
|
struct d_node *dn, *cur;
|
|
|
|
struct dirent *ep;
|
|
while ((ep = readdir(dp)) != NULL) {
|
|
if (ep->d_name[0] == '.' && !a_flag)
|
|
continue;
|
|
|
|
char *full_path = mu_make_path("ls", path, ep->d_name);
|
|
if (full_path == NULL)
|
|
continue;
|
|
|
|
cur = stat_file(full_path, 0);
|
|
if (cur == NULL) {
|
|
*ret = 1;
|
|
free(full_path);
|
|
continue;
|
|
}
|
|
|
|
cur->next = dn;
|
|
dn = cur;
|
|
|
|
(*nfiles)++;
|
|
}
|
|
|
|
closedir(dp);
|
|
|
|
if (dn == NULL)
|
|
return NULL;
|
|
|
|
struct d_node **dir = malloc(*nfiles * sizeof(struct d_node *));
|
|
if (dir == NULL) {
|
|
fprintf(stderr, "ls: malloc failed\n");
|
|
return NULL;
|
|
}
|
|
|
|
for (int i = 0; i < *nfiles; i++) {
|
|
dir[i] = dn;
|
|
dn = dn->next;
|
|
}
|
|
|
|
return dir;
|
|
}
|
|
|
|
struct d_node **list_one(const char *path, int *ret) {
|
|
struct d_node **dir = malloc(sizeof(struct d_node *) * 2);
|
|
if (dir == NULL) {
|
|
fprintf(stderr, "ls: malloc failed\n");
|
|
exit(1);
|
|
}
|
|
|
|
char *new_path = strdup(path);
|
|
if (new_path == NULL)
|
|
goto ERROR;
|
|
|
|
dir[0] = stat_file(new_path, 1);
|
|
if (dir[0] == NULL)
|
|
goto ERROR_PATH;
|
|
|
|
dir[1] = NULL;
|
|
return dir;
|
|
|
|
ERROR_PATH:
|
|
*ret = 1;
|
|
free(new_path);
|
|
|
|
ERROR:
|
|
free(dir);
|
|
return NULL;
|
|
|
|
}
|
|
|
|
void dfree(struct d_node **dir, size_t files) {
|
|
for (size_t i = 0; i < files; i++) {
|
|
free(dir[i]->full_name);
|
|
free(dir[i]);
|
|
}
|
|
|
|
free(dir);
|
|
}
|
|
|
|
char *get_date(time_t mtime) {
|
|
static char date[100];
|
|
|
|
strftime(date, sizeof(date), "%b %d %H:%M", localtime(&mtime));
|
|
|
|
return date;
|
|
}
|
|
|
|
/* Print */
|
|
int print(const struct d_node *node) {
|
|
char suf = ' ';
|
|
char *color = "";
|
|
|
|
char *mode = mu_mode_2_str(node->stats.st_mode);
|
|
if (S_ISDIR(node->stats.st_mode)) {
|
|
if (node->name[strlen(node->name) - 1] != '/')
|
|
suf = '/';
|
|
|
|
mode[0] = 'd';
|
|
color = LS_DIR_COLOR;
|
|
}
|
|
|
|
else if (S_ISLNK(node->stats.st_mode)) {
|
|
suf = '@';
|
|
mode[0] = 'l';
|
|
color = LS_LINK_COLOR;
|
|
}
|
|
|
|
else if (S_ISSOCK(node->stats.st_mode)) {
|
|
suf = '=';
|
|
mode[0] = 's';
|
|
color = LS_SOCK_COLOR;
|
|
}
|
|
|
|
else if (S_ISBLK(node->stats.st_mode)) {
|
|
mode[0] = 'b';
|
|
color = LS_BLOCK_COLOR;
|
|
}
|
|
|
|
else if (S_ISFIFO(node->stats.st_mode)) {
|
|
suf = '|';
|
|
mode[0] = 'p';
|
|
color = LS_FIFO_COLOR;
|
|
}
|
|
|
|
else if ((node->stats.st_mode & S_IXUSR) || (node->stats.st_mode & S_IXGRP) || (node->stats.st_mode & S_IXOTH)) {
|
|
suf = '*';
|
|
color = LS_EXE_COLOR;
|
|
}
|
|
|
|
int ret = 0;
|
|
if (i_flag)
|
|
ret += printf("%7jd ", node->stats.st_ino);
|
|
|
|
if (s_flag) {
|
|
off_t size = 512 * node->stats.st_blocks;
|
|
if (h_flag)
|
|
ret += printf("%7s ", mu_humansize(size, 1024));
|
|
|
|
else
|
|
ret += printf("%7jd ", size / 1024);
|
|
}
|
|
|
|
if (l_flag) {
|
|
printf("%s", mode);
|
|
|
|
struct passwd *pw = getpwuid(node->stats.st_uid);
|
|
struct group *gr = getgrgid(node->stats.st_gid);
|
|
|
|
char *gr_name = (gr != 0) ? gr->gr_name : "nobody";
|
|
char *pw_name = (pw != 0) ? pw->pw_name : "nobody";
|
|
if (h_flag)
|
|
ret += printf(" %4u %4s %6s %6s %s ", node->stats.st_nlink, pw_name, gr_name, mu_humansize(node->stats.st_size, 1024), get_date(node->stats.st_mtime));
|
|
|
|
else
|
|
ret += printf(" %4u %4s %6s %10ld %s ", node->stats.st_nlink, pw_name, gr_name, node->stats.st_size, get_date(node->stats.st_mtime));
|
|
}
|
|
|
|
if (c_flag && p_flag)
|
|
printf("%s", color);
|
|
|
|
ret += printf("%s", node->name);
|
|
if (c_flag && p_flag)
|
|
printf("\033[0m");
|
|
|
|
printf("%c", (F_flag) ? suf : 0);
|
|
return ret;
|
|
}
|
|
|
|
void col_print(struct d_node **node, size_t files, struct winsize w) {
|
|
/* Get max len */
|
|
size_t maxlen = 0;
|
|
for (size_t i = 0; i < files; i++)
|
|
if (strlen(node[i]->name) > maxlen)
|
|
maxlen = strlen(node[i]->name);
|
|
|
|
/* Calc */
|
|
maxlen += 3;
|
|
if (i_flag)
|
|
maxlen += 10;
|
|
|
|
if (s_flag)
|
|
maxlen += 10;
|
|
|
|
size_t ncols = w.ws_col / maxlen;
|
|
size_t nrows = files;
|
|
if (ncols > 1) {
|
|
nrows = files / ncols;
|
|
if (nrows * ncols < files)
|
|
nrows++;
|
|
}
|
|
|
|
else
|
|
ncols = 1;
|
|
|
|
int col = 0;
|
|
int nexttab = 0;
|
|
|
|
/* Mc print */
|
|
for (size_t i = 0; i < nrows; i++) {
|
|
for (size_t j = 0; j < ncols; j++) {
|
|
size_t index = j * nrows + i;
|
|
if (index < files) {
|
|
if (col > 0) {
|
|
nexttab -= col;
|
|
col += nexttab;
|
|
for (int k = 0; k < nexttab; k++)
|
|
putchar(' ');
|
|
}
|
|
|
|
nexttab = col + (int)maxlen;
|
|
col += print(node[index]);
|
|
}
|
|
}
|
|
|
|
putchar('\n');
|
|
col = 0;
|
|
}
|
|
}
|
|
|
|
/* Sort */
|
|
int sortt(const void *p1, const void *p2) {
|
|
return (*(struct d_node **)p2)->stats.st_mtime - (*(struct d_node **)p1)->stats.st_mtime;
|
|
}
|
|
|
|
int sorts(const void *p1, const void *p2) {
|
|
return (*(struct d_node **)p2)->stats.st_size - (*(struct d_node **)p1)->stats.st_size <= 10;
|
|
}
|
|
|
|
int sortd(const void *p1, const void *p2) {
|
|
return strcmp((*(struct d_node **)p1)->full_name, (*(struct d_node **)p2)->full_name);
|
|
}
|
|
|
|
int ls(const char *dir_name, int label, struct winsize w) {
|
|
size_t files = 0;
|
|
int ret = 0;
|
|
struct stat sb;
|
|
if (mu_get_stat("ls", dir_name, &sb))
|
|
return 1;
|
|
|
|
int its_file = 0;
|
|
struct d_node **dir = NULL;
|
|
if (S_ISDIR(sb.st_mode) && !d_flag)
|
|
dir = list(dir_name, &files, &ret);
|
|
|
|
else {
|
|
dir = list_one(dir_name, &ret);
|
|
its_file = 1;
|
|
files = 1;
|
|
}
|
|
|
|
if (dir == NULL)
|
|
return 1;
|
|
|
|
qsort(dir, files, sizeof(struct d_node *), sorter);
|
|
|
|
if ((label || R_flag) && !d_flag && !its_file)
|
|
printf("%s:\n", dir_name);
|
|
|
|
/* pipe print */
|
|
if (!p_flag || l_flag || O_flag) {
|
|
for (size_t i = 0; i < files; i++) {
|
|
print(dir[i]);
|
|
putchar('\n');
|
|
}
|
|
}
|
|
|
|
/* mc print */
|
|
else
|
|
col_print(dir, files, w);
|
|
|
|
if (R_flag)
|
|
for (size_t i = 0; i < files; i++)
|
|
if (S_ISDIR(dir[i]->stats.st_mode) && strcmp(dir[i]->name, "..") && strcmp(dir[i]->name, "."))
|
|
ls(dir[i]->full_name, 1, w);
|
|
|
|
dfree(dir, files);
|
|
return ret;
|
|
}
|
|
|
|
int main(int argc, char **argv) {
|
|
int opt;
|
|
while ((opt = getopt(argc, argv, "1alFcRdLhistS")) != -1) {
|
|
switch (opt) {
|
|
case '1':
|
|
O_flag = 1;
|
|
break;
|
|
|
|
case 'a':
|
|
a_flag = 1;
|
|
break;
|
|
|
|
case 'l':
|
|
l_flag = 1;
|
|
break;
|
|
|
|
case 'F':
|
|
F_flag = 1;
|
|
break;
|
|
|
|
case 'c':
|
|
c_flag = 1;
|
|
break;
|
|
|
|
case 'R':
|
|
d_flag = 0;
|
|
R_flag = 1;
|
|
break;
|
|
|
|
case 'd':
|
|
R_flag = 0;
|
|
d_flag = 1;
|
|
break;
|
|
|
|
case 'L':
|
|
L_flag = 1;
|
|
break;
|
|
|
|
case 'h':
|
|
h_flag = 1;
|
|
break;
|
|
|
|
case 'i':
|
|
i_flag = 1;
|
|
break;
|
|
|
|
case 's':
|
|
s_flag = 1;
|
|
break;
|
|
|
|
case 't':
|
|
sorter = sortt;
|
|
break;
|
|
|
|
case 'S':
|
|
sorter = sorts;
|
|
break;
|
|
|
|
default:
|
|
printf("ls [1alFcRdLhistS] [dir1 file2...]\n\t-a Show hidden files\n\t-l Use a long listing format\n\t-F Append indicator to names\n\t-c Color mode\n\t-R Recursive\n\t-1 One column\n\t-d Print only dir names\n\t-L Follow symlinks\n\t-h Sizes in human readable format\n\t-i Listen inodes\n\t-t Sort by mtime\n\t-S Sort by size\n\t-s Print file size\n");
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
argv += optind;
|
|
argc -= optind;
|
|
|
|
struct winsize w;
|
|
ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
|
|
|
|
/* Check if programm piped, 1 - false, 0 - true */
|
|
p_flag = isatty(STDOUT_FILENO);
|
|
|
|
if (argc < 1)
|
|
return ls(".", 0, w);
|
|
|
|
else if (argc == 1)
|
|
return ls(argv[0], 0, w);
|
|
|
|
else {
|
|
int ret = 0;
|
|
for (int i = 0; i < argc; i++)
|
|
if (ls(argv[i], 1, w))
|
|
ret = 1;
|
|
|
|
return ret;
|
|
}
|
|
|
|
return 0;
|
|
}
|