whence.c

Go to the documentation of this file.

/** @file whence.c
    @brief Find the full path of a file in the directories specified by the
    @author Bill Waller
    Copyright (c) 2025
    MIT License
    billxwaller@gmail.com
    @date 2026-02-09
 */
 
#include <argp.h>
#include <cm.h>
#include <fcntl.h>
#include <limits.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
 
char *path_p;
char path_s[MAXLEN];
char *file_name[MAXLEN + 1];
 
void whence(char *, int);
int next_path(char *, char **);
int file_spec_parts(char *, char *, char *);
void ABEND(char *, int, char *);
void normalend();
typedef enum { WH_ALL = 1, WH_VERBOSE = 2 } WhenceFlags;
int wh_flags = 0;
const char *argp_program_version = CM_VERSION;
const char *argp_program_bug_address = "billxwaller@gmail.com";
static char doc[] = "whence locate files in path";
static char args_doc[] = "";
 
static struct argp_option options[] = {
    {"all", 'a', 0, 0, "list all matches", 0},
    {"verbose", 'v', 0, 0, "verbose messages", 0},
    {0}};
 
struct wh_opts {
    int flags;
    char *argv[MAXARGS];
};
 
static error_t parse_opt(int key, char *arg, struct argp_state *state) {
    struct wh_opts *wh_opts = state->input;
    int i = 0;
    switch (key) {
    case 'a':
        wh_opts->flags |= WH_ALL;
        break;
    case 'v':
        wh_opts->flags |= WH_VERBOSE;
        break;
    case ARGP_KEY_ARG:
        if (i >= 1) {
            argp_usage(state);
        }
        wh_opts->argv[i] = arg;
        optind = i;
        i++;
        break;
    case ARGP_KEY_END:
        break;
    default:
        return ARGP_ERR_UNKNOWN;
    }
    return 0;
}
static struct argp argp = {options, parse_opt, args_doc, doc,
                           nullptr, nullptr,   nullptr};
 
int main(int argc, char **argv) {
    struct wh_opts wh_opts = {0};
    wh_opts.flags = 0;
    wh_opts.argv[0] = nullptr;
 
    argp_parse(&argp, argc, argv, 0, 0, &wh_opts);
    path_p = getenv("PATH");
    if (path_p == nullptr)
        ABEND(argv[0], 0, "PATH environment variable not set");
    if (wh_opts.flags & WH_VERBOSE)
        printf("%s\n", path_p);
    while (optind < argc) {
        whence(wh_opts.argv[optind++], wh_opts.flags);
    }
    normalend();
}
/** @brief Find the full path of a file in the directories specified by the PATH
   environment variable
    @param file_spec_p The file specification to search for
    @param flags Flags to control the behavior of the search (e.g., verbose
   mode, list all matches)
    @details This function takes a file specification, extracts the directory
   and file name components, and searches through the directories specified in
   the PATH environment variable to find matches. It prints the full path of
   each match found, and if verbose mode is enabled, it also indicates whether
   each attempted path was found or not. */
void whence(char *file_spec_p, int flags) {
    char file_spec[PATH_MAX];
    char file_dir[PATH_MAX];
    char file_name[PATH_MAX];
    char try_spec[PATH_MAX];
    char try_dir[PATH_MAX];
    int path_l;
    struct stat stat_struct;
 
    strnz__cpy(file_spec, file_spec_p, MAXLEN - 1);
    strnz__cpy(path_s, path_p, MAXLEN - 1);
    file_spec_parts(file_spec, file_dir, file_name);
    path_p = path_s;
    path_l = next_path(try_dir, &path_p);
    while (path_l != 0) {
        strnz__cpy(try_spec, try_dir, MAXLEN - 1);
        if (try_spec[path_l] != '/')
            strnz__cat(try_spec, "/", MAXLEN - 1);
        strnz__cat(try_spec, file_name, MAXLEN - 1);
        if (flags & WH_VERBOSE) {
            if (stat(try_spec, &stat_struct) == -1)
                printf("-      %s\n", try_spec);
            else
                printf("found  %s\n", try_spec);
        } else if (stat(try_spec, &stat_struct) == 0) {
            printf("%s\n", try_spec);
            if (!(flags & WH_ALL))
                return;
        }
        path_l = next_path(try_dir, &path_p);
    }
}
/** @brief Extract the next directory path from the PATH string
    @param dp A buffer to store the extracted directory path
    @param sp A pointer to the current position in the PATH string
    @return The length of the extracted directory path
    @details This function takes a buffer and a pointer to the current position
   in the PATH string, and extracts the next directory path. If the next
   character in the PATH string is a colon, it treats it as an empty path and
   uses the current working directory. Otherwise, it copies characters until it
   reaches a colon or the end of the string, and returns the length of the
   extracted path.
 */
int next_path(char *dp, char **sp) {
    int dl;
 
    if (**sp == ':') {
        (*sp)++;
        getcwd(dp, PATH_MAX);
        return (strlen(dp));
    } else {
        dl = 0;
        while (**sp != '\0' && **sp != '\n' && **sp != '\r' && **sp != ':') {
            *dp++ = *(*sp)++;
            dl++;
        }
        *dp = '\0';
        if (**sp == ':' && *++(*sp) == '\0')
            (*sp)--;
        return (dl);
    }
}
/** @brief Split a file specification into directory and file name components
    @param file_spec The full file specification to split
    @param file_path A buffer to store the extracted directory path
    @param file_name A buffer to store the extracted file name
    @return 0 on success
    @details This function takes a file specification, checks if it is a
   directory, and if so, it sets the file path accordingly. If the file
   specification is empty, it defaults to the current directory. Otherwise, it
   splits the file specification into the directory and file name components
   based on the last occurrence of a slash ('/'). */
int file_spec_parts(char *file_spec, char *file_path, char *file_name) {
    int i, last_slash;
    char tmp_file_spec[PATH_MAX];
    int file_spec_l;
    struct stat stat_struct;
 
    if (stat(file_spec, &stat_struct) != -1)
        if ((stat_struct.st_mode & S_IFMT) == S_IFDIR) {
            if (file_spec[strlen(file_path)] != '/')
                strnz__cat(file_spec, "/", MAXLEN - 1);
            strnz__cpy(file_path, file_spec, MAXLEN - 1);
            file_name[0] = '\0';
            return (0);
        }
    if (strlen(file_spec) == 0) {
        strnz__cpy(file_spec, "./", MAXLEN - 1);
        file_name[0] = '\0';
        return (0);
    }
    strnz__cpy(tmp_file_spec, file_spec, MAXLEN - 1);
    last_slash = -1;
    file_spec_l = strlen(tmp_file_spec);
    if (file_spec_l > 0) {
        i = 0;
        while (i < file_spec_l && tmp_file_spec[i] != '\0') {
            if (tmp_file_spec[i] == '/') {
                last_slash = i;
                break;
            }
            i++;
        }
    }
    if (last_slash < 0) {
        strnz__cpy(file_path, "./", MAXLEN - 1);
        if (strcmp(file_spec, ".") == 0)
            file_name[0] = '\0';
        else
            strnz__cpy(file_name, tmp_file_spec, MAXLEN - 1);
        strnz__cpy(file_spec, file_path, MAXLEN - 1);
        strnz__cat(file_spec, file_name, MAXLEN - 1);
    } else {
        tmp_file_spec[last_slash] = '\0';
        strnz__cpy(file_path, tmp_file_spec, MAXLEN - 1);
        strnz__cat(file_path, "/", MAXLEN - 1);
        if (last_slash < file_spec_l)
            last_slash++;
        strnz__cpy(file_name, tmp_file_spec + last_slash, MAXLEN - 1);
    }
    return (0);
}
/** @brief Exit the program successfully
    @details This function is called to exit the program with a success status.
   It simply calls the exit function with EXIT_SUCCESS. */
void normalend() { exit(EXIT_SUCCESS); }
/** @brief Exit the program with an error message
    @param pgmid The name of the program
    @param rc The return code to exit with
    @param err_msg The error message to display
    @details This function is called to exit the program with an error status.
   It prints the program name, return code, and error message to the standard
   error stream, and then exits with the specified return code. */
void ABEND(char *pgmid, int rc, char *err_msg) {
    fprintf(stderr, "%s; error %d; %s\n", pgmid, rc, err_msg);
    exit(EXIT_FAILURE);
}