process.h

Go to the documentation of this file.

 
#ifndef PROCESS_H
#define PROCESS_H
 
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
 
#include "env.h"
 
#include <assert.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
 
#ifdef _WIN32
#include "wintypes.h"
 
#include <io.h>
#include <sys/stat.h>
#include <windows.h>
#else
#include <fcntl.h>
#include <signal.h>
#include <sys/select.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef enum {
    PROCESS_SUCCESS = 0,
    PROCESS_ERROR_INVALID_ARGUMENT = -1,
    PROCESS_ERROR_FORK_FAILED = -2,
    PROCESS_ERROR_EXEC_FAILED = -3,
    PROCESS_ERROR_PIPE_FAILED = -4,
    PROCESS_ERROR_MEMORY = -5,
    PROCESS_ERROR_WAIT_FAILED = -6,
    PROCESS_ERROR_KILL_FAILED = -7,
    PROCESS_ERROR_PERMISSION_DENIED = -8,
    PROCESS_ERROR_IO = -9,
    PROCESS_ERROR_TIMEOUT = -10,      // Operation timed out
    PROCESS_ERROR_WOULD_BLOCK = -11,  // Non-blocking operation would block
    PROCESS_ERROR_PIPE_CLOSED = -12,  // Pipe end was closed
    PROCESS_ERROR_TERMINATE_FAILED = -13,
    PROCESS_ERROR_UNKNOWN = -14
} ProcessError;
 
#ifdef _WIN32
typedef HANDLE PipeFd;  // Pipe handle
#else
typedef int PipeFd;  // Pipe file descriptor.
#endif
 
typedef enum { PROCESS_STREAM_STDIN = 0, PROCESS_STREAM_STDOUT = 1, PROCESS_STREAM_STDERR = 2 } ProcessStream;
 
typedef struct ProcessHandle ProcessHandle;
 
typedef struct PipeHandle PipeHandle;
 
typedef struct FileRedirection FileRedirection;
 
typedef struct {
    const char* working_directory;   // NULL = inherit current
    bool inherit_environment;        // If true, child inherits parent env
    const char* const* environment;  // NULL-terminated array of "KEY=VALUE" strings
    bool detached;                   // Run process in background (no wait by default)
 
    // Stream redirection options
    struct {
        PipeHandle* stdin_pipe;   // NULL = inherit
        PipeHandle* stdout_pipe;  // NULL = inherit
        PipeHandle* stderr_pipe;  // NULL = inherit
        bool merge_stderr;        // Redirect stderr to stdout
    } io;
} ProcessOptions;
 
#ifndef _WIN32
// Extend ProcessIO structure with file redirections
typedef struct {
    PipeHandle* stdin_pipe;   // stdin pipe
    PipeHandle* stdout_pipe;  // stdout pipe
    PipeHandle* stderr_pipe;  // stderr pipe
    bool merge_stderr;        // whether to merge stdout and stderr.
 
    FileRedirection* stdout_file;  // stdout redirections
    FileRedirection* stderr_file;  // stderr redirections
} ExtendedProcessIO;
 
// Extended ProcessOptions to include extended IO
typedef struct {
    const char* working_directory;
    bool inherit_environment;
    char* const* environment;
    bool detached;
    ExtendedProcessIO io;
} ExtProcessOptions;
 
#endif  // Linux only
 
typedef struct {
    int exit_code;
    bool exited_normally;
    int term_signal;  // Only valid if !exited_normally
} ProcessResult;
 
ProcessError process_create(ProcessHandle** handle, const char* command, const char* const argv[],
                            const ProcessOptions* options);
 
ProcessError process_wait(ProcessHandle* handle, ProcessResult* result, int timeout_ms);
 
ProcessError process_terminate(ProcessHandle* handle, bool force);
 
void process_free(ProcessHandle* handle);
 
bool pipe_read_closed(PipeHandle* handle);
 
bool pipe_write_closed(PipeHandle* handle);
 
PipeFd pipe_read_fd(PipeHandle* handle);
 
PipeFd pipe_write_fd(PipeHandle* handle);
 
ProcessError pipe_create(PipeHandle** pipe);
 
ProcessError pipe_set_nonblocking(PipeHandle* pipe, bool nonblocking);
 
ProcessError pipe_read(PipeHandle* pipe, void* buffer, size_t size, size_t* bytes_read, int timeout_ms);
 
ProcessError pipe_write(PipeHandle* pipe, const void* buffer, size_t size, size_t* bytes_written, int timeout_ms);
 
void pipe_close(PipeHandle* pipe);
ProcessError pipe_close_read_end(PipeHandle* pipe);
ProcessError pipe_close_write_end(PipeHandle* pipe);
 
const char* process_error_string(ProcessError error);
 
ProcessError process_run_and_capture(const char* command, const char* const argv[], ProcessOptions* options,
                                     int* exit_code);
 
#ifndef _WIN32
ProcessError process_redirect_to_file(FileRedirection** redirection, const char* filepath, int flags,
                                      unsigned int mode);
 
ProcessError process_redirect_to_fd(FileRedirection** redirection, int fd, bool close_on_exec);
 
void process_close_redirection(FileRedirection* redirection);
 
ProcessError process_run_with_multiwriter(ProcessResult* result, const char* cmd, const char* args[], int output_fds[],
                                          int error_fds[]);
 
ProcessError process_create_with_redirection(ProcessHandle** handle, const char* command, const char* const argv[],
                                             const ExtProcessOptions* options);
 
ProcessError process_run_with_file_redirection(ProcessHandle** handle, const char* command, const char* const argv[],
                                               const char* stdout_file, const char* stderr_file, bool append);
 
#endif  // Linux only
 
#ifdef __cplusplus
}
#endif
 
#endif /* PROCESS_H */