path: root/src/output.c

/* SPDX-License-Identifier: Apache-2.0 */

/* Copyright 2025 Thorsten Töpper
 *
 * vim:ts=4:sw=4:expandtab
 */

#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <ctype.h>
#include <time.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <pwd.h>
#include <grp.h>
#include <stdint.h>
#include <errno.h>

#include "output.h"
#include "data_management.h"
#include "options.h"



/* === DEFINITIONS === */

#define DM_OUT_FORMAT_MAX_LEN 80

#define box_cross '+'
#define box_hsep  '-'
#define box_vsep  '|'

#define out_cross() fputc(box_cross, stdout)
#define out_hsep() fputc(box_hsep, stdout)
#define out_vsep() fputc(box_vsep, stdout)

#define out_print_newline()  fputc('\n', stdout)
#define out_print_fname(x)   printf(" %s ", x->fname)
#define out_print_uid(x)     printf(" %4u ", x->ln_stat.st_gid)
#define out_print_gid(x)     printf(" %4u ", x->ln_stat.st_uid)

void out_print_group_name(struct list_node *ptr);
void out_print_permissions(struct list_node *ptr);
void out_print_size(struct list_node *ptr);
void out_print_time(time_t tv);
void out_print_time_by_option(struct list_node *ptr);
void out_print_type(struct list_node *ptr);
void out_print_user_name(struct list_node *ptr);

void out_print_format_string_header(const char *format, size_t longest_fname);

size_t estimate_formatted_line_length(const char *format, size_t longest_fname);
size_t get_longest_filename(struct list_head *list);


char *global_sep_line = NULL;

/* === IMPLEMENTATION === */

inline int fputc_all_cols(char c, FILE *fdout) {
    struct winsize terminal;
    if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &terminal) == -1) {
        if (errno != 25) {
            LOGERR("ERROR: ioctl(STDOUT_FILENO, TIOCGWINSZ,...) failed: %s (errno %d)\n",
                    strerror(errno), errno);
        }
        terminal.ws_col = 72;
    }
    DBGTRC("DEBUG: terminal.ws_col = %d / terminal.ws_row = %d\n", terminal.ws_col, terminal.ws_row);
    /* Somehow not always ws_col == 0, with optimization compiler flags and executed by watch. */
    if (terminal.ws_col == 0) {
        terminal.ws_col = 72;
    }
    return fputc_width_x(c, terminal.ws_col, fdout);
}


/* Not the most performant way, but during output the time critical tasks are already done. */
inline int fputc_width_x(char c, size_t x, FILE *fdout) {
    size_t i=0;

    if (fdout == NULL) {
        LOGERR("ERROR: No output stream given.\n");
        return EOF;
    }

    if ( ! isprint(c) ) { c = '?'; }

    for (i=0; i<x; i++) {
        if (fputc(c, fdout) == EOF) {
            LOGERR("ERROR: Failed to write char 0x%02X to stream %d\n", c, fdout->_fileno);
            return EOF;
        }
    }

    return 1;
}

/* basic 4 due to formatted output */
inline size_t get_longest_filename(struct list_head *list) {
    size_t rc = 4, tmp = 0;
    struct list_node *ptr = NULL;
    if (list == NULL) { return 0; }
    ptr = list->first;
    while (ptr != NULL) {
        tmp = strlen(ptr->fname);
        if (tmp>rc) { rc = tmp; }
        ptr = ptr->next;
    }
    return rc;
}


/* === FORMATTING RELATED FUNCTIONS === */
/* Be aware: getting the name via uid takes a lot of time depending on the
 * systems setup. local, NIS, LDAP ...
 * Caching happens outside the executable, minimal here for skipping funcion calls. */
inline void out_print_group_name(struct list_node *ptr) {
    struct group *group = NULL;
    static gid_t prev_gid = UINT32_MAX;
    static char prev_group_name[64] = "";
    size_t group_name_length = 0;

    /* For the unlikely case of multi threading this program: lock required here... */
    if (prev_gid == ptr->ln_stat.st_gid) {
        if (prev_group_name[0] == '\0') { /* first call of function and GID UINT32_MAX ? */
            if ((group = getgrgid(prev_gid)) == NULL) {
                LOGERR("ERROR: Failed to resolve information for gid %u: %s (errno %d)\n",
                        prev_gid, strerror(errno), errno);
                return;
            }
            group_name_length = strlen(group->gr_name);
            group_name_length = (group_name_length > 63) ? 63 : group_name_length;
            explicit_bzero(prev_group_name, 64);
            memcpy(prev_group_name, group->gr_name, group_name_length);
        }
        printf(" %-10s ", prev_group_name);
        return;
    }

    prev_gid = ptr->ln_stat.st_gid;
    if ((group = getgrgid(prev_gid)) == NULL) {
        LOGERR("ERROR: Failed to resolve information for gid %u: %s (errno %d)\n",
                prev_gid, strerror(errno), errno);
        return;
    }
    group_name_length = strlen(group->gr_name);
    group_name_length = (group_name_length > 63) ? 63 : group_name_length;
    explicit_bzero(prev_group_name, 64);
    memcpy(prev_group_name, group->gr_name, group_name_length);
    printf(" %-10s ", prev_group_name);
}

/* Reminder: resolving may take some time even with cache in libraries,
 * minimal cache here to prevent function call */
inline void out_print_user_name(struct list_node *ptr) {
    struct passwd *pwd = NULL;
    static uid_t prev_uid = UINT32_MAX;
    static char prev_user_name[64] = "";
    size_t user_name_length = 0;

    /* For the unlikely case of multi threading this program: lock required here... */
    if (prev_uid == ptr->ln_stat.st_uid) {
        if (prev_user_name[0] == '\0') { /* first call of function and UID UINT32_MAX ? */
            if ((pwd = getpwuid(prev_uid)) == NULL) {
                LOGERR("ERROR: Failed to resolve information for uid %u: %s (errno %d)\n",
                        prev_uid, strerror(errno), errno);
                return;
            }
            user_name_length = strlen(pwd->pw_name);
            user_name_length = (user_name_length > 63) ? 63 : user_name_length;
            explicit_bzero(prev_user_name, 64);
            memcpy(prev_user_name, pwd->pw_name, user_name_length);
        }
        printf(" %-10s ", prev_user_name);
        return;
    }

    prev_uid = ptr->ln_stat.st_uid;
    if ((pwd = getpwuid(prev_uid)) == NULL) {
        LOGERR("ERROR: Failed to resolve information for uid %u: %s (errno %d)\n",
                prev_uid, strerror(errno), errno);
        return;
    }
    user_name_length = strlen(pwd->pw_name);
    user_name_length = (user_name_length > 63) ? 63 : user_name_length;
    explicit_bzero(prev_user_name, 64);
    memcpy(prev_user_name, pwd->pw_name, user_name_length);
    printf(" %-10s ", prev_user_name);
}

inline void out_print_size(struct list_node *ptr) {
    printf(" %8ld %2s ", ((ptr->ln_stat.st_size>=1024) ? (ptr->ln_stat.st_size/1024) : ptr->ln_stat.st_size),
            ((ptr->ln_stat.st_size >= 1024) ? "kB" : ""));
}

inline void out_print_time(time_t tv) {
    struct tm *tm = NULL;
    char timestamp[128];

    tm = localtime(&tv);
    if (option_timestamp_long) {
        strftime(timestamp, sizeof(timestamp), "%Y%m%d %H:%M:%S %Z", tm);
        printf(" %-22s ", timestamp);
    } else {
        strftime(timestamp, sizeof(timestamp), "%H:%M:%S", tm);
        printf(" %-8s ", timestamp);
    }
}

inline void out_print_time_by_option(struct list_node *ptr) {
    time_t time_value = 0;

    switch (option_time_field) {
        case 'm':
            time_value = ptr->ln_stat.st_mtim.tv_sec;
            break;
        case 'a':
            time_value = ptr->ln_stat.st_atim.tv_sec;
            break;
        case 'c':
            time_value = ptr->ln_stat.st_ctim.tv_sec;
            break;
        default:
            LOGERR("WARNING: option_time_field has invalid value %c 0x%02X - going by default m\n",
                option_time_field, option_time_field);
            option_time_field = 'm';
            time_value = ptr->ln_stat.st_mtim.tv_sec;
            break;
        };
    out_print_time(time_value);
}

inline void out_print_type(struct list_node *ptr) {
    char entry[16] = "";

    /* regular file, directory and symlinks are most common */
    if (S_ISREG(ptr->ln_stat.st_mode)) {
        sprintf(entry, "regular file");
    } else if (S_ISDIR(ptr->ln_stat.st_mode)) {
        sprintf(entry, "directory");
    } else if (S_ISLNK(ptr->ln_stat.st_mode)) {
        sprintf(entry, "symlink");
    } else if (S_ISBLK(ptr->ln_stat.st_mode)) {
        sprintf(entry, "block");
    } else if (S_ISCHR(ptr->ln_stat.st_mode)) {
        sprintf(entry, "char");
    } else if (S_ISFIFO(ptr->ln_stat.st_mode)) {
        sprintf(entry, "fifo");
    } else if (S_ISSOCK(ptr->ln_stat.st_mode)) {
        sprintf(entry, "socket");
    /* The following macros operate on the complete struct stat */
    } else if (S_TYPEISMQ(&(ptr->ln_stat))) {
        sprintf(entry, "message queue");
    } else if (S_TYPEISSEM(&(ptr->ln_stat))) {
        sprintf(entry, "semaphore");
    } else if (S_TYPEISSHM(&(ptr->ln_stat))) {
        sprintf(entry, "shared memory");
#if 0
    /* Although mentioned in the POSIX man page, not part of glibc */
    } else if (S_TYPEISTMO(&(ptr->ln_stat))) {
        sprintf(entry, "memory object");
#endif
    } else {
        sprintf(entry, "unidentified");
    }
    /* The ones longer than 12 characters are rare. */
    printf(" %-12s ", entry);
}

inline void out_print_permissions(struct list_node *ptr) {
    mode_t mode = 0;
    /* User permissions */
    if (ptr->ln_stat.st_mode & S_IXUSR) {
        mode |= S_IXUSR;
    }
    if (ptr->ln_stat.st_mode & S_IWUSR) {
        mode |= S_IWUSR;
    }
    if (ptr->ln_stat.st_mode & S_IRUSR) {
        mode |= S_IRUSR;
    }
    /* Group permissions */
    if (ptr->ln_stat.st_mode & S_IXGRP) {
        mode |= S_IXGRP;
    }
    if (ptr->ln_stat.st_mode & S_IWGRP) {
        mode |= S_IWGRP;
    }
    if (ptr->ln_stat.st_mode & S_IRGRP) {
        mode |= S_IRGRP;
    }
    /* Other permissions */
    if (ptr->ln_stat.st_mode & S_IXOTH) {
        mode |= S_IXOTH;
    }
    if (ptr->ln_stat.st_mode & S_IWOTH) {
        mode |= S_IWOTH;
    }
    if (ptr->ln_stat.st_mode & S_IROTH) {
        mode |= S_IROTH;
    }
    /* special bits */
    if (ptr->ln_stat.st_mode & S_ISVTX) {
        mode |= S_ISVTX;
    }
    if (ptr->ln_stat.st_mode & S_ISGID) {
        mode |= S_ISGID;
    }
    if (ptr->ln_stat.st_mode & S_ISUID) {
        mode |= S_ISUID;
    }
    printf(" %4o ", mode);
}

/* Interpret the format string and based on it generate a size which will be
 * able to store everything including visual additions. Use strlen later.  */
inline size_t estimate_formatted_line_length(const char *format, size_t longest_fname) {
    size_t rc = 0, i=0, format_len=0;
    static int login_name_max = -1;
    if (login_name_max < 0) {
        /* TODO: Check whether all UNIX likes use this for user and group name*/
        if ((login_name_max=(int)sysconf(_SC_LOGIN_NAME_MAX)) < 0) {
            LOGERR("ERROR: sysconf(_SC_LOGIN_NAME_MAX) failed: %s (errno %d)\n",
                strerror(errno), errno);
            return 0;
        }
        DBGTRC("DEBUG: sysconf(_SC_LOGIN_NAME_MAX) = %d\n", login_name_max);
        login_name_max += 4; /* formatting additions */
    }
    format_len = strnlen(format, DM_OUT_FORMAT_MAX_LEN);
    for (i=0; i<format_len; i++) {
        switch (format[i]) {
            case 'n': rc += longest_fname+4; break;
            case 'G':
            case 'U': rc += ((unsigned int)login_name_max); break;
            case 'g': /* Short ones */
            case 'p':
            case 'u': rc += 8; break;
            case ' ': break;
            default: rc += 28; /* time, and strings >10 in format*/
        };
    }
    DBGTRC("DEBUG: format string '%s' estimated with %lu bytes\n", format, rc);
    return rc;
}

inline void out_print_format_string_header(const char *format, size_t longest_fname) {
    size_t i=0, j=0, k=0, format_len=0, est_length=0, tmp = 0;
    char *header = NULL, *sep_line = NULL;
    char *pos = NULL;

    if (format == NULL || format[0] == '\0' || longest_fname == 0) return;
    DBGTRC("DEBUG: format string: \"%s\"\n", format);

    format_len = strnlen(format, DM_OUT_FORMAT_MAX_LEN);

    est_length = estimate_formatted_line_length(format, longest_fname);
    if ((header=calloc(est_length, sizeof(char))) == NULL) {
        LOGERR("ERROR: Failed to allocate memory for header\n");
        return;
    }

    pos = header;

    if (option_print_boxed_table) {
        if ((sep_line=calloc(est_length, sizeof(char))) == NULL) {
            free(header);
            LOGERR("ERROR: Failed to allocate memory for sep line\n");
            return;
        }
        if (global_sep_line != NULL) { free(global_sep_line); }
        pos[0] = box_vsep;
        pos++;
        sep_line[j++] = box_cross;
    }

#define LOCAL_EXTEND_SEP_LINE() { \
    if (option_print_boxed_table) { \
        tmp = strlen(pos); \
        for (k=0; k<tmp; k++) { sep_line[j++] = box_hsep; } \
        sep_line[j++] = box_cross;   pos[tmp] = box_vsep; } }

    /* Prevent buffer overflow, with the header string 32 byte buffer */
    for (i=0; (i < format_len) && (strlen(header) < 4064); i++) {
        switch (format[i]) {
            case 'n':
                sprintf(pos, " FILE ");
                tmp = strlen(pos);
                for (k=0; k<longest_fname-4; k++) {
                    pos[tmp+k] = ' ';
                }
                LOCAL_EXTEND_SEP_LINE();
                break;
            case 's':
                sprintf(pos, " %11s ", "SIZE   ");
                LOCAL_EXTEND_SEP_LINE();
                break;
            case 't':
                if (option_timestamp_long) {
                    sprintf(pos, " %c%-21s ", toupper(option_time_field), "TIME");
                } else {
                    sprintf(pos, " %c%-7s ", toupper(option_time_field), "TIME");
                }
                LOCAL_EXTEND_SEP_LINE();
                break;
            case 'A':
                if (option_timestamp_long) {
                    sprintf(pos, " %-22s ", "ACCESS TIME");
                } else {
                    sprintf(pos, " %-8s ", "ATIME");
                }
                LOCAL_EXTEND_SEP_LINE();
                break;
            case 'C':
                if (option_timestamp_long) {
                    sprintf(pos, " %-22s ", "CREATION TIME");
                } else {
                    sprintf(pos, " %-8s ", "CTIME");
                }
                LOCAL_EXTEND_SEP_LINE();
                break;
            case 'M':
                if (option_timestamp_long) {
                    sprintf(pos, " %-22s ", "MODIFICATION TIME");
                } else {
                    sprintf(pos, " %-8s ", "MTIME");
                }
                LOCAL_EXTEND_SEP_LINE();
                break;
            case 'T':
                sprintf(pos, " %-12s ", "TYPE");
                LOCAL_EXTEND_SEP_LINE();
                break;
            case 'u':
                sprintf(pos, " %-4s ", "UID");
                LOCAL_EXTEND_SEP_LINE();
                break;
            case 'g':
                sprintf(pos, " %-4s ", "GID");
                LOCAL_EXTEND_SEP_LINE();
                break;
            case 'U':
                sprintf(pos, " %-10s ", "USER");
                LOCAL_EXTEND_SEP_LINE();
                break;
            case 'G':
                sprintf(pos, " %-10s ", "GROUP");
                LOCAL_EXTEND_SEP_LINE();
                break;
            case 'p':
                sprintf(pos, " %-4s ", "PERM");
                LOCAL_EXTEND_SEP_LINE();
                break;
            case ' ':
                break;
            default:
                LOGERR("WARNING: Invalid character 0x%02X ignoring it\n", format[i]);
                break;
        };
        pos = &header[strlen(header)];
    }
    /* Output to stdout */
    if (option_print_boxed_table) {
        fputs(sep_line, stdout);
        out_print_newline();
    }
    fputs(header, stdout);
    out_print_newline();
    if (option_print_boxed_table) {
        tmp = strlen(sep_line);
        fputs(sep_line, stdout);
        if ((global_sep_line = calloc(tmp+1, sizeof(char))) != NULL) {
            memcpy(global_sep_line, sep_line, tmp);
            free(sep_line);
        }
    } else {
        fputc_width_x('-', strlen(header), stdout);
    }
    out_print_newline();
    free(header);
#undef LOCAL_EXTEND_SEP_LINE
}
/* === END OF FORMATTING FUNCTIONS === */



/* The most simple default output, formatted output is planned */
void print_list(struct list_head *list) {
    struct list_head *lh = list;
    struct list_node *ptr;
    size_t total_size = 0;
    size_t longest_fname = 0, i = 0;

    if (list == NULL) return;
    if (option_sort_reverse_order) {
        lh = create_list_sort_reversed(list);
        /* be tolerant */
        if (lh == NULL) {
            lh = list;
        }
    }

    longest_fname = get_longest_filename(list);

    if (option_print_header) {
        out_print_format_string_header("stn", longest_fname);
    }

    ptr = lh->first;
    while (ptr != NULL) {
        if (option_print_boxed_table) out_vsep();
        out_print_size(ptr);
        if (option_print_boxed_table) out_vsep();
        out_print_time_by_option(ptr);
        if (option_print_boxed_table) out_vsep();
        out_print_fname(ptr);
        if (option_print_boxed_table) {
            for (i=0; i<(longest_fname-strlen(ptr->fname)); i++) fputc(' ', stdout);
            out_vsep();
        }
        out_print_newline();

        /* Linux: Neither man stat(2) nor stat(3type) declare why struct stat field st_size
         * would get a negative value assigned. The type off_t masks __off_t or __off64_t
         * which themselves mask bits/types.h __SLONGWORD_TYPE on x86_64 that's long int.
         * Haven't checked libc/kernel code but regardless why, I assume that a negative
         * value would imply a corrupt filesystem.
         */
        total_size += (ptr->ln_stat.st_size>0) ? (unsigned long int)ptr->ln_stat.st_size : 0;
        ptr = ptr->next;
    }
    if (option_print_boxed_table && global_sep_line != NULL) {
        fputs(global_sep_line, stdout);
    } else {
        fputc_all_cols('=', stdout);
    }
    out_print_newline();
    printf("\nTotal size: %lu %s\n", ((total_size>1024) ? total_size/1024 : total_size),
            ((total_size >= 1024) ? "kB" : ""));

    if (lh != list) destroy_list(lh);
}


/* For now with a large walk around common format strings and prevention of attack vectors.
 * n - name
 * s - file size
 * T - type
 * U - user name
 * u - user id
 * G - group name
 * g - group id
 * p - permissions and special bits
 *
 * Time related
 * t - timestamp set by option_time_field
 * A - timestamp from atim.tv_sec
 * C - timestamp from ctim.tv_sec
 * M - timestamp from mtim.tv_sec
 */
void print_list_formatted(const char *format, struct list_head *list) {
    struct list_head *lh = list;
    struct list_node *ptr;
    size_t format_len = 0, i = 0, j = 0;
    size_t longest_fname = 0;
    size_t total_size = 0;

    if (format == NULL || format[0] == '\0') {
        LOGERR("ERROR: No format string given");
        return;
    }

    if (list == NULL || list->first == NULL) {
        LOGERR("ERROR: No data to print.\n");
        return;
    }

    if (option_sort_reverse_order) {
        lh = create_list_sort_reversed(list);
        /* be tolerant */
        if (lh == NULL) {
            lh = list;
        }
    }

    /* Note: the maximum length needs to be adjusted if the strings
     * shall contain more complicated settings */
    format_len = strnlen(format, DM_OUT_FORMAT_MAX_LEN);
    DBGTRC("DEBUG: format_len = %lu\n", format_len);

    longest_fname = get_longest_filename(list);

    if (option_print_header) {
        out_print_format_string_header(format, longest_fname);
    }

    ptr = lh->first;
    while (ptr != NULL) {
        if (option_print_boxed_table) { out_vsep(); }
        for (i=0; i < format_len; i++) {
            switch (format[i]) {
                case 'n':
                    out_print_fname(ptr);
                    for (j=0; j<(longest_fname - strlen(ptr->fname)); j++) {
                        fputc(' ', stdout);
                    }
                    if (option_print_boxed_table) { out_vsep(); }
                    break;
                case 's':
                    out_print_size(ptr);
                    if (option_print_boxed_table) { out_vsep(); }
                    break;
                case 't':
                    out_print_time_by_option(ptr);
                    if (option_print_boxed_table) { out_vsep(); }
                    break;
                case 'A':
                    out_print_time(ptr->ln_stat.st_atim.tv_sec);
                    if (option_print_boxed_table) { out_vsep(); }
                    break;
                case 'C':
                    out_print_time(ptr->ln_stat.st_ctim.tv_sec);
                    if (option_print_boxed_table) { out_vsep(); }
                    break;
                case 'M':
                    out_print_time(ptr->ln_stat.st_mtim.tv_sec);
                    if (option_print_boxed_table) { out_vsep(); }
                    break;
                case 'T':
                    out_print_type(ptr);
                    if (option_print_boxed_table) { out_vsep(); }
                    break;
                case 'u':
                    out_print_uid(ptr);
                    if (option_print_boxed_table) { out_vsep(); }
                    break;
                case 'g':
                    out_print_gid(ptr);
                    if (option_print_boxed_table) { out_vsep(); }
                    break;
                case 'U':
                    out_print_user_name(ptr);
                    if (option_print_boxed_table) { out_vsep(); }
                    break;
                case 'G':
                    out_print_group_name(ptr);
                    if (option_print_boxed_table) { out_vsep(); }
                    break;
                case 'p':
                    out_print_permissions(ptr);
                    if (option_print_boxed_table) { out_vsep(); }
                    break;
                case ' ': /* just ignore this without warning */
                    break;
                default:
                    LOGERR("WARNING: Invalid character 0x%02X ignoring it\n", format[i]);
                    break;
            };
        }
        out_print_newline();
        total_size += (ptr->ln_stat.st_size>0) ? (unsigned long int)ptr->ln_stat.st_size : 0;
        ptr = ptr->next;
    }
    if (option_print_boxed_table && global_sep_line != NULL) {
        fputs(global_sep_line, stdout);
    } else {
        fputc_all_cols('=', stdout);
    }
    out_print_newline();
    printf("\nTotal size: %lu %s\n", ((total_size>1024) ? total_size/1024 : total_size),
            ((total_size >= 1024) ? "kB" : ""));
    if (lh != list) destroy_list(lh);
}