Remove accidental file 'tatus'

.gitignore

@@ -7,3 +7,4 @@ cmake-build-release
 CMakeFiles
 CMakeLists.txt
 Makefile
+sample/logs/*

CMakeLists.txt

@@ -3,4 +3,5 @@ project(rex)
 
 set(CMAKE_CXX_STANDARD 14)
 
-add_executable(rex Rex.cpp src/json_support/jsoncpp/json.h src/json_support/jsoncpp/json-forwards.h src/json_support/jsoncpp/jsoncpp.cpp src/logger/Logger.cpp src/logger/Logger.h src/json_support/JSON.cpp src/json_support/JSON.h src/misc/helpers.cpp src/misc/helpers.h src/config/Config.cpp src/config/Config.h src/suite/Suite.cpp src/suite/Suite.h src/suite/Unit.cpp src/suite/Unit.h src/shells/shells.cpp src/shells/shells.h src/plan/Plan.cpp src/plan/Plan.h src/plan/Task.cpp src/plan/Task.h src/lcpex/liblcpex.h src/lcpex/liblcpex.cpp src/lcpex/vpty/libclpex_tty.h src/lcpex/vpty/libclpex_tty.cpp src/lcpex/Contexts.h src/lcpex/Contexts.cpp src/lcpex/helpers.h src/lcpex/string_expansion/string_expansion.h src/lcpex/string_expansion/string_expansion.cpp src/lcpex/vpty/pty_fork_mod/pty_fork.h src/lcpex/vpty/pty_fork_mod/pty_fork.cpp src/lcpex/vpty/pty_fork_mod/pty_master_open.h src/lcpex/vpty/pty_fork_mod/pty_master_open.cpp src/lcpex/vpty/pty_fork_mod/tty_functions.h src/lcpex/vpty/pty_fork_mod/tty_functions.cpp )
+add_executable(rex Rex.cpp src/json_support/jsoncpp/json.h src/json_support/jsoncpp/json-forwards.h src/json_support/jsoncpp/jsoncpp.cpp src/logger/Logger.cpp src/logger/Logger.h src/json_support/JSON.cpp src/json_support/JSON.h src/misc/helpers.cpp src/misc/helpers.h src/config/Config.cpp src/config/Config.h src/suite/Suite.cpp src/suite/Suite.h src/suite/Unit.cpp src/suite/Unit.h src/shells/shells.cpp src/shells/shells.h src/plan/Plan.cpp src/plan/Plan.h src/plan/Task.cpp src/plan/Task.h src/lcpex/helpers.h src/lcpex/helpers.cpp src/lcpex/liblcpex.h src/lcpex/liblcpex.cpp src/lcpex/vpty/libclpex_tty.h src/lcpex/vpty/libclpex_tty.cpp src/lcpex/Contexts.h src/lcpex/Contexts.cpp src/lcpex/helpers.h src/lcpex/string_expansion/string_expansion.h src/lcpex/string_expansion/string_expansion.cpp src/lcpex/vpty/pty_fork_mod/pty_fork.h src/lcpex/vpty/pty_fork_mod/pty_fork.cpp src/lcpex/vpty/pty_fork_mod/pty_master_open.h src/lcpex/vpty/pty_fork_mod/pty_master_open.cpp src/lcpex/vpty/pty_fork_mod/tty_functions.h src/lcpex/vpty/pty_fork_mod/tty_functions.cpp
+        src/lcpex/FileHandle.h)

Rex.cpp

@@ -15,12 +15,15 @@
 */
 
 #include <iostream>
+#include <string>
+#include <cstring>
 #include <unistd.h>
 #include <getopt.h>
 #include "src/logger/Logger.h"
 #include "src/config/Config.h"
 #include "src/suite/Suite.h"
 #include "src/plan/Plan.h"
+#include "src/misc/helpers.h"
 
 void version_info()
 {
@@ -162,6 +165,8 @@ int main( int argc, char * argv[] )
     interpolate( config_path );
     interpolate( plan_path );
 
+    plan_path = get_absolute_path( plan_path );
+
     // default logging level
     int L_LEVEL = E_INFO;
 

sample/components/independent_test_1.bash

@@ -1,7 +1,7 @@
 #!/usr/bin/bash
 #
 echo test from script
-/usr/bin/dialog --title "This should be one argument" --inputbox "Enter your name:" 0 0
+#/usr/bin/dialog --title "This should be one argument" --inputbox "Enter your name:" 0 0
 
 
 

sample/environments/rex.variables

@@ -1,9 +1,5 @@
 #!/usr/bin/bash
 
-
-
-
-
 set -a
 
 echo "variables file says hello and set a variable named TEST_VAR"

sample/plans/test.plan

@@ -1,5 +1,6 @@
 {
   "plan": [
-    { "name": "independent test 1", "dependencies":  [ null ] }
+    { "name": "independent test 1", "dependencies":  [ null ] },
+    { "name": "independent test 2", "dependencies":  [ null ] }
   ]
 }

sample/rex.config

@@ -1,6 +1,6 @@
 {
   "config": {
-	"project_root": 	"/tmp/sample",
+	"project_root": 	"$HOME/development/internal/rex/sample",
   	"units_path":		"units/",
   	"logs_path": 		"logs/",
 	"shells_path":		"shells/shells.definitions",

sample/units/new.units

@@ -13,8 +13,26 @@
         "active":       		true,
         "required":     		true,
 	"set_user_context": 		true,
-        "user":         		"bagira",
-        "group":        		"bagira",
+        "user":         		"$USER",
+        "group":        		"$USER",
+	"supply_environment":		true,
+        "environment":  		"environments/rex.variables"
+    },
+    {
+        "name":         		"independent test 2",
+        "target":       		"components/independent_test_1.bash --ls -s --arg",
+	"is_shell_command":		true,
+	"shell_definition":		"bash",
+	"force_pty":			true,
+	"set_working_directory":	false,
+	"working_directory":		"",
+        "rectify":      		false,
+        "rectifier":    		"echo rectifier executed",
+        "active":       		true,
+        "required":     		true,
+	"set_user_context": 		true,
+        "user":         		"$USER",
+        "group":        		"$USER",
 	"supply_environment":		true,
         "environment":  		"environments/rex.variables"
     }

src/config/Config.cpp

@@ -72,7 +72,7 @@ void Conf::set_object_s(std::string keyname, std::string & object_member, std::s
     if ( this->get_string(jval_s, keyname) != 0) {
         throw ConfigLoadException( "'" + keyname + "' string is not set in the config file supplied: " + filename );
     } else {
-        interpolate(jval_s);
+        //interpolate(jval_s);
         object_member = jval_s;
     }
     this->slog.log_task( E_DEBUG, "SET_PROPERTY", "'" + keyname + "': " + object_member );
@@ -101,7 +101,7 @@ void Conf::set_object_s_derivedpath(std::string keyname, std::string & object_me
     if ( this->get_string(jval_s, keyname) != 0) {
         throw ConfigLoadException( "'" + keyname + "' string is not set in the config file supplied: " + filename );
     } else {
-        interpolate(jval_s);
+        //interpolate(jval_s);
         object_member = prepend_project_root( jval_s );
     }
     this->slog.log_task( E_DEBUG, "SET_PROPERTY", "'" + keyname + "': " + object_member );
@@ -157,29 +157,7 @@ std::string Conf::prepend_project_root( std::string relative_path)
     return this->project_root + "/" + relative_path;
 }
 
-/**
- * @brief Get the absolute path from a relative path
- *
- * This function takes a relative path and returns the corresponding absolute path.
- * The absolute path is obtained by calling the `realpath` function.
- * If the `realpath` function returns a null pointer, an error message is printed to the standard error stream and an empty string is returned.
- *
- * @param relative_path The relative path to be converted to an absolute path
- *
- * @return The absolute path corresponding to the relative path
- */
-std::string get_absolute_path(const std::string &relative_path)
-{
-    char resolved_path[1024];
-    memset(resolved_path, 0, sizeof(resolved_path));
 
-    if( realpath( relative_path.c_str(), resolved_path) == nullptr ) {
-        std::cerr << "Error resolving path: " << relative_path << std::endl;
-        return "";
-    }
-
-    return std::string(resolved_path);
-}
 
 /**
  * @brief Check if a path exists
@@ -265,8 +243,6 @@ Shell Conf::get_shell_by_name( std::string name ) {
     throw ConfigLoadException("The shell specified ('" + name + "') is not defined in the shell definitions file.");
 }
 
-
-
 /**
  * @class Conf
  * @brief Loads the configuration for the application
@@ -284,9 +260,9 @@ Shell Conf::get_shell_by_name( std::string name ) {
 Conf::Conf(std::string filename, int LOG_LEVEL ): JSON_Loader(LOG_LEVEL ), slog(LOG_LEVEL, "_conf_" )
 {
     this->LOG_LEVEL = LOG_LEVEL;
-    this->slog.log_task( E_DEBUG, "LOAD", "Loading configuration file: " + filename );
 
     interpolate( filename );
+    this->slog.log_task( E_DEBUG, "LOAD", "Loading configuration file: " + filename );
 
     try {
         // load the test file.
@@ -295,6 +271,7 @@ Conf::Conf(std::string filename, int LOG_LEVEL ): JSON_Loader(LOG_LEVEL ), slog(
         this->slog.log( E_FATAL, "Unable to load configuration file: '" + filename + "'. Error: " + e.what());
         throw ConfigLoadException("Parsing error in configuration file.");
     }
+
     Json::Value jbuff;
 
     if ( this->get_serialized( jbuff, "config" ) != 0) {
@@ -306,15 +283,20 @@ Conf::Conf(std::string filename, int LOG_LEVEL ): JSON_Loader(LOG_LEVEL ), slog(
     }
 
     set_object_s( "project_root",     this->project_root,           filename );
+    interpolate( this->project_root );
+
     // convert to an absolute path after all the interpolation is done.
     this->project_root = get_absolute_path( this->project_root );
-    set_object_s(   "logs_path",        this->logs_path,              filename );
-    this->logs_path = get_absolute_path( this->logs_path );
 
+    set_object_s( "logs_path",        this->logs_path,              filename );
+    interpolate( this->logs_path );
 
     // all other paths are relative to project_root
     set_object_s_derivedpath( "units_path",       this->units_path,             filename );
+    interpolate( this->units_path );
+
     set_object_s_derivedpath( "shells_path",      this->shell_definitions_path, filename );
+    interpolate( this->shell_definitions_path );
 
     // ensure these paths exists, with exception to the logs_path, which will be created at runtime
     this->slog.log_task( E_DEBUG, "SANITY_CHECKS", "Checking for sanity..." );

src/lcpex/FileHandle.h

@@ -0,0 +1,54 @@
+#pragma once
+#include <unistd.h> // for close()
+
+// Simplified RAII wrapper for file descriptors (C-style compatible)
+class FdGuard {
+    int fd_;
+public:
+    // Constructor
+    explicit FdGuard(int fd = -1) : fd_(fd) {}
+
+    // Disable copy semantics
+    FdGuard(const FdGuard&) = delete;
+    FdGuard& operator=(const FdGuard&) = delete;
+
+    // Move constructor
+    FdGuard(FdGuard&& other) /* no noexcept */ {
+        fd_ = other.fd_;
+        other.fd_ = -1;
+    }
+
+    // Move assignment
+    FdGuard& operator=(FdGuard&& other) /* no noexcept */ {
+        if (this != &other) {
+            reset(); // Close current if valid
+            fd_ = other.fd_;
+            other.fd_ = -1;
+        }
+        return *this;
+    }
+
+    // Destructor
+    ~FdGuard() {
+        close_if_valid();
+    }
+
+    // Reset with new fd (or close if -1)
+    void reset(int new_fd = -1) {
+        close_if_valid();
+        fd_ = new_fd;
+    }
+
+    // Get the raw fd
+    int get() const {
+        return fd_;
+    }
+
+private:
+    void close_if_valid() {
+        if (fd_ != -1) {
+            ::close(fd_);
+            fd_ = -1;
+        }
+    }
+};

src/lcpex/helpers.cpp

@@ -0,0 +1,15 @@
+#include "helpers.h"
+
+ssize_t write_all(int fd, const void *buf, size_t count) {
+    const char *p = (const char *)buf;
+    while (count > 0) {
+        ssize_t written = write(fd, p, count);
+        if (written == -1) {
+            if (errno == EINTR || errno == EAGAIN) continue; // Retry
+            return -1; // Other errors
+        }
+        count -= written;
+        p += written;
+    }
+    return 0;
+}

src/lcpex/helpers.h

@@ -1,6 +1,9 @@
 #ifndef LCPEX_HELPERS_H
 #define LCPEX_HELPERS_H
 
+#include <unistd.h>
+#include "errno.h"
+
 // helper for sanity
 enum PIPE_ENDS {
     READ_END = 0,
@@ -16,6 +19,6 @@ enum CHILD_PIPE_NAMES {
 
 #define BUFFER_SIZE 1024
 
-
+ssize_t write_all(int fd, const void *buf, size_t count);
 
 #endif //LCPEX_HELPERS_H

src/lcpex/liblcpex.cpp

@@ -1,4 +1,69 @@
 #include "liblcpex.h"
+#include <cstring>
+#include <stdexcept>
+#include <signal.h>
+#include <string>
+#include "../logger/Logger.h"
+#include "FileHandle.h"
+#define BUFFER_SIZE 1024
+
+
+// Initialize logger
+static Logger logger(E_INFO, "lcpex");
+std::string user = logger.get_user_name();
+std::string group = logger.get_group_name();
+
+void signal_handler(int sig) {
+    std::string command = "signal_handler";        // Command context
+
+    // Create an instance of Logger (you can change the log level and mask accordingly)
+    // Log the signal handling
+    if (sig == SIGCHLD) {
+        // Log that SIGCHLD was received, but leave the exit status to the parent
+        logger.log_to_json_file("E_INFO", "SIGCHLD received. A child process ended.", user, group, command);
+    } else if (sig == SIGINT) {
+        logger.log_to_json_file("E_FATAL", "SIGINT received. Gracefully terminating...", user, group, command);
+    } else if (sig == SIGTERM) {
+        logger.log_to_json_file("E_FATAL", "SIGTERM received. Terminating...", user, group, command);
+    } else if (sig == SIGSEGV) {
+        logger.log_to_json_file("E_FATAL", "SIGSEGV received. Possible segmentation fault.", user, group, command);
+    } else {
+        logger.log_to_json_file("E_FATAL", "Unhandled signal received", user, group, command);
+    }
+}
+
+// Setup signal registrations
+void setup_signal_handlers() {
+    struct sigaction sa;
+    sa.sa_handler = signal_handler; // <-- handler function
+    sigemptyset(&sa.sa_mask);
+    sa.sa_flags = SA_RESTART | SA_NOCLDSTOP;
+    std::string command = "setup_signal_handlers"; // Command context
+
+    // SIGCHLD
+    if (sigaction(SIGCHLD, &sa, nullptr) == -1) {
+        std::string error_message = "Failed to set SIGCHLD handler: " + std::string(strerror(errno));
+        logger.log_to_json_file("E_FATAL", error_message, user, group, command); // Log to JSON file
+    }
+
+    // SIGINT
+    if (sigaction(SIGINT, &sa, nullptr) == -1) {
+        std::string error_message = "Failed to set SIGINT handler: " + std::string(strerror(errno));
+        logger.log_to_json_file("E_FATAL", error_message, user, group, command); // Log to JSON file
+    }
+
+    // SIGTERM
+    if (sigaction(SIGTERM, &sa, nullptr) == -1) {
+        std::string error_message = "Failed to set SIGTERM handler: " + std::string(strerror(errno));
+        logger.log_to_json_file("E_FATAL", error_message, user, group, command); // Log to JSON file
+    }
+
+    // SIGSEGV
+    if (sigaction(SIGSEGV, &sa, nullptr) == -1) {
+        std::string error_message = "Failed to set SIGSEGV handler: " + std::string(strerror(errno));
+        logger.log_to_json_file("E_FATAL", error_message, user, group, command); // Log to JSON file
+    }
+}
 
 std::string prefix_generator(
         std::string command,
@@ -36,8 +101,12 @@ std::string prefix_generator(
         // it's not a shell command, so we can just execute it directly
         prefix = command;
     }
-    std::cout << "LAUNCHER: " << prefix << std::endl;
+
+    // Log the message to JSON file
+    logger.log_to_json_file("E_INFO", "LAUNCHER: " + prefix, user, group, command);
+    //logger.log(E_INFO, "LAUNCHER: " + prefix);
     return prefix;
+
 }
 
 
@@ -68,6 +137,7 @@ int lcpex(
             environment_file_path
     );
     command = prefix;
+    setup_signal_handlers();
 
     // if we are forcing a pty, then we will use the vpty library
     if( force_pty )
@@ -90,10 +160,14 @@ int lcpex(
  */
 void set_cloexec_flag(int fd)
 {
+    std::string command = "set_cloexec_flag";
     if (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1)
     {
-        perror("fcntl");
-        exit(1);
+        std::string error_message = "fcntl(F_SETFD) failed for fd " + std::to_string(fd);
+
+        logger.log_to_json_file("E_FATAL", error_message, user, group, command);
+
+        throw std::runtime_error("fcntl(F_SETFD) failed for fd " + std::to_string(fd));
     }
 }
 
@@ -124,6 +198,13 @@ void set_cloexec_flag(int fd)
 void run_child_process(bool context_override, const char* context_user, const char* context_group, char* processed_command[], int fd_child_stdout_pipe[], int fd_child_stderr_pipe[]) {
     while ((dup2(fd_child_stdout_pipe[WRITE_END], STDOUT_FILENO) == -1) && (errno == EINTR)) {}
     while ((dup2(fd_child_stderr_pipe[WRITE_END], STDERR_FILENO) == -1) && (errno == EINTR)) {}
+    // Close unused pipe ends to avoid leaks
+
+    close(fd_child_stdout_pipe[READ_END]);
+    close(fd_child_stdout_pipe[WRITE_END]);
+    close(fd_child_stderr_pipe[READ_END]);
+    close(fd_child_stderr_pipe[WRITE_END]);
+    std::string command = "run_child_process";    // Command context
 
     if ( context_override ) {
         int context_result = set_identity_context(context_user, context_group);
@@ -131,34 +212,38 @@ void run_child_process(bool context_override, const char* context_user, const ch
             case IDENTITY_CONTEXT_ERRORS::ERROR_NONE:
                 break;
             case IDENTITY_CONTEXT_ERRORS::ERROR_NO_SUCH_USER:
-                std::cerr << "REX: Aborting: context user not found: " << context_user << std::endl;
-                exit(1);
+                logger.log(E_FATAL, "Aborting: context user not found: " + std::string(context_user));
+                logger.log_to_json_file("E_FATAL", "Aborting: context user not found: " + std::string(context_user), user, group, command);
+                _exit(1);
                 break;
             case IDENTITY_CONTEXT_ERRORS::ERROR_NO_SUCH_GROUP:
-                std::cerr << "REX: Aborting: context group not found: " << context_group << std::endl;
-                exit(1);
+                logger.log(E_FATAL, "Aborting: context group not found: " + std::string(context_group));
+                logger.log_to_json_file("E_FATAL", "Aborting: context group not found: " + std::string(context_group), user, group, command);
+                _exit(1);
                 break;
             case IDENTITY_CONTEXT_ERRORS::ERROR_SETGID_FAILED:
-                std::cerr << "REX: Aborting: Setting GID failed: " << context_user << "/" << context_group << std::endl;
-                exit(1);
+                logger.log(E_FATAL, "Aborting: Setting GID failed: " + std::string(context_user) + "/" + std::string(context_group));
+                logger.log_to_json_file("E_FATAL", "Aborting: Setting GID failed: " + std::string(context_user) + "/" + std::string(context_group), user, group, command);
+                _exit(1);
                 break;
             case IDENTITY_CONTEXT_ERRORS::ERROR_SETUID_FAILED:
-                std::cerr << "REX: Aborting: Setting UID failed: " << context_user << "/" << context_group << std::endl;
-                exit(1);
+                logger.log(E_FATAL, "Aborting: Setting UID failed: " + std::string(context_user) + "/" + std::string(context_group));
+                logger.log_to_json_file("E_FATAL", "Aborting: Setting UID failed: " + std::string(context_user) + "/" + std::string(context_group), user, group, command);
+                _exit(1);
                 break;
             default:
-                std::cerr << "REX: Aborting: Unknown error while setting identity context." << std::endl;
-                exit(1);
+                logger.log(E_FATAL, "Aborting: Unknown error while setting identity context.");
+                logger.log_to_json_file("E_FATAL", "Aborting: Unknown error while setting identity context.", user, group, command);
+                _exit(1);
                 break;
         }
     }
-
     int exit_code = execvp(processed_command[0], processed_command);
-    perror("failed on execvp in child");
-    exit(exit_code);
+    logger.log_to_json_file("E_FATAL", "failed on execvp in child", user, group, command);
+    logger.log(E_FATAL, "failed on execvp in child");
+    _Exit(exit_code);
 }
 
-
 int execute(
         std::string command,
         FILE * stdout_log_fh,
@@ -168,6 +253,8 @@ int execute(
         std::string context_group,
         bool environment_supplied
 ){
+
+    try {
     // this does three things:
     //  - execute a dang string as a subprocess command
     //  - capture child stdout/stderr to respective log files
@@ -180,7 +267,8 @@ int execute(
     // before we fork the process, so that the child process will inherit the environment
     // from the parent process
     if ( environment_supplied ) {
-        clearenv();
+        // this breaks reuse of env variables in between executions
+        //clearenv();
     }
 
     // create the pipes for the child process to write and read from using its stdin/stdout/stderr
@@ -188,13 +276,13 @@ int execute(
     int fd_child_stderr_pipe[2];
 
     if ( pipe(fd_child_stdout_pipe ) == -1 ) {
-        perror( "child stdout pipe" );
-        exit( 1 );
+        throw std::runtime_error("Failed to create stdout pipe");
     }
 
     if ( pipe( fd_child_stderr_pipe ) == -1 ) {
-        perror( "child stderr pipe" );
-        exit( 1 );
+        close(fd_child_stdout_pipe[0]);
+        close(fd_child_stdout_pipe[1]);
+        throw std::runtime_error("Failed to create stderr pipe");
     }
 
     // using O_CLOEXEC to ensure that the child process closes the file descriptors
@@ -204,15 +292,20 @@ int execute(
     set_cloexec_flag( fd_child_stderr_pipe[WRITE_END] );
 
     // status result basket for the parent process to capture the child's exit status
-    int status = 616;
+    int status;
     pid_t pid = fork();
 
     switch( pid ) {
         case -1:
         {
             // fork failed
-            perror("fork failure");
-            exit(1);
+            logger.log(E_FATAL, "fork failure: " + std::string(strerror(errno)));
+            logger.log_to_json_file("E_FATAL", "fork failure: " + std::string(strerror(errno)), user, group, command);
+            close(fd_child_stdout_pipe[0]);      // Pipe Leaks on Error Paths
+            close(fd_child_stdout_pipe[1]);      // Pipe Leaks on Error Paths
+            close(fd_child_stderr_pipe[0]);      // Pipe Leaks on Error Paths
+            close(fd_child_stderr_pipe[1]);      // Pipe Leaks on Error Paths
+            throw std::runtime_error("fork() failed: " + std::string(strerror(errno)));
         }
 
         case 0:
@@ -232,14 +325,23 @@ int execute(
         {
             // parent process
 
+            FdGuard stdout_read_guard(fd_child_stdout_pipe[READ_END]);
+            FdGuard stderr_read_guard(fd_child_stderr_pipe[READ_END]);
+            FdGuard stdout_write_guard(fd_child_stdout_pipe[WRITE_END]);
+            FdGuard stderr_write_guard(fd_child_stderr_pipe[WRITE_END]);
+
+            // We don't need WRITE_ENDs in parent, close them now
+            stdout_write_guard.reset();  // Closes and sets fd to -1
+            stderr_write_guard.reset();
+
             // The parent process has no need to access the entrance to the pipe, so fd_child_*_pipe[1|0] should be closed
             // within that process too:
-            close(fd_child_stdout_pipe[WRITE_END]);
-            close(fd_child_stderr_pipe[WRITE_END]);
+
 
             // attempt to write to stdout,stderr from child as well as to write each to file
-            char buf[BUFFER_SIZE];
-
+            char buf[BUFFER_SIZE] = {0};
+            std::strncpy(buf, command.c_str(), BUFFER_SIZE - 1);
+            buf[BUFFER_SIZE - 1] = '\0';
             // contains the byte count of the last read from the pipe
             ssize_t byte_count;
 
@@ -249,11 +351,11 @@ int execute(
             // populate the watched_fds array
 
             // child STDOUT to parent
-            watched_fds[CHILD_PIPE_NAMES::STDOUT_READ].fd = fd_child_stdout_pipe[READ_END];
+            watched_fds[CHILD_PIPE_NAMES::STDOUT_READ].fd = stdout_read_guard.get();
             watched_fds[CHILD_PIPE_NAMES::STDOUT_READ].events = POLLIN;
 
             // child STDERR to parent
-            watched_fds[CHILD_PIPE_NAMES::STDERR_READ].fd = fd_child_stderr_pipe[READ_END];
+            watched_fds[CHILD_PIPE_NAMES::STDERR_READ].fd = stderr_read_guard.get();
             watched_fds[CHILD_PIPE_NAMES::STDERR_READ].events = POLLIN;
 
             // number of files poll() reports as ready
@@ -265,10 +367,17 @@ int execute(
             // loop until we've read all the data from the child process
             while ( ! break_out ) {
                 num_files_readable = poll(watched_fds, sizeof(watched_fds) / sizeof(watched_fds[0]), -1);
+                // after the poll() call, add a check to see if both pipes are closed
+                if (!(watched_fds[CHILD_PIPE_NAMES::STDOUT_READ].events & POLLIN) &&
+                    !(watched_fds[CHILD_PIPE_NAMES::STDERR_READ].events & POLLIN)) {
+                    break_out = true;
+                }
+
                 if (num_files_readable == -1) {
                     // error occurred in poll()
-                    perror("poll");
-                    exit(1);
+                    logger.log(E_FATAL, "poll() failed: " + std::string(strerror(errno)));
+                    logger.log_to_json_file("E_FATAL", "poll() failed", user, group, command);
+                    throw std::runtime_error("poll() failed");
                 }
                 if (num_files_readable == 0) {
                     // poll reports no files readable
@@ -281,9 +390,15 @@ int execute(
                         byte_count = read(watched_fds[this_fd].fd, buf, BUFFER_SIZE);
 
                         if (byte_count == -1) {
+                            if (errno == EAGAIN) { continue; } else {
                                 // error reading from pipe
-                            perror("read");
+                                logger.log(E_FATAL, "Error while reading: " + std::string(strerror(errno)));
+                                logger.log_to_json_file("E_FATAL", "Error while reading from pipe", user, group, command);
+                                stdout_read_guard.reset(-1);
+                                stderr_read_guard.reset(-1);
                                 exit(EXIT_FAILURE);
+                            }
+
                         } else if (byte_count == 0) {
                             // reached EOF on one of the streams but not a HUP
                             // we've read all we can this cycle, so go to the next fd in the for loop
@@ -293,41 +408,79 @@ int execute(
                             // write to stdout,stderr
                             if (this_fd == CHILD_PIPE_NAMES::STDOUT_READ) {
                                 // the child's stdout pipe is readable
-                                write(stdout_log_fh->_fileno, buf, byte_count);
-                                write(STDOUT_FILENO, buf, byte_count);
+                                write_all(stdout_log_fh->_fileno, buf, byte_count);
+                                write_all(STDOUT_FILENO, buf, byte_count);
                             } else if (this_fd == CHILD_PIPE_NAMES::STDERR_READ) {
                                 // the child's stderr pipe is readable
-                                write(stderr_log_fh->_fileno, buf, byte_count);
-                                write(STDERR_FILENO, buf, byte_count);
+                                write_all(stderr_log_fh->_fileno, buf, byte_count);
+                                write_all(STDERR_FILENO, buf, byte_count);
                             } else {
                                 // this should never happen
-                                perror("Logic error!");
+                                logger.log(E_FATAL, "Logic error: unexpected pipe index.");
                                 exit(EXIT_FAILURE);
                             }
                         }
                     }
                     if (watched_fds[this_fd].revents & POLLERR) {
-                        close(watched_fds[this_fd].fd);
+                        if (this_fd == CHILD_PIPE_NAMES::STDOUT_READ) {
+                            stdout_read_guard.reset(-1);
+                        } else if (this_fd == CHILD_PIPE_NAMES::STDERR_READ) {
+                            stderr_read_guard.reset(-1);
+                        }
                         break_out = true;
                     }
                     if (watched_fds[this_fd].revents & POLLHUP) {
                         // this pipe has hung up
-                        close(watched_fds[this_fd].fd);
-                        break_out = true;
+                        // don't close the file descriptor yet, there might still be data to read
+                        // instead, remove the POLLIN event to avoid getting a POLLHUP event in the next poll() call
+                        watched_fds[this_fd].events &= ~POLLIN;
                     }
-
                 }
             }
             // wait for child to exit, capture status
             waitpid(pid, &status, 0);
 
+            // Drain the pipes before exiting
+            while ((byte_count = read(stdout_read_guard.get(), buf, BUFFER_SIZE)) > 0) {
+                write_all(stdout_log_fh->_fileno, buf, byte_count);
+                write_all(STDOUT_FILENO, buf, byte_count);
+            }
+            while ((byte_count = read(stderr_read_guard.get(), buf, BUFFER_SIZE)) > 0) {
+                write_all(stderr_log_fh->_fileno, buf, byte_count);
+                write_all(STDERR_FILENO, buf, byte_count);
+            }
 
-            if WIFEXITED(status) {
-                return WEXITSTATUS(status);
-            } else {
-                return -617;
+            int status;
+            pid_t pid = waitpid(-1, &status, WNOHANG);  // Non-blocking wait for child process
+            if (pid > 0) {  // If a child process has terminated
+                // Check if the child process exited normally
+                if (WIFEXITED(status)) {
+                    int exit_code = WEXITSTATUS(status);
+                    logger.log(E_INFO, "Child exited with status " + std::to_string(exit_code));
+                    logger.log_to_json_file("E_INFO", "Child exited with status " + std::to_string(exit_code), user, group, command);
+                }
+                // Check if the child process was terminated by a signal
+                else if (WIFSIGNALED(status)) {
+                    int signal_number = WTERMSIG(status);
+                    logger.log(E_FATAL, "Process terminated by signal: " + std::to_string(signal_number));
+                    logger.log_to_json_file("E_FATAL", "Process terminated by signal: " + std::to_string(signal_number), user, group, command);
+                    // Reset signal handler to default before exiting
+                    signal(signal_number, SIG_DFL);
+                    // Return 128 + signal number as the exit code for signal termination
+                    return 128 + signal_number;  // POSIX exit code format
+                }
+                // Handle unexpected exit conditions
+                else {
+                    logger.log(E_WARN, "Unknown child exit condition.");
+                    logger.log_to_json_file("E_WARN", "Unknown child exit condition", user, group, command);
                 }
             }
         }
+    }
+        return 0;
+    } catch (const std::exception& ex) {
+        std::cerr << "[LCPEX ERROR] " << ex.what() << std::endl;
+        return -999;
+}
 }
 

src/lcpex/vpty/libclpex_tty.cpp

@@ -1,4 +1,67 @@
 #include "libclpex_tty.h"
+#include <cstring>
+#include <stdexcept>
+#include <signal.h>
+#include <string>
+#include "../../logger/Logger.h"
+#include "../FileHandle.h"
+#define BUFFER_SIZE 1024
+
+// Initialize logger
+static Logger tty_logger(E_INFO, "lcpex_tty");
+std::string tty_user = tty_logger.get_user_name();
+std::string tty_group = tty_logger.get_group_name();
+
+
+void tty_signal_handler(int sig) {
+    std::string command = "tty_signal_handler";        // Command context
+    // Create an instance of Logger (you can change the log level and mask accordingly)
+    // Log the signal handling
+    if (sig == SIGCHLD) {
+        // Log that SIGCHLD was received, but leave the exit status to the parent
+        tty_logger.log_to_json_file("E_INFO", "SIGCHLD received. A child process ended.", tty_user, tty_group, command);
+    } else if (sig == SIGINT) {
+        tty_logger.log_to_json_file("E_FATAL", "SIGINT received. Gracefully terminating...", tty_user, tty_group, command);
+    } else if (sig == SIGTERM) {
+        tty_logger.log_to_json_file("E_FATAL", "SIGTERM received. Terminating...", tty_user, tty_group, command);
+    } else if (sig == SIGSEGV) {
+        tty_logger.log_to_json_file("E_FATAL", "SIGSEGV received. Possible segmentation fault.", tty_user, tty_group, command);
+    } else {
+        tty_logger.log_to_json_file("E_FATAL", "Unhandled signal received", tty_user, tty_group, command);
+    }
+}
+// Setup signal registrations
+void setup_tty_signal_handlers() {
+    struct sigaction sa;
+    sa.sa_handler = tty_signal_handler; // <-- handler function
+    sigemptyset(&sa.sa_mask);
+    sa.sa_flags = SA_RESTART | SA_NOCLDSTOP;
+    std::string command = "setup_tty_signal_handlers"; // Command context
+
+    // SIGCHLD
+    if (sigaction(SIGCHLD, &sa, nullptr) == -1) {
+        std::string error_message = "Failed to set SIGCHLD handler: " + std::string(strerror(errno));
+        tty_logger.log_to_json_file("E_FATAL", error_message, tty_user, tty_group, command); // Log to JSON file
+    }
+
+    // SIGINT
+    if (sigaction(SIGINT, &sa, nullptr) == -1) {
+        std::string error_message = "Failed to set SIGINT handler: " + std::string(strerror(errno));
+        tty_logger.log_to_json_file("E_FATAL", error_message, tty_user, tty_group, command); // Log to JSON file
+    }
+
+    // SIGTERM
+    if (sigaction(SIGTERM, &sa, nullptr) == -1) {
+        std::string error_message = "Failed to set SIGTERM handler: " + std::string(strerror(errno));
+        tty_logger.log_to_json_file("E_FATAL", error_message, tty_user, tty_group, command); // Log to JSON file
+    }
+
+    // SIGSEGV
+    if (sigaction(SIGSEGV, &sa, nullptr) == -1) {
+        std::string error_message = "Failed to set SIGSEGV handler: " + std::string(strerror(errno));
+        tty_logger.log_to_json_file("E_FATAL", error_message, tty_user, tty_group, command); // Log to JSON file
+    }
+}
 
 /**
  * @brief Safely prints a message and exits the program
@@ -11,13 +74,26 @@
  * Then, it calls `ttyResetExit()` with `ttyOrig` as its argument to reset the terminal settings.
  * Finally, the function exits the program with exit code 1.
  */
-void safe_perror( const char * msg, struct termios * ttyOrig )
+
+void set_tty_cloexec_flag(int fd)
 {
-    std::cerr << msg << std::endl;
-    ttyResetExit( ttyOrig );
-    exit(1);
+    std::string command = "set_tty_cloexec_flag";
+    if (fcntl(fd, F_SETFD, FD_CLOEXEC) == -1)
+    {
+        std::string error_message = "fcntl(F_SETFD) failed for fd " + std::to_string(fd);
+        tty_logger.log_to_json_file("E_FATAL", error_message, tty_user, tty_group, command);
+        throw std::runtime_error("fcntl(F_SETFD) failed for fd " + std::to_string(fd));
+    }
 }
 
+void safe_perror( const char * msg, struct termios * ttyOrig )
+{
+    std::string command = "safe_perror";  // Command context
+    tty_logger.log_to_json_file("E_FATAL", msg, tty_user, tty_group, command);  // Log the message before exiting
+    std::cerr << msg << std::endl;
+    ttyResetExit( ttyOrig );
+    throw std::runtime_error(std::string("TTY Error: ") + msg);
+}
 
 /**
  * @brief Executes the child process
@@ -44,12 +120,14 @@ void safe_perror( const char * msg, struct termios * ttyOrig )
  */
 void run_child_process( int fd_child_stderr_pipe[2], char * processed_command[], struct termios * ttyOrig, bool context_override, std::string context_user, std::string context_group )
 {
+    std::string command = "run_child_process_tty";  // Command context
     // redirect stderr to the write end of the stderr pipe
     // close the file descriptor STDERR_FILENO if it was previously open, then (re)open it as a copy of
     while ((dup2(fd_child_stderr_pipe[WRITE_END], STDERR_FILENO) == -1) && (errno == EINTR)) {}
 
-    // close the write end of the stderr pipe
+    // close the write end of the stderr pipe and read end to avoid leaks
     close( fd_child_stderr_pipe[WRITE_END] );
+    close( fd_child_stderr_pipe[READ_END] );
 
     // if the user has specified a context override, set the context
     if ( context_override )
@@ -59,24 +137,29 @@ void run_child_process( int fd_child_stderr_pipe[2], char * processed_command[],
             case IDENTITY_CONTEXT_ERRORS::ERROR_NONE:
                 break;
             case IDENTITY_CONTEXT_ERRORS::ERROR_NO_SUCH_USER:
-                std::cerr << "lcpex: Aborting: context user not found: " << context_user << std::endl;
-                exit(1);
+                tty_logger.log(E_FATAL, "Aborting: context user not found: " + context_user);
+                tty_logger.log_to_json_file("E_FATAL", "Context user not found: " + context_user, tty_user, tty_group, command);
+                _exit(1);
                 break;
             case IDENTITY_CONTEXT_ERRORS::ERROR_NO_SUCH_GROUP:
-                std::cerr << "lcpex: Aborting: context group not found: " << context_group << std::endl;
-                exit(1);
+                tty_logger.log(E_FATAL, "Aborting: context group not found: " + context_group);
+                tty_logger.log_to_json_file("E_FATAL", "Context group not found: " + context_group, tty_user, tty_group, command);
+                _exit(1);
                 break;
             case IDENTITY_CONTEXT_ERRORS::ERROR_SETGID_FAILED:
-                std::cerr << "lcpex: Aborting: Setting GID failed: " << context_user << "/" << context_group << std::endl;
-                exit(1);
+                tty_logger.log(E_FATAL, "Aborting: Setting GID failed: " + context_user + "/" + context_group);
+                tty_logger.log_to_json_file("E_FATAL", "Setting GID failed for: " + context_user + "/" + context_group, tty_user, tty_group, command);
+                _exit(1);
                 break;
             case IDENTITY_CONTEXT_ERRORS::ERROR_SETUID_FAILED:
-                std::cerr << "lcpex: Aborting: Setting UID failed: " << context_user << "/" << context_group << std::endl;
-                exit(1);
+                tty_logger.log(E_FATAL, "Aborting: Setting UID failed: " + context_user + "/" + context_group);
+                tty_logger.log_to_json_file("E_FATAL", "Setting UID failed for: " + context_user + "/" + context_group, tty_user, tty_group, command);
+                _exit(1);
                 break;
             default:
-                std::cerr << "lcpex: Aborting: Unknown error while setting identity context." << std::endl;
-                exit(1);
+                tty_logger.log(E_FATAL, "Aborting: Unknown error while setting identity context.");
+                tty_logger.log_to_json_file("E_FATAL", "Unknown error while setting identity context.", tty_user, tty_group, command);
+                _exit(1);
                 break;
         }
     }
@@ -84,8 +167,10 @@ void run_child_process( int fd_child_stderr_pipe[2], char * processed_command[],
     // execute the dang command, print to stdout, stderr (of parent), and dump to file for each!!!!
     // (and capture exit code in parent)
     int exit_code = execvp( processed_command[0], processed_command );
-    safe_perror("failed on execvp in child", ttyOrig );
-    exit(exit_code);
+    tty_logger.log_to_json_file("E_FATAL", "failed on execvp in child", tty_user, tty_group, command);
+    tty_logger.log(E_FATAL, "failed on execvp in child");
+    _Exit(exit_code);
+
 }
 
 // this does three things:
@@ -101,6 +186,11 @@ int exec_pty(
         std::string context_group,
         bool environment_supplied
 ) {
+    try {
+        std::string exec_command = "exec_pty";  // Command context
+        tty_logger.log_to_json_file("E_INFO", "TTY LAUNCHER: " + command, tty_user, tty_group, exec_command);
+        // Setup signal handlers
+        setup_tty_signal_handlers();
     // initialize the terminal settings obj
     struct termios ttyOrig;
 
@@ -108,20 +198,20 @@ int exec_pty(
     // before we fork the process, so that the child process will inherit the environment
     // from the parent process
     if ( environment_supplied ) {
-        clearenv();
+        //clearenv();
     }
 
     // turn our command string into something execvp can consume
     char ** processed_command = expand_env( command );
 
     if ( stdout_log_fh == NULL ) {
-        safe_perror( "Error opening STDOUT log file.  Aborting.", &ttyOrig );
-        exit( 1 );
+        tty_logger.log_to_json_file("E_FATAL", "Error opening STDOUT log file. Aborting.", tty_user, tty_group, exec_command);
+        throw std::runtime_error("Error opening STDOUT log file");
     }
 
     if ( stderr_log_fh == NULL ) {
-        safe_perror( "Error opening STDERR log file.  Aborting.", &ttyOrig );
-        exit( 1 );
+        tty_logger.log_to_json_file("E_FATAL", "Error opening STDERR log file. Aborting.", tty_user, tty_group, exec_command);
+        throw std::runtime_error("Error opening STDERR log file");
     }
 
 
@@ -129,16 +219,13 @@ int exec_pty(
     int fd_child_stderr_pipe[2];
 
     if ( pipe( fd_child_stderr_pipe ) == -1 ) {
-        safe_perror( "child stderr pipe", &ttyOrig );
-        exit( 1 );
+        std::string error_message = "Failed to create stderr pipe: " + std::string(strerror(errno));
+        tty_logger.log_to_json_file("E_FATAL", error_message, tty_user, tty_group, exec_command);
+        throw std::runtime_error("Failed to create stderr pipe");
     }
-
         // using O_CLOEXEC to ensure that the child process closes the file descriptors
-    if ( fcntl( fd_child_stderr_pipe[READ_END], F_SETFD, FD_CLOEXEC ) == -1 ) { perror("fcntl"); exit(1); }
-
-    //    // same for stderr write
-    if ( fcntl( fd_child_stderr_pipe[WRITE_END], F_SETFD, FD_CLOEXEC ) == -1 ) { perror("fcntl"); exit(1); }
-
+        set_tty_cloexec_flag( fd_child_stderr_pipe[READ_END] );
+        set_tty_cloexec_flag( fd_child_stderr_pipe[WRITE_END] );
     // status result basket for the parent process to capture the child's exit status
     int status = 616;
 
@@ -148,39 +235,52 @@ int exec_pty(
     struct winsize ws;
 
     /* Retrieve the attributes of terminal on which we are started */
-    if (tcgetattr(STDIN_FILENO, &ttyOrig) == -1)
-        safe_perror("tcgetattr", &ttyOrig);
+    if (tcgetattr(STDIN_FILENO, &ttyOrig) == -1){
+        tty_logger.log_to_json_file("E_FATAL", "tcgetattr failed", tty_user, tty_group, exec_command);
+        close(fd_child_stderr_pipe[READ_END]);      // Pipe Leaks on Error Paths
+        close(fd_child_stderr_pipe[WRITE_END]);     // Pipe Leaks on Error Paths
+        throw std::runtime_error("tcgetattr failed");
+}
     if (ioctl(STDIN_FILENO, TIOCGWINSZ, &ws) < 0)
-        safe_perror("ioctl-TIOCGWINSZ", &ttyOrig );
-
+{
+        tty_logger.log_to_json_file("E_FATAL", "ioctl-TIOCGWINSZ failed", tty_user, tty_group, exec_command);
+        close(fd_child_stderr_pipe[READ_END]);      // Pipe Leaks on Error Paths
+        close(fd_child_stderr_pipe[WRITE_END]);     // Pipe Leaks on Error Paths
+        throw std::runtime_error("ioctl-TIOCGWINSZ failed");
+}
     pid_t pid = ptyFork( &masterFd, slaveName, MAX_SNAME, &ttyOrig, &ws );
-
     switch( pid ) {
         case -1:
         {
             // fork failed
-            safe_perror("ptyfork failure", &ttyOrig );
-            exit(1);
+            tty_logger.log(E_FATAL, "ptyfork failure: " + std::string(strerror(errno)));
+            tty_logger.log_to_json_file("E_FATAL", "ptyfork failure: " + std::string(strerror(errno)), tty_user, tty_group, exec_command);
+            close(fd_child_stderr_pipe[READ_END]);      // Pipe Leaks on Error Paths
+            close(fd_child_stderr_pipe[WRITE_END]);     // Pipe Leaks on Error Paths
+            throw std::runtime_error("ptyfork() failed: " + std::string(strerror(errno)));
         }
-
         case 0:
         {
             // child process
             run_child_process( fd_child_stderr_pipe, processed_command, &ttyOrig, context_override, context_user, context_group );
         }
-
         default:
         {
             // parent process
             // start ptyfork integration
             ttySetRaw(STDIN_FILENO, &ttyOrig);
 
+            // RAII guards for file descriptors
+            FdGuard stderr_read_guard(fd_child_stderr_pipe[READ_END]);
+            FdGuard stderr_write_guard(fd_child_stderr_pipe[WRITE_END]);
+            FdGuard master_fd_guard(masterFd);
 
-            // The parent process has no need to access the entrance to the pipe
-            close(fd_child_stderr_pipe[WRITE_END]);
-
+            // We don't need WRITE_END in parent, close it now
+            stderr_write_guard.reset();  // Closes and sets fd to -1
             // attempt to write to stdout,stderr from child as well as to write each to file
-            char buf[BUFFER_SIZE];
+            char buf[BUFFER_SIZE] = {0};
+            std::strncpy(buf, command.c_str(), BUFFER_SIZE - 1);
+            buf[BUFFER_SIZE - 1] = '\0';
 
             // contains the byte count of the last read from the pipe
             ssize_t byte_count;
@@ -195,11 +295,11 @@ int exec_pty(
             watched_fds[0].events = POLLIN;
 
             // child pty to parent (stdout)
-            watched_fds[1].fd = masterFd;
+            watched_fds[1].fd =  master_fd_guard.get();
             watched_fds[1].events = POLLIN;
 
             // child stderr to parent
-            watched_fds[2].fd = fd_child_stderr_pipe[READ_END];
+            watched_fds[2].fd = stderr_read_guard.get();
             watched_fds[2].events = POLLIN;
 
             // number of files poll() reports as ready
@@ -211,11 +311,18 @@ int exec_pty(
             // loop until we've read all the data from the child process
             while ( ! break_out ) {
                 num_files_readable = poll(watched_fds, sizeof(watched_fds) / sizeof(watched_fds[0]), -1);
+                // after the poll() call, add a check to see if both pipes are closed
+                if (!(watched_fds[1].events & POLLIN) &&
+                    !(watched_fds[2].events & POLLIN)) {
+                    break_out = true;
+                }
 
                 if (num_files_readable == -1) {
                     // error occurred in poll()
-                    safe_perror("poll", &ttyOrig );
-                    exit(1);
+                    tty_logger.log(E_FATAL, "poll() failed: " + std::string(strerror(errno)));
+                    tty_logger.log_to_json_file("E_FATAL", "poll() failed", tty_user, tty_group, exec_command);
+                    ttyResetExit( &ttyOrig);
+                    throw std::runtime_error("poll() failed");
                 }
 
                 if (num_files_readable == 0) {
@@ -230,9 +337,15 @@ int exec_pty(
                         byte_count = read(watched_fds[this_fd].fd, buf, BUFFER_SIZE);
 
                         if (byte_count == -1) {
+                            if (errno == EAGAIN) { continue; } else {
                                 // error reading from pipe
-                            safe_perror("read", &ttyOrig );
+                                tty_logger.log(E_FATAL, "Error while reading: " + std::string(strerror(errno)));
+                                tty_logger.log_to_json_file("E_FATAL", "Error while reading from pipe", tty_user, tty_group, exec_command);
+                                ttyResetExit( &ttyOrig);
+                                stderr_read_guard.reset(-1);
+                                master_fd_guard.reset(-1);
                                 exit(EXIT_FAILURE);
+                            }
                         } else if (byte_count == 0) {
                             // reached EOF on one of the streams but not a HUP
                             // we've read all we can this cycle, so go to the next fd in the for loop
@@ -240,40 +353,89 @@ int exec_pty(
                         } else {
                             // byte count was sane
                             // write to stdout,stderr
+
                             if (this_fd == 0) {
                                 // parent stdin received, write to child pty (stdin)
-                                write(masterFd, buf, byte_count);
+                                write_all(masterFd, buf, byte_count);
                             } else if (this_fd == 1 ) {
                                 // child pty sent some stuff, write to parent stdout and log
-                                write(stdout_log_fh->_fileno, buf, byte_count);
-                                write(STDOUT_FILENO, buf, byte_count);
+                                write_all(stdout_log_fh->_fileno, buf, byte_count);
+                                write_all(STDOUT_FILENO, buf, byte_count);
                             } else if ( this_fd == 2 ){
                                 //the child's stderr pipe sent some stuff, write to parent stderr and log
-                                write(stderr_log_fh->_fileno, buf, byte_count);
-                                write(STDERR_FILENO, buf, byte_count);
+                                write_all(stderr_log_fh->_fileno, buf, byte_count);
+                                write_all(STDERR_FILENO, buf, byte_count);
                             } else {
                                 // this should never happen
-                                perror("Logic error!");
+                                tty_logger.log(E_FATAL, "Logic error: unexpected pipe index.");
                                 exit(EXIT_FAILURE);
                             }
                         }
                     }
                     if (watched_fds[this_fd].revents & POLLERR) {
-                        close(watched_fds[this_fd].fd);
-                        //break_out = true;
-                        continue;
+                        if (this_fd == 1) {
+                            master_fd_guard.reset(-1);
+                        } else if (this_fd == 2) {
+                            stderr_read_guard.reset(-1);
                         }
+                        //close(watched_fds[this_fd].fd);
+                        break_out = true;
+                        //continue;
+                    }
+//                    if (watched_fds[this_fd].revents & POLLHUP) {
+//                        // this pipe has hung up
+//                        close(watched_fds[this_fd].fd);
+//                        break_out = true;
+//                        break;
+//                    }
                     if (watched_fds[this_fd].revents & POLLHUP) {
                         // this pipe has hung up
-                        close(watched_fds[this_fd].fd);
-                        break_out = true;
-                        break;
+                        // don't close the file descriptor yet, there might still be data to read
+                        // instead, remove the POLLIN event to avoid getting a POLLHUP event in the next poll() call
+                        watched_fds[this_fd].events &= ~POLLIN;
                     }
                 }
             }
             // wait for child to exit, capture status
             waitpid(pid, &status, 0);
 
+            while ((byte_count = read(master_fd_guard.get(), buf, BUFFER_SIZE)) > 0) {
+                write_all(stdout_log_fh->_fileno, buf, byte_count);
+                write_all(STDOUT_FILENO, buf, byte_count);
+            }
+
+            while ((byte_count = read(stderr_read_guard.get(), buf, BUFFER_SIZE)) > 0) {
+                write_all(stderr_log_fh->_fileno, buf, byte_count);
+                write_all(STDERR_FILENO, buf, byte_count);
+            }
+            // Handle child process status with proper signal handling
+            pid_t child_pid = waitpid(-1, &status, WNOHANG);  // Non-blocking wait for child process
+            if (child_pid > 0) {  // If a child process has terminated
+                // Check if the child process exited normally
+                if (WIFEXITED(status)) {
+                    int exit_code = WEXITSTATUS(status);
+                    tty_logger.log(E_INFO, "Child exited with status " + std::to_string(exit_code));
+                    tty_logger.log_to_json_file("E_INFO", "Child exited with status " + std::to_string(exit_code), tty_user, tty_group, exec_command);
+                    ttyResetExit( &ttyOrig);
+                    return exit_code;
+                }
+                // Check if the child process was terminated by a signal
+                else if (WIFSIGNALED(status)) {
+                    int signal_number = WTERMSIG(status);
+                    tty_logger.log(E_FATAL, "Process terminated by signal: " + std::to_string(signal_number));
+                    tty_logger.log_to_json_file("E_FATAL", "Process terminated by signal: " + std::to_string(signal_number), tty_user, tty_group, exec_command);
+                    // Reset signal handler to default before exiting
+                    signal(signal_number, SIG_DFL);
+                    ttyResetExit( &ttyOrig);
+                    return 128 + signal_number;  // POSIX exit code format
+                }
+                // Handle unexpected exit conditions
+                else {
+                    tty_logger.log(E_WARN, "Unknown child exit condition.");
+                    tty_logger.log_to_json_file("E_WARN", "Unknown child exit condition", tty_user, tty_group, exec_command);
+                }
+            }
+
             ttyResetExit( &ttyOrig);
             if WIFEXITED(status) {
                 return WEXITSTATUS(status);
@@ -282,5 +444,9 @@ int exec_pty(
             }
         }
     }
+        return 0;
+    } catch (const std::exception& ex) {
+        std::cerr << "[LCPEX TTY ERROR] " << ex.what() << std::endl;
+        return -999;
+    }
 }
-

src/logger/Logger.cpp

@@ -19,6 +19,13 @@
 
 */
 #include "Logger.h"
+#include <string>
+#include <cstdio>
+#include <cstring>
+#include <ctime>
+#include <unistd.h>  // For FdGuard
+#include <fcntl.h>  // For O_RDONLY, O_WRONLY, open()
+#include "../lcpex/FileHandle.h"   // Include the FdGuard header
 
 Logger::Logger( int LOG_LEVEL, std::string mask )
 {
@@ -26,6 +33,11 @@ Logger::Logger( int LOG_LEVEL, std::string mask )
     this->mask = mask;
 }
 
+// Destructor added in the update
+Logger::~Logger() {
+
+}
+
 void Logger::log( int LOG_LEVEL, std::string msg )
 {
     std::string ERR = "XXXX";
@@ -42,7 +54,7 @@ void Logger::log( int LOG_LEVEL, std::string msg )
 
         std::string s_msg = "[" + ERR + "] " + msg;
 
-        if ( LOG_LEVEL == E_FATAL | LOG_LEVEL == E_WARN )
+        if ( LOG_LEVEL == E_FATAL || LOG_LEVEL == E_WARN )
         {
             std::cerr << "[" << get_8601() << "] [" << ERR << "] " << "[" << this->mask << "] " << msg.c_str() << std::endl;
         } else {
@@ -53,6 +65,140 @@ void Logger::log( int LOG_LEVEL, std::string msg )
 
 void Logger::log_task( int LOG_LEVEL, std::string task_name, std::string msg )
 {
-    std::string final_msg = "[" + task_name + "] " + msg;
-    this->log( LOG_LEVEL, final_msg );
+     // Added memory management from the updated file
+
+    size_t task_msg_len = task_name.length() + msg.length() + 4;
+    char* task_msg = (char*)malloc(task_msg_len);
+
+    if (task_msg) {
+        snprintf(task_msg, task_msg_len, "[%s] %s", task_name.c_str(), msg.c_str());
+        log(LOG_LEVEL, task_msg);
+        free(task_msg);
     }
+}
+
+// JSON logging method
+void Logger::create_json_log_entry(char* buffer, size_t buffer_size,
+                                  const char* log_level, const char* message,
+                                  const char* user, const char* group,
+                                  const char* command)
+{
+    std::string timestamp = get_current_timestamp();
+    snprintf(buffer, buffer_size,
+        "{\n"
+        "  \"timestamp\": \"%s\",\n"
+        "  \"log_level\": \"%s\",\n"
+        "  \"message\": \"%s\",\n"
+        "  \"context\": {\n"
+        "    \"user\": \"%s\",\n"
+        "    \"group\": \"%s\",\n"
+        "    \"command\": \"%s\"\n"
+        "  }\n"
+        "}",
+        timestamp.c_str(), log_level, message, user, group, command);
+}
+
+// Add methods for user/group name and timestamp
+std::string Logger::get_user_name()
+{
+    struct passwd* pw = getpwuid(getuid());
+    if (pw) {
+        return std::string(pw->pw_name);
+    }
+    return "unknown";
+}
+
+std::string Logger::get_group_name()
+{
+    struct group* grp = getgrgid(getgid());
+    if (grp) {
+        return std::string(grp->gr_name);
+    }
+    return "unknown";
+}
+
+std::string Logger::get_current_timestamp()
+{
+    time_t now = time(NULL);
+    struct tm* timeinfo = localtime(&now);
+    char buffer[64];
+    strftime(buffer, sizeof(buffer), "%Y-%m-%d_%H:%M:%S", timeinfo);
+    return std::string(buffer);
+}
+
+//Log to JSON file
+void Logger::log_to_json_file(const std::string& log_level, const std::string& message,
+                               const std::string& user, const std::string& group,
+                               const std::string& command, bool log_to_console)
+{
+    // Log to console if requested
+    const char* log_level_str = "UNKNOWN";
+    if (log_level == "E_INFO") log_level_str = "INFO";
+    else if (log_level == "E_FATAL") log_level_str = "FATAL";
+    else if (log_level == "E_WARN") log_level_str = "WARN";
+    else if (log_level == "E_DEBUG") log_level_str = "DEBUG";
+
+    if (log_to_console && (log_level_str == "INFO" || log_level_str == "FATAL")) {
+        std::string timestamp = get_current_timestamp();
+        printf("[%s] [%s] [%s] %s\n", timestamp.c_str(), log_level_str, this->mask.c_str(), message.c_str());
+        fflush(stdout);
+    }
+
+    // 2. Create JSON log entry
+    char json_log[2048];
+    create_json_log_entry(json_log, sizeof(json_log), log_level_str, message.c_str(), user.c_str(), group.c_str(), command.c_str());
+
+    // 3. Generate filename
+    std::string timestamp = get_current_timestamp();
+    std::string filename = "log_" + timestamp + ".json";
+
+    // 4. Use FdGuard for file handling (to manage file opening and closing)
+    FdGuard check_file(open(filename.c_str(), O_RDONLY));
+    bool file_empty = true;
+
+    if (check_file.get() != -1) {
+        off_t file_size = lseek(check_file.get(), 0, SEEK_END);
+        file_empty = (file_size == 0);
+    }
+
+    if (file_empty) {
+        // First entry - create new JSON array
+        FdGuard json_file(open(filename.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0644));
+        if (json_file.get() != -1) {
+            dprintf(json_file.get(), "[\n  %s\n]\n", json_log);
+        } else {
+            fprintf(stderr, "Failed to open log file for writing: %s\n", filename.c_str());
+        }
+    } else {
+        // Subsequent entries - handle JSON array properly
+        FdGuard read_file(open(filename.c_str(), O_RDONLY));
+        if (read_file.get() == -1) {
+            fprintf(stderr, "Failed to open log file for reading: %s\n", filename.c_str());
+            return;
+        }
+
+        off_t file_size = lseek(read_file.get(), 0, SEEK_END);
+        lseek(read_file.get(), 0, SEEK_SET);
+        char* content = (char*)malloc(file_size + 1);
+        if (!content) {
+            fprintf(stderr, "Failed to allocate memory for file content\n");
+            return;
+        }
+        read(read_file.get(), content, file_size);
+        content[file_size] = '\0';
+        // Find and remove the last ']'
+        char* last_bracket = strrchr(content, ']');
+        if (last_bracket) {
+            *last_bracket = '\0';
+        }
+        FdGuard write_file(open(filename.c_str(), O_WRONLY | O_TRUNC, 0644));
+        if (write_file.get() != -1) {
+            dprintf(write_file.get(), "%s,\n  %s\n]\n", content, json_log);
+        } else {
+            fprintf(stderr, "Failed to open log file for writing: %s\n", filename.c_str());
+        }
+        free(content);
+    }
+}
+
+} // namespace lcpex

src/logger/Logger.h

@@ -24,8 +24,14 @@
 
 #include <string>
 #include <iostream>
-#include <iomanip>
-#include <sstream>
+#include <fstream>
+#include <fcntl.h>  // For O_RDONLY, O_WRONLY, open()
+#include <ctime>
+#include <pwd.h>
+#include <grp.h>
+#include <unistd.h>
+#include <memory>
+#include <cstdarg>  // for va_list in FileGuard::printf
 #include "../misc/helpers.h"
 
 enum L_LVL {
@@ -37,15 +43,28 @@ enum L_LVL {
 
 class Logger {
     public:
+    // Constructor and Destructor
     Logger(int LOG_LEVEL, std::string mask);
+    ~Logger();  // Added Destructor
+    // Logging methods
     void log(int LOG_LEVEL, std::string msg);
     void log_task(int LOG_LEVEL, std::string task_name, std::string msg);
+    void log_to_json_file(const std::string& log_level, const std::string& message,
+                           const std::string& user, const std::string& group,
+                           const std::string& command, bool log_to_console = true);
+    // Helper methods
+    std::string get_current_timestamp();
+    std::string get_user_name();
+    std::string get_group_name();
 
     private:
         int LOG_LEVEL;
         std::string mask;
+    // Internal helper methods
+    void create_json_log_entry(char* buffer, size_t buffer_size,
+                                const char* log_level, const char* message,
+                                const char* user, const char* group,
+                                const char* command);
 };
 
-
-
 #endif //REX_LOGGER_H

src/misc/helpers.cpp

@@ -96,19 +96,57 @@ std::string get_8601()
  * @brief Interpolates the environment variables in the input text
  *
  * This function takes a string reference as input and replaces all occurrences of
- * environment variables in the format `${VAR_NAME}` with their corresponding values.
+ * environment variables in the format `${VAR_NAME}` or `$VAR_NAME` with their corresponding values.
  * If an environment variable is not set, it is replaced with an empty string.
  *
  * @param text The input text to be processed
  */
+//void interpolate( std::string & text )
+//{
+//    static std::regex env1( "\\$\\{([^}]+)\\}" );
+//    static std::regex env2( "\\$([^/]+)" ); // matches $VAR_NAME until a / is found
+//    std::smatch match;
+//    while ( std::regex_search( text, match, env1 ) || std::regex_search( text, match, env2 ) )
+//    {
+//        const char * s = getenv( match[1].str().c_str() );
+//        const std::string var( s == NULL ? "" : s );
+//        text.replace( match[0].first, match[0].second, var );
+//    }
+//}
 void interpolate( std::string & text )
 {
-    static std::regex env( "\\$\\{([^}]+)\\}" );
+    std::regex env1( "\\$\\{([^}]+)\\}" );
+    std::regex env2( "\\$([^/]+)" ); // matches $VAR_NAME until a / is found
     std::smatch match;
-    while ( std::regex_search( text, match, env ) )
+    while ( std::regex_search( text, match, env1 ) || std::regex_search( text, match, env2 ) )
     {
         const char * s = getenv( match[1].str().c_str() );
         const std::string var( s == NULL ? "" : s );
         text.replace( match[0].first, match[0].second, var );
     }
 }
+
+/**
+ * @brief Get the absolute path from a relative path
+ *
+ * This function takes a relative path and returns the corresponding absolute path.
+ * The absolute path is obtained by calling the `realpath` function.
+ * If the `realpath` function returns a null pointer, an error message is printed to the standard error stream and an empty string is returned.
+ *
+ * @param relative_path The relative path to be converted to an absolute path
+ *
+ * @return The absolute path corresponding to the relative path
+ */
+std::string get_absolute_path(const std::string &relative_path)
+{
+    char resolved_path[1024];
+    memset(resolved_path, 0, sizeof(resolved_path));
+
+    if( realpath( relative_path.c_str(), resolved_path) == nullptr ) {
+        std::cerr << "Error resolving path: " << relative_path << std::endl;
+        return "";
+    }
+
+    return std::string(resolved_path);
+}
+

src/misc/helpers.h

@@ -23,6 +23,9 @@
 #define REX_HELPERS_H
 
 #include <string>
+#include <cstring>
+#include <string.h>
+
 #include <sys/stat.h>
 #include <sys/param.h>
 #include <unistd.h>
@@ -51,4 +54,17 @@ std::string get_8601();
 
 const char * command2args( std::string input_string );
 
+/**
+ * @brief Get the absolute path from a relative path
+ *
+ * This function takes a relative path and returns the corresponding absolute path.
+ * The absolute path is obtained by calling the `realpath` function.
+ * If the `realpath` function returns a null pointer, an error message is printed to the standard error stream and an empty string is returned.
+ *
+ * @param relative_path The relative path to be converted to an absolute path
+ *
+ * @return The absolute path corresponding to the relative path
+ */
+std::string get_absolute_path(const std::string &relative_path);
+
 #endif //REX_HELPERS_H

src/plan/Task.cpp

@@ -354,8 +354,19 @@ void Task::execute( Conf * configuration )
     std::string environment_file = this->definition.get_environment_file();
     std::string logs_root = configuration->get_logs_path();
 
+    interpolate(task_name);
     this->slog.log_task( E_DEBUG, task_name, "Using unit definition: \"" + task_name + "\"." );
 
+    interpolate(command);
+    interpolate(shell_name);
+    interpolate(user);
+    interpolate(group);
+    interpolate(environment_file);
+    interpolate(new_working_dir);
+    interpolate(rectifier);
+    interpolate(logs_root);
+
+
     // sanitize all path inputs from unit definition to be either absolute paths or relative to
     // project_root