Process.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
 
#include "../Common/CompilerMacrosExport.h"
#ifndef SC_EXPORT_LIBRARY_PROCESS
#define SC_EXPORT_LIBRARY_PROCESS 0
#endif
#define SC_PROCESS_EXPORT SC_COMPILER_LIBRARY_EXPORT(SC_EXPORT_LIBRARY_PROCESS)
 
#include "../Common/AlignedStorage.h"
#include "../Common/Assert.h"
#include "../Common/IGrowableBufferSpan.h"
#include "../Common/IGrowableBufferStringPath.h"
#include "../File/File.h"
 
namespace SC
{
SC_DECLARE_ASSERT_PROVIDER(ProcessAssert, SC_PROCESS_EXPORT);
 
#define SC_PROCESS_ASSERT_RELEASE(e)        SC_ASSERT_PROVIDER_RELEASE(SC::ProcessAssert, e)
#define SC_PROCESS_ASSERT_DEBUG(e)          SC_ASSERT_PROVIDER_DEBUG(SC::ProcessAssert, e)
#define SC_PROCESS_TRUST_RESULT(expression) SC_PROCESS_ASSERT_RELEASE(expression)
 
struct SC_PROCESS_EXPORT ProcessChain;
 
struct SC_PROCESS_EXPORT ProcessDescriptor
{
    using Handle                  = detail::FileDescriptorDefinition::Handle;
    static constexpr auto Invalid = detail::FileDescriptorDefinition::Invalid;
};
 
struct ProcessExitStatus
{
    int32_t status = -1;
};
 
 
 
struct ProcessID
{
    int32_t pid = 0;
};
 
 
struct SC_PROCESS_EXPORT Process
{
    static constexpr size_t InlineCommandStorageCapacity = StringPath::MaxPath + 1024;
 
    struct SC_PROCESS_EXPORT Options
    {
        bool windowsHide; 
        Options();
    };
 
    struct StdStream
    {
        StdStream(IGrowableBuffer& destination)
        {
            growableBuffer = &destination;
            operation      = Operation::GrowableBuffer;
        }
 
        StdStream(GrowableBuffer<FileDescriptor>& file)
        {
            operation = Operation::FileDescriptor;
            (void)file.content.get(fileDescriptor, Result::Error("Invalid redirection file descriptor"));
            file.content.detach();
        }
 
        StdStream(GrowableBuffer<PipeDescriptor>& pipe)
        {
            operation      = Operation::ExternalPipe;
            pipeDescriptor = &pipe.content;
        }
 
        StdStream(const StdStream&)            = delete;
        StdStream(StdStream&&)                 = delete;
        StdStream& operator=(const StdStream&) = delete;
        StdStream& operator=(StdStream&&)      = delete;
 
      protected:
        struct AlreadySetup
        {
        };
        StdStream() = default;
        StdStream(AlreadySetup) { operation = Operation::AlreadySetup; }
        friend struct Process;
        friend struct ProcessChain;
 
        enum class Operation
        {
            AlreadySetup,
            Inherit,
            Ignore,
            ExternalPipe,
            FileDescriptor,
            GrowableBuffer,
            WritableSpan,
            ReadableSpan
        };
        Operation operation = Operation::Inherit;
 
        Span<const char> readableSpan;
        Span<char>*      writableSpan = nullptr;
 
        IGrowableBuffer* growableBuffer = nullptr;
 
        FileDescriptor::Handle fileDescriptor;
 
        PipeDescriptor* pipeDescriptor;
    };
 
    struct StdOut : public StdStream
    {
        // clang-format off
        struct Ignore{};
        struct Inherit{};
        
        
        StdOut(GrowableBuffer<StdOut::Ignore>) { operation = Operation::Ignore; }
        
        StdOut(GrowableBuffer<StdOut::Inherit>) { operation = Operation::Inherit; }
        StdOut(GrowableBuffer<StdOut>) { operation = Operation::Inherit; }
        StdOut() { operation = Operation::Inherit; }
        
        StdOut(GrowableBuffer<Span<char>>& span) { operation = Operation::WritableSpan; writableSpan = &span.content; span.setContentInDestructor = false; }
        
        using StdStream::StdStream;
        friend struct ProcessChain;
        // clang-format on
    };
 
    using StdErr = StdOut;
 
    struct StdIn : public StdStream
    {
        // clang-format off
        struct Inherit{};
        
        StdIn(GrowableBuffer<Inherit>) { operation = Operation::Inherit; }
        StdIn(GrowableBuffer<StdIn>) { operation = Operation::Inherit; }
        StdIn() { operation = Operation::Inherit; }
 
        template <int N> StdIn(GrowableBuffer<const char [N]>& item) { operation = Operation::ReadableSpan; readableSpan = {item.content, N - 1}; }
        
        StdIn(GrowableBuffer<StringSpan> string) { operation = Operation::ReadableSpan; readableSpan = string.content.toCharSpan();}
        
        StdIn(GrowableBuffer<Span<const char>> span) { operation = Operation::ReadableSpan; readableSpan = span.content;}
        
        using StdStream::StdStream;
        friend struct ProcessChain;
        // clang-format on
    };
 
    ProcessID processID; 
    Options   options;   
 
    ProcessDescriptor::Handle handle = ProcessDescriptor::Invalid;
 
    Result waitForExitSync();
 
    template <typename Out = StdOut, typename In = StdIn, typename Err = StdErr>
    Result launch(Span<const StringSpan> cmd, Out&& stdOut = Out(), In&& stdIn = In(), Err&& stdErr = Err())
    {
        SC_TRY(formatArguments(cmd));
        GrowableBuffer<typename TypeTraits::RemoveReference<Out>::type> gbOut = {stdOut};
        GrowableBuffer<typename TypeTraits::RemoveReference<In>::type>  gbIn  = {stdIn};
        GrowableBuffer<typename TypeTraits::RemoveReference<Err>::type> gbErr = {stdErr};
        return launch(StdOut(gbOut), StdIn(gbIn), StdErr(gbErr));
    }
 
    template <typename Out = StdOut, typename In = StdIn, typename Err = StdErr>
    Result exec(Span<const StringSpan> cmd, Out&& stdOut = Out(), In&& stdIn = In(), Err&& stdErr = Err())
    {
        SC_TRY(launch(cmd, stdOut, stdIn, stdErr));
        return waitForExitSync();
    }
 
    int32_t getExitStatus() const { return exitStatus.status; }
 
    Result setWorkingDirectory(StringSpan processWorkingDirectory);
 
    void inheritParentEnvironmentVariables(bool inherit) { inheritEnv = inherit; }
 
    Result setEnvironment(StringSpan environmentVariable, StringSpan value);
 
    [[nodiscard]] static size_t getNumberOfProcessors();
 
    [[nodiscard]] static bool isWindowsConsoleSubsystem();
 
    [[nodiscard]] static bool isWindowsEmulatedProcess();
 
    Process(Span<native_char_t> commandMemory = {}, Span<native_char_t> environmentMemory = {})
        : command({commandMemory}), environment({environmentMemory})
    {
        if (commandMemory.empty())
            command = {commandStorage};
        if (environmentMemory.empty())
            environment = {environmentStorage};
    }
 
  private:
    ProcessExitStatus exitStatus; 
 
    FileDescriptor stdInFd;  
    FileDescriptor stdOutFd; 
    FileDescriptor stdErrFd; 
 
    Result launch(const StdOut& stdOutput, const StdIn& stdInput, const StdErr& stdError);
 
    Result formatArguments(Span<const StringSpan> cmd);
 
    StringPath currentDirectory;
#if SC_PLATFORM_WINDOWS
    StringPath executablePathForLaunch;
    bool       executablePathLooksLikeFile = false;
#endif
 
    // On Windows command holds the concatenation of executable and arguments.
    // On Posix command holds the concatenation of executable and arguments SEPARATED BY null-terminators (\0).
    // This is done so that in this single buffer with no allocation (under 255) or a single allocation (above 255)
    // we can track all arguments to be passed to execve.
    native_char_t              commandStorage[InlineCommandStorageCapacity];
    StringSpan::NativeWritable command;
#if !SC_PLATFORM_WINDOWS // On Posix we need to track the "sub-strings" hidden in command
    static constexpr size_t MAX_NUM_ARGUMENTS = 64;
    size_t commandArgumentsByteOffset[MAX_NUM_ARGUMENTS]; // Tracking length of each argument in the command string
    size_t commandArgumentsNumber = 0;                    // Counts number of arguments (including executable name)
#endif
 
    native_char_t              environmentStorage[4096 * 8];
    StringSpan::NativeWritable environment;
 
    static constexpr size_t MAX_NUM_ENVIRONMENT = 256;
 
    size_t environmentByteOffset[MAX_NUM_ENVIRONMENT]; // Tracking length of each environment variable
    size_t environmentNumber = 0;                      // Counts number of environment variable
 
    bool inheritEnv = true;
 
    friend struct ProcessChain;
    ProcessChain* parent = nullptr;
 
    Process* next = nullptr;
    Process* prev = nullptr;
    struct Internal;
    struct InternalFork;
    friend struct ProcessFork;
    Result launchImplementation();
    Result launchForkChild(PipeDescriptor& pipe);
    Result launchForkParent(PipeDescriptor& pipe, const void* previousSignals);
};
 
struct SC_PROCESS_EXPORT ProcessChain
{
    Process::Options options;
    Result pipe(Process& process, const Span<const StringSpan> cmd);
 
    template <typename Out = Process::StdOut, typename In = Process::StdIn, typename Err = Process::StdErr>
    Result launch(Out&& stdOut = Out(), In&& stdIn = In(), Err&& stdErr = Err())
    {
        GrowableBuffer<typename TypeTraits::RemoveReference<Out>::type> gbOut = {stdOut};
        GrowableBuffer<typename TypeTraits::RemoveReference<In>::type>  gbIn  = {stdIn};
        GrowableBuffer<typename TypeTraits::RemoveReference<Err>::type> gbErr = {stdErr};
        return internalLaunch(gbOut, gbIn, gbErr);
    }
 
    Result waitForExitSync();
 
    template <typename Out = Process::StdOut, typename In = Process::StdIn, typename Err = Process::StdErr>
    Result exec(Out&& stdOut = Out(), In&& stdIn = In(), Err&& stdErr = Err())
    {
        SC_TRY(launch(stdOut, stdIn, stdErr));
        return waitForExitSync();
    }
 
  private:
    Result internalLaunch(const Process::StdOut& stdOut, const Process::StdIn& stdIn, const Process::StdErr& stdErr);
    // Trimmed duplicate of IntrusiveDoubleLinkedList<T>
    struct ProcessLinkedList
    {
        Process* back  = nullptr; // has no next
        Process* front = nullptr; // has no prev
 
        [[nodiscard]] bool isEmpty() const { return front == nullptr; }
 
        void clear();
        void queueBack(Process& process);
    };
    ProcessLinkedList processes;
};
 
struct ProcessEnvironment
{
    ProcessEnvironment();
    ~ProcessEnvironment();
 
    ProcessEnvironment(const ProcessEnvironment&)            = delete;
    ProcessEnvironment(ProcessEnvironment&&)                 = delete;
    ProcessEnvironment& operator=(const ProcessEnvironment&) = delete;
    ProcessEnvironment& operator=(ProcessEnvironment&&)      = delete;
 
    [[nodiscard]] size_t size() const { return numberOfEnvironment; }
 
    [[nodiscard]] bool get(size_t index, StringSpan& name, StringSpan& value) const;
 
    [[nodiscard]] bool contains(StringSpan variableName, size_t* index = nullptr) const;
 
    [[nodiscard]] bool get(StringSpan variableName, StringSpan& value) const;
 
  private:
    size_t numberOfEnvironment = 0;
#if SC_PLATFORM_WINDOWS
    static constexpr size_t MAX_ENVIRONMENTS = 256;
 
    StringSpan envStrings[MAX_ENVIRONMENTS];
    wchar_t*   environment = nullptr;
#else
    char** environment = nullptr;
#endif
};
 
struct SC_PROCESS_EXPORT ProcessFork
{
    ProcessFork();
    ~ProcessFork();
    ProcessFork(const ProcessFork&)            = delete;
    ProcessFork* operator=(const ProcessFork&) = delete;
 
    enum Side
    {
        ForkParent, 
        ForkChild,  
    };
 
    [[nodiscard]] Side getSide() const { return side; }
 
    enum State
    {
        Suspended, 
        Immediate, 
    };
 
    Result fork(State state);
 
    Result resumeChildFork();
 
    Result waitForChild();
 
    int32_t getExitStatus() const { return exitStatus.status; }
 
    FileDescriptor& getWritePipe();
 
    FileDescriptor& getReadPipe();
 
  private:
    Side side = ForkParent;
#if SC_PLATFORM_WINDOWS
    ProcessDescriptor::Handle processHandle = ProcessDescriptor::Invalid;
    ProcessDescriptor::Handle threadHandle  = ProcessDescriptor::Invalid;
#else
    ProcessID processID;
#endif
    ProcessExitStatus exitStatus; 
 
    PipeDescriptor parentToFork; 
    PipeDescriptor forkToParent; 
};
 
} // namespace SC