Process.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
 
#include "../Containers/IntrusiveDoubleLinkedList.h"
#include "../File/FileDescriptor.h"
#include "../Strings/String.h"
#include "ProcessDescriptor.h"
 
namespace SC
{
struct SC_COMPILER_EXPORT Process;
struct SC_COMPILER_EXPORT ProcessChain;
struct SC_COMPILER_EXPORT ProcessFork;
struct ProcessID;
struct ProcessEnvironment;
} // namespace SC
 
 
 
struct SC::ProcessID
{
    int32_t pid = 0;
};
 
 
struct SC::Process
{
    struct SC_COMPILER_EXPORT Options
    {
        bool windowsHide; 
        Options();
    };
 
    struct StdStream
    {
        // clang-format off
        StdStream(String& externalString) { operation = Operation::String; string = &externalString;}
 
        StdStream(Buffer& externalBuffer) { operation = Operation::Vector; buffer = &externalBuffer; }
        // clang-format on
 
        StdStream(FileDescriptor&& file)
        {
            operation = Operation::FileDescriptor;
            (void)file.get(fileDescriptor, Result::Error("Invalid redirection file descriptor"));
            file.detach();
        }
 
        StdStream(PipeDescriptor& pipe)
        {
            operation      = Operation::ExternalPipe;
            pipeDescriptor = &pipe;
        }
 
      protected:
        struct AlreadySetup
        {
        };
        StdStream() = default;
        StdStream(AlreadySetup) { operation = Operation::AlreadySetup; }
        friend struct Process;
        friend struct ProcessChain;
 
        enum class Operation
        {
            AlreadySetup,
            Inherit,
            Ignore,
            ExternalPipe,
            FileDescriptor,
            Vector,
            String,
            WritableSpan,
            ReadableSpan
        };
        Operation operation = Operation::Inherit;
 
        Span<const char> readableSpan;
        Span<char>       writableSpan;
 
        String* string;
        Buffer* buffer;
 
        FileDescriptor::Handle fileDescriptor;
 
        PipeDescriptor* pipeDescriptor;
    };
 
    struct StdOut : public StdStream
    {
        // clang-format off
        struct Ignore{};
        struct Inherit{};
 
        StdOut(Ignore) { operation = Operation::Ignore; }
 
        StdOut(Inherit) { operation = Operation::Inherit; }
 
        StdOut(Span<char> span) { operation = Operation::WritableSpan; writableSpan = span; }
 
        using StdStream::StdStream;
        friend struct ProcessChain;
        // clang-format on
    };
 
    using StdErr = StdOut;
 
    struct StdIn : public StdStream
    {
        // clang-format off
        struct Inherit{};
 
        StdIn(Inherit) { operation = Operation::Inherit; }
 
        template <int N> StdIn(const char (&item)[N]) : StdIn(StringView({item, N - 1}, true, StringEncoding::Ascii)) {}
 
        StdIn(StringView string) : StdIn(string.toCharSpan()) {}
 
        StdIn(Span<const char> span) { operation = Operation::ReadableSpan; readableSpan = span;}
 
        using StdStream::StdStream;
        friend struct ProcessChain;
        // clang-format on
    };
 
    ProcessDescriptor handle;    
    ProcessID         processID; 
    Options           options;   
 
    [[nodiscard]] Result waitForExitSync();
 
    [[nodiscard]] Result launch(Span<const StringView> cmd,                        //
                                const StdOut&          stdOut = StdOut::Inherit{}, //
                                const StdIn&           stdIn  = StdIn::Inherit{},  //
                                const StdErr&          stdErr = StdErr::Inherit{})
    {
        SC_TRY(formatArguments(cmd));
        return launch(stdOut, stdIn, stdErr);
    }
 
    [[nodiscard]] Result exec(Span<const StringView> cmd,                        //
                              const StdOut&          stdOut = StdOut::Inherit{}, //
                              const StdIn&           stdIn  = StdIn::Inherit{},  //
                              const StdErr&          stdErr = StdErr::Inherit{})
    {
        SC_TRY(launch(cmd, stdOut, stdIn, stdErr));
        return waitForExitSync();
    }
 
    int32_t getExitStatus() const { return exitStatus.status; }
 
    [[nodiscard]] Result setWorkingDirectory(StringView processWorkingDirectory);
 
    void inheritParentEnvironmentVariables(bool inherit) { inheritEnv = inherit; }
 
    [[nodiscard]] Result setEnvironment(StringView environmentVariable, StringView value);
 
    [[nodiscard]] static size_t getNumberOfProcessors();
 
    [[nodiscard]] static bool isWindowsConsoleSubsystem();
 
    [[nodiscard]] static bool isWindowsEmulatedProcess();
 
  private:
    ProcessDescriptor::ExitStatus exitStatus; 
 
    FileDescriptor stdInFd;  
    FileDescriptor stdOutFd; 
    FileDescriptor stdErrFd; 
 
    [[nodiscard]] Result launch(const StdOut& stdOutput, const StdIn& stdInput, const StdErr& stdError);
 
    [[nodiscard]] Result formatArguments(Span<const StringView> cmd);
 
    StringNative<255> currentDirectory = StringEncoding::Native;
 
    // 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.
    StringNative<255> command = StringEncoding::Native;
#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
 
    StringNative<1024> environment = StringEncoding::Native;
 
    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 IntrusiveDoubleLinkedList<Process>;
    friend struct ProcessChain;
    ProcessChain* parent = nullptr;
 
    Process* next = nullptr;
    Process* prev = nullptr;
    struct Internal;
    friend struct ProcessFork;
    Result launchImplementation();
};
 
struct SC::ProcessChain
{
    Process::Options options;
    [[nodiscard]] Result pipe(Process& process, const Span<const StringView> cmd);
 
    [[nodiscard]] Result launch(const Process::StdOut& stdOut = Process::StdOut::Inherit{}, //
                                const Process::StdIn&  stdIn  = Process::StdIn::Inherit{},  //
                                const Process::StdErr& stdErr = Process::StdErr::Inherit{});
 
    [[nodiscard]] Result waitForExitSync();
 
    [[nodiscard]] Result exec(const Process::StdOut& stdOut = Process::StdOut::Inherit{}, //
                              const Process::StdIn&  stdIn  = Process::StdIn::Inherit{},  //
                              const Process::StdErr& stdErr = Process::StdErr::Inherit{})
    {
        SC_TRY(launch(stdOut, stdIn, stdErr));
        return waitForExitSync();
    }
 
  private:
    IntrusiveDoubleLinkedList<Process> processes;
};
 
struct SC::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, StringView& name, StringView& value) const;
 
    [[nodiscard]] bool contains(StringView variableName, size_t* index = nullptr);
 
  private:
    size_t numberOfEnvironment = 0;
#if SC_PLATFORM_WINDOWS
    static constexpr size_t MAX_ENVIRONMENTS = 256;
 
    StringView envStrings[MAX_ENVIRONMENTS];
    wchar_t*   environment = nullptr;
#else
    char** environment = nullptr;
#endif
};
 
struct SC::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
    detail::ProcessDescriptorDefinition::Handle processHandle = detail::ProcessDescriptorDefinition::Invalid;
    detail::ProcessDescriptorDefinition::Handle threadHandle  = detail::ProcessDescriptorDefinition::Invalid;
#else
    ProcessID processID;
#endif
    ProcessDescriptor::ExitStatus exitStatus; 
 
    PipeDescriptor parentToFork; 
    PipeDescriptor forkToParent; 
};