/*
	 * Copyright 2017-2023 the Pacemaker project contributors
	 *
	 * The version control history for this file may have further details.
	 *
	 * This source code is licensed under the GNU Lesser General Public License
	 * version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
	 */
	
	#include <crm_internal.h>
	
	#include <stdio.h>
	#include <ctype.h>
	#include <stdlib.h>
	#include <signal.h>
	#include <unistd.h>
	#include <sys/types.h>
	#include <sys/wait.h>
	
	#include <crm/crm.h>
	#include "pacemaker-execd.h"
	
	static pid_t main_pid = 0;
	
	static void
	sigdone(void)
	{
	    exit(CRM_EX_OK);
	}
	
	static void
	sigreap(void)
	{
	    pid_t pid = 0;
	    int status;
	
	    do {
	        /*
	         * Opinions seem to differ as to what to put here:
	         *  -1, any child process
	         *  0,  any child process whose process group ID is equal to that of the calling process
	         */
	        pid = waitpid(-1, &status, WNOHANG);
	        if (pid == main_pid) {
	            /* Exit when pacemaker-remote exits and use the same return code */
	            if (WIFEXITED(status)) {
	                exit(WEXITSTATUS(status));
	            }
	            exit(CRM_EX_ERROR);
	        }
	    } while (pid > 0);
	}
	
	static struct {
	    int sig;
	    void (*handler)(void);
	} sigmap[] = {
	    { SIGCHLD, sigreap },
	    { SIGINT,  sigdone },
	};
	
	/*!
	 * \internal
	 * \brief Check a line of text for a valid environment variable name
	 *
	 * \param[in]  line  Text to check
	 * \param[out] first  First character of valid name if found, NULL otherwise
	 * \param[out] last   Last character of valid name if found, NULL otherwise
	 *
	 * \return TRUE if valid name found, FALSE otherwise
	 * \note It's reasonable to impose limitations on environment variable names
	 *       beyond what C or setenv() does: We only allow names that contain only
	 *       [a-zA-Z0-9_] characters and do not start with a digit.
	 */
	static bool
	find_env_var_name(char *line, char **first, char **last)
	{
	    // Skip leading whitespace

	    *first = line;

	    while (isspace(**first)) {
	        ++*first;

	    }
	

	    if (isalpha(**first) || (**first == '_')) { // Valid first character
	        *last = *first;

	        while (isalnum(*(*last + 1)) || (*(*last + 1) == '_')) {
	            ++*last;
	        }
	        return TRUE;
	    }
	
	    *first = *last = NULL;
	    return FALSE;
	}
	
	static void
	load_env_vars(const char *filename)
	{
	    /* We haven't forked or initialized logging yet, so don't leave any file
	     * descriptors open, and don't log -- silently ignore errors.
	     */
	    FILE *fp = fopen(filename, "r");
	

	    if (fp != NULL) {
	        char line[LINE_MAX] = { '\0', };
	

	        while (fgets(line, LINE_MAX, fp) != NULL) {
	            char *name = NULL;
	            char *end = NULL;
	            char *value = NULL;
	            char *quote = NULL;
	
	            // Look for valid name immediately followed by equals sign

	            if (find_env_var_name(line, &name, &end) && (*++end == '=')) {
	
	                // Null-terminate name, and advance beyond equals sign
	                *end++ = '\0';
	
	                // Check whether value is quoted

	                if ((*end == '\'') || (*end == '"')) {
	                    quote = end++;
	                }
	                value = end;
	

	                if (quote) {
	                    /* Value is remaining characters up to next non-backslashed
	                     * matching quote character.
	                     */

	                    while (((*end != *quote) || (*(end - 1) == '\\'))
	                           && (*end != '\0')) {
	                        end++;

	                    }

	                    if (*end == *quote) {
	                        // Null-terminate value, and advance beyond close quote
	                        *end++ = '\0';

	                    } else {
	                        // Matching closing quote wasn't found
	                        value = NULL;
	                    }
	

	                } else {
	                    /* Value is remaining characters up to next non-backslashed
	                     * whitespace.
	                     */
	                    while ((!isspace(*end) || (*(end - 1) == '\\'))
	                           && (*end != '\0')) {
	                        ++end;
	                    }
	
	                    if (end == (line + LINE_MAX - 1)) {
	                        // Line was too long
	                        value = NULL;
	                    }
	                    // Do NOT null-terminate value (yet)
	                }
	
	                /* We have a valid name and value, and end is now the character
	                 * after the closing quote or the first whitespace after the
	                 * unquoted value. Make sure the rest of the line is just
	                 * whitespace or a comment.
	                 */

	                if (value) {
	                    char *value_end = end;
	

	                    while (isspace(*end) && (*end != '\n')) {
	                        ++end;
	                    }

	                    if ((*end == '\n') || (*end == '#')) {

	                        if (quote == NULL) {
	                            // Now we can null-terminate an unquoted value
	                            *value_end = '\0';
	                        }
	
	                        // Don't overwrite (bundle options take precedence)

	                        setenv(name, value, 0);
	
	                    } else {
	                        value = NULL;
	                    }
	                }
	            }
	
	            if ((value == NULL) && (strchr(line, '\n') == NULL)) {
	                // Eat remainder of line beyond LINE_MAX
	                if (fscanf(fp, "%*[^\n]\n") == EOF) {
	                    value = NULL; // Don't care, make compiler happy
	                }
	            }
	        }
	        fclose(fp);
	    }
	}
	
	void
	remoted_spawn_pidone(int argc, char **argv, char **envp)
	{
	    sigset_t set;
	
	    /* This environment variable exists for two purposes:
	     * - For testing, setting it to "full" enables full PID 1 behavior even
	     *   when PID is not 1
	     * - Setting to "vars" enables just the loading of environment variables
	     *   from /etc/pacemaker/pcmk-init.env, which could be useful for testing or
	     *   containers with a custom PID 1 script that launches pacemaker-remoted.
	     */
	    const char *pid1 = "default";
	
	    if (getpid() != 1) {
	        pid1 = pcmk__env_option(PCMK__ENV_REMOTE_PID1);
	        if (!pcmk__str_any_of(pid1, "full", "vars", NULL)) {
	            // Default, unset, or invalid
	            return;
	        }
	    }
	
	    /* When a container is launched, it may be given specific environment
	     * variables, which for Pacemaker bundles are given in the bundle
	     * configuration. However, that does not allow for host-specific values.
	     * To allow for that, look for a special file containing a shell-like syntax
	     * of name/value pairs, and export those into the environment.
	     */
	    load_env_vars("/etc/pacemaker/pcmk-init.env");
	
	    if (strcmp(pid1, "vars") == 0) {
	        return;
	    }
	
	    /* Containers can be expected to have /var/log, but they may not have
	     * /var/log/pacemaker, so use a different default if no value has been
	     * explicitly configured in the container's environment.
	     */
	    if (pcmk__env_option(PCMK__ENV_LOGFILE) == NULL) {
	        pcmk__set_env_option(PCMK__ENV_LOGFILE, "/var/log/pcmk-init.log", true);
	    }
	
	    sigfillset(&set);
	    sigprocmask(SIG_BLOCK, &set, 0);
	
	    main_pid = fork();
	    switch (main_pid) {
	        case 0:
	            sigprocmask(SIG_UNBLOCK, &set, NULL);
	            setsid();
	            setpgid(0, 0);
	
	            // Child remains as pacemaker-remoted
	            return;
	        case -1:
	            crm_err("fork failed: %s", pcmk_rc_str(errno));
	    }
	
	    /* Parent becomes the reaper of zombie processes */
	    /* Safe to initialize logging now if needed */
	
	#  ifdef HAVE_PROGNAME
	    /* Differentiate ourselves in the 'ps' output */
	    {
	        char *p;
	        int i, maxlen;
	        char *LastArgv = NULL;
	        const char *name = "pcmk-init";
	
	        for (i = 0; i < argc; i++) {
	            if (!i || (LastArgv + 1 == argv[i]))
	                LastArgv = argv[i] + strlen(argv[i]);
	        }
	
	        for (i = 0; envp[i] != NULL; i++) {
	            if ((LastArgv + 1) == envp[i]) {
	                LastArgv = envp[i] + strlen(envp[i]);
	            }
	        }
	
	        maxlen = (LastArgv - argv[0]) - 2;
	
	        i = strlen(name);
	
	        /* We can overwrite individual argv[] arguments */
	        snprintf(argv[0], maxlen, "%s", name);
	
	        /* Now zero out everything else */
	        p = &argv[0][i];
	        while (p < LastArgv) {
	            *p++ = '\0';
	        }
	        argv[1] = NULL;
	    }
	#  endif // HAVE_PROGNAME
	
	    while (1) {
	        int sig;
	        size_t i;
	
	        sigwait(&set, &sig);
	        for (i = 0; i < PCMK__NELEM(sigmap); i++) {
	            if (sigmap[i].sig == sig) {
	                sigmap[i].handler();
	                break;
	            }
	        }
	    }
	}