exec.c

Go to the documentation of this file.

/** @file exec.c
    @brief Functions to execute external commands
    @author Bill Waller
    Copyright (c) 2025
    MIT License
    billxwaller@gmail.com
    @date 2026-02-09
 */
 
/** @defgroup exec External Commands
    @brief This module provides functions to execute external commands
    @details Handles terminal settings, signal handling, and error reporting to
   ensure a smooth user experience when executing commands from within the
   application. The main functions include full_screen_fork_exec,
   full_screen_shell, and fork_exec, which manage the execution of commands
   while maintaining the integrity of the application's user interface.
 */
 
#include <cm.h>
#include <errno.h>
#include <fcntl.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <termios.h>
#include <unistd.h>
 
int full_screen_fork_exec(char **);
int full_screen_shell(char *);
int shell(char *);
int fork_exec(char **);
int nf_error(int ec, char *s);
int dmon(char **);
/** @brief Execute a command in full screen mode
    @ingroup exec
    @param argv - array of arguments for the command to execute
    @return the return code from the executed command
    @details Clear the screen,
    move the cursor to the bottom, and refresh the screen before executing
   the command.
    After the command completes, clear the screen, move the cursor to the
   top, refresh the screen, and restore the windows. */
int full_screen_fork_exec(char **argv) {
    int rc;
 
    fflush(stderr);
    wmove(stdscr, LINES - 1, 0);
    rc = fork_exec(argv);
    return (rc);
}
/** @brief Execute a shell command in full screen mode
    @ingroup exec
    @param shellCmdPtr - pointer to the shell command string
    @return the return code from the executed shell command
    @details Clear the screen, move the cursor to the top, and refresh the
   screen before executing the shell command. After the command completes,
   restore the windows.
 */
int full_screen_shell(char *shellCmdPtr) {
    int rc;
 
    fflush(stderr);
    werase(stdscr);
    wmove(stdscr, 0, 0);
    wrefresh(stdscr);
    rc = shell(shellCmdPtr);
    touchwin(stdscr);
    wnoutrefresh(stdscr);
    restore_wins();
    wrefresh(stdscr);
    return (rc);
}
/** @brief Execute a shell command
    @ingroup exec
    @param shellCmdPtr - pointer to the shell command string
    @return the return code from the executed shell command
    @details Executes the command string using the user's shell.
    If the SHELL environment variable is not set, use /bin/sh. */
int shell(char *shellCmdPtr) {
    int Eargc;
    char *Eargv[MAXARGS];
    char *shellPtr;
    int rc;
 
    Eargc = 0;
    shellPtr = getenv("SHELL");
    if (shellPtr == nullptr || *shellPtr == '\0')
        shellPtr = DEFAULTSHELL;
    Eargv[Eargc++] = strdup(shellPtr);
    Eargv[Eargc++] = "-c";
    Eargv[Eargc++] = shellCmdPtr;
    Eargv[Eargc++] = nullptr;
    rc = fork_exec(Eargv);
    free(Eargv[0]);
    return (rc);
}
/** @brief Fork and exec a command
    @ingroup exec
    @param argv - array of arguments for the command to execute
    @return the return code from the executed command, or -1 on error
    @details Captures and restores terminal settings around the fork and exec.
    Sets signal handlers to default in the child process.
    Waits for the child process to complete in the parent process.
    Handles errors from fork and execvp, and reports child exit status.
    Restores curses mode and keypad settings after execution.
    Restores window states after execution.
    Uses a temporary string buffer tmp_str for error messages.
    Uses Perror for error reporting.
    Uses sig_dfl_mode and sig_prog_mode for signal handling.
    Uses capture_curses_tioctl and restore_curses_tioctl for terminal
   settings.
    Uses restore_shell_tioctl for shell terminal settings.
    Uses waitpid to wait for the child process.
    Uses WIFEXITED, WEXITSTATUS, WIFSIGNALED, and WTERMSIG to interpret
   child status.
    Uses keypad to manage keypad mode in curses.
    Uses restore_wins to restore window states.
    Uses errno for error codes.
    Uses pid_t for process IDs.
    Uses standard file descriptors STDIN_FILENO, STDOUT_FILENO,
   STDERR_FILENO.
    Uses execvp for executing the command.
    Uses fork for creating a new process.
    Uses ssnprintf for formatting error messages.
    Uses switch-case for handling fork results.
    Uses default shell if SHELL environment variable is not set. */
int fork_exec(char **argv) {
    char tmp_str[MAXLEN];
    pid_t pid;
    int status;
    int rc;
 
    if (argv[0] == 0) {
        Perror("fork_exec: missing argument for execvp");
        return (-1);
    }
    capture_curses_tioctl();
    curs_set(1);
    sig_dfl_mode();
 
    tmp_str[0] = '\0';
    pid = fork();
    switch (pid) {
    case -1: // parent fork failed
        sig_prog_mode();
        keypad(stdscr, true);
        ssnprintf(tmp_str, sizeof(tmp_str), "fork failed: %s, errno: %d",
                  argv[0], errno);
        Perror(tmp_str);
        return (-1);
    case 0: // child
        /** Prevent child process from writing to terminal */
        // if (flags & F_NO_STDERR) {
        //     int dev_null = open("/dev/null", O_WRONLY);
        //     if (dev_null == -1) {
        //         Perror("open(/dev/null) failed in init_pick child process");
        //         exit(EXIT_FAILURE);
        //     }
        //     dup2(dev_null, STDOUT_FILENO);
        //     dup2(dev_null, STDERR_FILENO);
        //     close(dev_null);
        // }
        restore_shell_tioctl();
        werase(stdscr);
        wrefresh(stdscr);
        execvp(argv[0], argv);
        restore_curses_tioctl();
        sig_prog_mode();
        keypad(stdscr, true);
        ssnprintf(tmp_str, sizeof(tmp_str), "execvp failed: %s, errno: %d",
                  argv[0], errno);
        Perror(tmp_str);
        exit(-1);
    default: // parent
        rc = 0;
        restore_curses_tioctl();
        sig_prog_mode();
        waitpid(pid, &status, 0);
        if (WIFEXITED(status)) {
            rc = WEXITSTATUS(status);
            if (rc != 0) {
                keypad(stdscr, true);
                ssnprintf(tmp_str, sizeof(tmp_str),
                          "Child %s exited  with status %d", argv[0], rc);
            }
        } else {
            if (WIFSIGNALED(status)) {
                rc = WTERMSIG(status);
                keypad(stdscr, true);
                ssnprintf(tmp_str, sizeof(tmp_str),
                          "Child %s terminated by signal %d", argv[0], rc);
            } else {
                keypad(stdscr, true);
                ssnprintf(tmp_str, sizeof(tmp_str),
                          "Child %s terminated abnormally", argv[0]);
            }
        }
        break;
    }
    restore_curses_tioctl();
    sig_prog_mode();
    touchwin(stdscr);
    wnoutrefresh(stdscr);
    wrefresh(stdscr);
    restore_wins();
    tmp_str[0] = '\0';
    if (tmp_str[0] != '\0') {
        Perror(tmp_str);
    }
    return (rc);
}
/** @brief Fork and execute a command as a daemon
    @ingroup exec
    @param eargv - array of arguments for the command to execute
    @return EXIT_SUCCESS on success, EXIT_FAILURE on failure
    @details Forks the process twice to create a daemon.
    Sets the session ID and working directory.
    Redirects standard file descriptors to /dev/null.
    Closes all open file descriptors.
    Executes the command using execvp.
    Exits with failure if any step fails.
    @note Don't use this code. It is not finished. */
int dmon(char **eargv) {
 
    pid_t pid = fork();
    capture_curses_tioctl();
    curs_set(1);
    sig_dfl_mode();
 
    if (pid < 0) {
        fprintf(stderr, "Failed to fork: %s\n", strerror(errno));
        return EXIT_FAILURE;
    }
    if (pid > 0) {
        restore_curses_tioctl();
        sig_prog_mode();
        touchwin(stdscr);
        wnoutrefresh(stdscr);
        wrefresh(stdscr);
        restore_wins();
        return 0;
    }
    if (setsid() < 0) {
        fprintf(stderr, "Failed to set session ID: %s\n", strerror(errno));
        exit(EXIT_FAILURE);
    }
    pid = fork();
    if (pid < 0) {
        fprintf(stderr, "Second fork failed: %s\n", strerror(errno));
        exit(EXIT_FAILURE);
    }
    if (pid > 0) {
        exit(EXIT_SUCCESS);
    }
    char *e = getenv("HOME");
    if (e != NULL) {
        if (chdir(e) < 0)
            exit(EXIT_FAILURE);
    }
    umask(0);
    close(STDIN_FILENO);
    close(STDOUT_FILENO);
    close(STDERR_FILENO);
    int dev_null = open("/dev/null", O_RDWR);
    if (dev_null != -1) {
        dup2(dev_null, STDIN_FILENO);
        dup2(dev_null, STDOUT_FILENO);
        dup2(dev_null, STDERR_FILENO);
        if (dev_null > 2) {
            close(dev_null);
        }
    }
    long max_fd = sysconf(_SC_OPEN_MAX);
    for (long fd = 3; fd < max_fd; fd++) {
        close(fd);
    }
    execvp(eargv[0], eargv);
    exit(EXIT_FAILURE);
}