whence.c File Reference

Find the full path of a file in the directories specified by the. More...

#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>

Include dependency graph for whence.c:

Go to the source code of this file.

Macros
#define	_GNU_SOURCE

Enumerations
enum	WhenceFlags { WH_ALL = 1 , WH_VERBOSE = 2 , WH_EXECUTABLE = 4 , WH_SETUID = 8 }

Functions
void	ABEND (char *pgmid, int rc, char *err_msg)
	Exit the program with an error message.
int	file_spec_parts (char *file_spec, char *file_path, char *file_name)
	Split a file specification into directory and file name components.
int	main (int argc, char **argv)
int	next_path (char *dp, char **pp)
	Get the next directory path from a colon-separated list of paths.
size_t	strnz__cat (char *, const char *, size_t)
	safer alternative to strncat
size_t	strnz__cat (char *d, const char *s, size_t max_len)
	safer alternative to strncat
size_t	strnz__cpy (char *, const char *, size_t)
	safer alternative to strncpy
size_t	strnz__cpy (char *d, const char *s, size_t max_len)
	safer alternative to strncpy
int	whence (char *file_spec_p, int flags)
	Find the full path of a file in the directories specified by the PATH environment variable.

Variables
const char *	argp_program_bug_address = "billxwaller@gmail.com"
const char *	argp_program_version = CM_VERSION
char *	path_p
char	path_s [MAXLEN]
int	wh_flags = 0

Detailed Description

Find the full path of a file in the directories specified by the.

Author

Bill Waller Copyright (c) 2025 MIT License billx.nosp@m.wall.nosp@m.er@gm.nosp@m.ail..nosp@m.com

Date

2026-02-09

Definition in file whence.c.

Macro Definition Documentation

_GNU_SOURCE

#define _GNU_SOURCE

Definition at line 10 of file whence.c.

Enumeration Type Documentation

WhenceFlags

enum WhenceFlags

Enumerator
WH_ALL
WH_VERBOSE
WH_EXECUTABLE
WH_SETUID

Definition at line 34 of file whence.c.

             { WH_ALL = 1,
               WH_VERBOSE = 2,
               WH_EXECUTABLE = 4,
               WH_SETUID = 8 } WhenceFlags;

Function Documentation

ABEND()

void ABEND	(	char *	pgmid,
		int	rc,
		char *	err_msg )

Exit the program with an error message.

Parameters

pgmid	The name of the program
rc	The return code to exit with
err_msg	The error message to display

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.

Definition at line 266 of file whence.c.

                                               {
    fprintf(stderr, "%s; error %d; %s\n", pgmid, rc, err_msg);
    exit(EXIT_FAILURE);
}

file_spec_parts()

int file_spec_parts	(	char *	file_spec,
		char *	file_path,
		char *	file_name )

Split a file specification into directory and file name components.

Parameters

file_spec	The full file specification to split
file_path	A buffer to store the extracted directory path
file_name	A buffer to store the extracted file name

Returns

0 on success

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 ('/').

Definition at line 209 of file whence.c.

                                                                       {
    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);
}

References strnz__cat(), and strnz__cpy().

Referenced by whence().

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char **	argv )

Definition at line 90 of file whence.c.

                                {
    struct wh_opts wh_opts = {0};
    wh_opts.flags = 0;
    wh_opts.argv[0] = nullptr;
    int i = 0;
    int found = 0;
    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 (i < wh_opts.argc) {
        found = whence(wh_opts.argv[i++], wh_opts.flags);
    }
    if (found == 0)
        exit(1);
    exit(0);
}

References ABEND(), path_p, WH_VERBOSE, and whence().

Here is the call graph for this function:

next_path()

int next_path	(	char *	dp,
		char **	pp )

Get the next directory path from a colon-separated list of paths.

Parameters

dp	A buffer to store the extracted directory path
pp	A pointer to the current position in the path string

Returns

The length of the extracted directory path

This function takes a pointer to a colon-separated list of paths and extracts the next directory path from it. If the current character is a colon, it retrieves the current working directory instead. The extracted directory path is stored in the provided buffer, and the function returns the length of the extracted path.

Definition at line 180 of file whence.c.

                                   {
    int dl;
 
    if (**pp == ':') {
        (*pp)++;
        getcwd(dp, PATH_MAX);
        return (strlen(dp));
    } else {
        dl = 0;
        while (**pp != '\0' && **pp != '\n' && **pp != '\r' && **pp != ':') {
            *dp++ = *(*pp)++;
            dl++;
        }
        *dp = '\0';
        if (**pp == ':' && *++(*pp) == '\0')
            (*pp)--;
        return (dl);
    }
}

Referenced by whence().

Here is the caller graph for this function:

whence()

int whence	(	char *	file_spec_p,
		int	flags )

Find the full path of a file in the directories specified by the PATH environment variable.

Parameters

file_spec_p	The file specification to search for
flags	Flags to control the behavior of the search (e.g., verbose mode, list all matches)

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.

Definition at line 119 of file whence.c.

                                         {
    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;
    int found = 0;
    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 (stat(try_spec, &stat_struct) != 0) {
            if (flags & WH_VERBOSE)
                printf("-      %s\n", try_spec);
            path_l = next_path(try_dir, &path_p);
            continue;
        }
        if (flags & WH_SETUID)
            if (!(stat_struct.st_mode & S_ISUID)) {
                path_l = next_path(try_dir, &path_p);
                continue;
            }
        if (flags & WH_EXECUTABLE)
            if (!(stat_struct.st_mode & S_ISUID)) {
                path_l = next_path(try_dir, &path_p);
                continue;
            }
        if (!(stat_struct.st_mode & S_IXUSR)) {
            path_l = next_path(try_dir, &path_p);
            continue;
        }
        found++;
        if (flags & WH_VERBOSE)
            printf("found  %s\n", try_spec);
        else {
            printf("%s\n", try_spec);
            if (!(flags & WH_ALL))
                return found;
        }
        path_l = next_path(try_dir, &path_p);
    }
    return found;
}

References file_spec_parts(), next_path(), path_p, path_s, strnz__cat(), strnz__cpy(), WH_ALL, WH_EXECUTABLE, WH_SETUID, and WH_VERBOSE.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

argp_program_bug_address

const char* argp_program_bug_address = "billxwaller@gmail.com"

Definition at line 40 of file whence.c.

argp_program_version

const char* argp_program_version = CM_VERSION

Definition at line 39 of file whence.c.

path_p

char* path_p

Definition at line 24 of file whence.c.

Referenced by main(), and whence().

path_s

char path_s[MAXLEN]

Definition at line 25 of file whence.c.

Referenced by whence().

wh_flags

int wh_flags = 0

Definition at line 38 of file whence.c.