path: root/ls.c

/*
 * UNG's Not GNU
 *
 * Copyright (c) 2011-2022, Jakob Kaivo <jkk@ung.org>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#define _XOPEN_SOURCE 700
#include <errno.h>
#include <limits.h>
#include <locale.h>
#include <stdio.h>
#include <stdint.h>
#include <sys/stat.h>
#include <unistd.h>
#include <dirent.h>
#include <stdlib.h>
#include <string.h>
#include <ftw.h>
#include <time.h>
#include <sys/types.h>
#include <pwd.h>
#include <grp.h>
#include <limits.h>
#include <libgen.h>

#ifndef PATH_MAX
#ifdef _XOPEN_PATH_MAX
#define PATH_MAX _XOPEN_PATH_MAX
#else
#define PATH_MAX _POSIX_PATH_MAX
#endif
#endif

#define NONE 0
#define ALL 1
#define ALMOST 2

static enum {
	ALPHA,
	SIZE,
	DIRECTORY,
	CTIME,
	MTIME,
	ATIME,
} sort = ALPHA;

#define CHARACTER 1 << 0
#define INODES 1 << 1
#define DIRS 1 << 2
#define QUOTE 1 << 3
#define BLOCKS 1 << 4

#define FOLLOW 1
#define LLONG 2

#define DEFAULT_BLOCK_SIZE 512

static int all = NONE;
static int format = NONE;
static int links = NONE;
static int recurse = 0;
static int listdirs = 0;
static int noowner = 0;
static int blocksize = DEFAULT_BLOCK_SIZE;
static int numeric = 0;
static int nogroup = 0;
static int reverse = 0;
//static int totaldirs = 0;
static int columns = 80;

struct file_info {
	char *path;
	struct stat st;
};

static void (*ls_print)(size_t n, struct file_info[static n]);

static char * ls_filename(struct file_info *fi)
{
	static char name[PATH_MAX];
	/* TODO: decorate with /@|* if needed */
	snprintf(name, sizeof(name), "%s", fi->path);
	return name;
}

static int ls_compare_files(const void *op_a, const void *op_b)
{
	const struct file_info *a = op_a;
	const struct file_info *b = op_b;

	int ret = 0;
	switch (sort) {
	case SIZE:
		ret = a->st.st_size - b->st.st_size;
		break;

	case CTIME:
		ret = a->st.st_ctime - b->st.st_ctime;
		break;

	case MTIME:
		ret = a->st.st_mtime - b->st.st_mtime;
		break;

	case ATIME:
		ret = a->st.st_atime - b->st.st_atime;
		break;

	case DIRECTORY:
		ret = 1;
		break;

	case ALPHA:
		/* handled below */
		break;
	}

	if (ret == 0) {
		ret = strcoll(a->path, b->path);
	}

	return (reverse ? -1 : 1) * ret;
}

/*
static int ls_dir(char *dir)
{
	DIR *d = opendir(dir);
	struct dirent *de;
	int blocks = 0;
	char filename[PATH_MAX];

	while ((de = readdir(d)) != NULL) {
		if (de->d_name[0] != '.' || (de->d_name[0] == '.' && all == ALL)
		    || (strcmp(".", de->d_name) && strcmp("..", de->d_name)
			&& all == ALMOST)) {
			strcpy(filename, dir);
			strcat(filename, "/");
			strcat(filename, de->d_name);
			//blocks += ls_add(filename, 1);
		}
	}
	closedir(d);
	return blocks * DEFAULT_BLOCK_SIZE / blocksize;
}
*/

static size_t ls_find_widest(size_t n, struct file_info files[static n])
{
	size_t ret = 0;
	for (size_t i = 0; i < n; i++) {
		size_t len = strlen(ls_filename(files + i));
		if (len > ret) {
			ret = len;
		}
	}
	return ret + 1;
}

static void ls_print_single(size_t n, struct file_info files[static n])
{
	for (size_t i = 0; i < n; i++) {
		printf("%s\n", ls_filename(files + i));
	}
}

static void ls_print_serial(size_t n, struct file_info files[static n])
{
	if (n == 0) {
		return;
	}

	/* TODO: lines */
	for (size_t i = 0; i < n - 1; i++) {
		printf("%s, ", ls_filename(files + i));
	}
	printf("%s\n", ls_filename(files + n - 1));
}

static void ls_print_columns(size_t n, struct file_info files[static n])
{
	/* TODO: partial columns */

	size_t widest = ls_find_widest(n, files);
	size_t ncolumns = columns / widest;
	size_t nrows = n / ncolumns;
	char format[32] = "";
	snprintf(format, sizeof(format), "%%-%zds", widest);
	for (size_t i = 0; i < nrows; i++) {
		for (size_t j = 0; j < ncolumns; j++) {
			printf(format, ls_filename(files + i + (nrows * j)));
		}
		printf("\n");
	}
}

static void ls_print_rows(size_t n, struct file_info files[static n])
{
	size_t widest = ls_find_widest(n, files);
	size_t ncolumns = columns / widest;
	char format[32] = "";
	snprintf(format, sizeof(format), "%%-%zds", widest);
	for (size_t i = 0; i < n; i++) {
		printf(format, ls_filename(files + i));
		if (i % ncolumns == ncolumns - 1) {
			printf("\n");
		}
	}
}

static int ls_compare_operands(const void *op_a, const void *op_b)
{
	const struct file_info *a = op_a;
	const struct file_info *b = op_b;

	if (a->path == NULL && b->path == NULL) {
		return 0;
	}

	if (a->path == NULL) {
		return 1;
	}

	if (b->path == NULL) {
		return -1;
	}

	if (S_ISDIR(a->st.st_mode) && !S_ISDIR(b->st.st_mode)) {
		return 1;
	}

	if (!S_ISDIR(a->st.st_mode) && S_ISDIR(b->st.st_mode)) {
		return -1;
	}

	return strcoll(a->path, b->path);
}

int main(int argc, char *argv[])
{
	setlocale(LC_ALL, "");

	char *cols = getenv("COLUMNS");
	if (cols != NULL) {
		columns = atoi(cols);
	}

	/* TODO: default to ls_print_columns */
	ls_print = isatty(STDOUT_FILENO) ? ls_print_columns : ls_print_single;

	int c;
	while ((c = getopt(argc, argv, ":ACFRSacdgfiklmnoprstux1HL")) != -1) {
		switch (c) {
		case 'A':	/** all but . and .. **/
			all = ALMOST;
			break;

		case 'C':	/** sort in columns **/
			ls_print = ls_print_columns;
			break;

		case 'F':	/** append file type characters **/
			format |= CHARACTER;
			break;

		case 'H':	/** follow symbolic links on command line **/
			links = FOLLOW;
			break;

		case 'L':	/** follow all symbolic links **/
			links = LLONG;
			break;

		case 'R':	/** run recursively **/
			recurse = 1;
			break;

		case 'S':	/** sort by size **/
			sort = SIZE;
			break;

		case 'a':	/** output all files **/
			all = ALL;
			break;

		case 'c':	/** sort by change time **/
			sort = CTIME;
			break;

		case 'd':	/** do not enter directories **/
			listdirs = 1;
			break;

		case 'f':	/** do not sort **/
			sort = DIRECTORY;
			all = ALL;
			//display = ROWS;
			format ^= BLOCKS;
			recurse = 0;
			break;

		case 'g':	/** like -l, but without owner **/
			//display = LONG;
			noowner = 1;
			break;

		case 'i':	/** include file serial numbers **/
			format |= INODES;
			break;

		case 'k':	/** use a blocksize of 1024 **/
			blocksize = 1024;
			break;

		case 'l':	/** output full details **/
			//display = LONG;
			break;

		case 'm':	/** stream output separated by commas **/
			ls_print = ls_print_serial;
			break;

		case 'n':	/** like -l, but with numeric UID and GID **/
			//display = LONG;
			numeric = 1;
			break;

		case 'o':	/** like -l, but without group **/
			//display = LONG;
			nogroup = 1;
			break;

		case 'p':	/** append / after directory names **/
			format |= DIRS;
			break;

		case 'q':	/** replace non-printable characters with ? **/
			format |= QUOTE;	// FIXME
			break;

		case 'r':	/** reverse sort order **/
			reverse = 1;
			break;

		case 's':	/** outpu total number of blocks **/
			format |= BLOCKS;	// FIXME
			break;

		case 't':	/** sort by modified time **/
			sort = MTIME;
			break;

		case 'u':	/** sort by access time **/
			sort = ATIME;
			break;

		case 'x':	/** sort across rows first **/
			ls_print = ls_print_rows;
			break;

		case '1':	/** output one file per line **/
			ls_print = ls_print_single;
			break;

		default:
			return 1;
		}
	}

	/* sort operands */
	/* TODO: deal with -L/-H */
	argv += optind;
	argc -= optind;
	struct file_info operands[argc + 1];
	int ret = 0;
	for (int i = 0; i < argc; i++) {
		operands[i].path = argv[i];
		if (stat(argv[i], &operands[i].st) == -1) {
			operands[i].path = NULL;
			fprintf(stderr, "ls: %s: %s\n", argv[i], strerror(errno));
			ret = 1;
		}
	}
	operands[argc].path = NULL;
	qsort(operands, argc, sizeof(operands[0]), ls_compare_operands);

	/* list files */
	size_t nfiles = 0;
	struct file_info *op = operands;
	while (op->path != NULL && !S_ISDIR(op->st.st_mode)) {
		op++;
		nfiles++;
	}

	qsort(operands, nfiles, sizeof(operands[0]), ls_compare_files);
	ls_print(nfiles, operands);

	/* list directories */

	/* TODO: now always necessary */
	printf("\n");

	while (op->path != NULL) {
		printf("%s: (directory)\n", op->path);
		op++;
	}
	return ret;
}