/* Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/*
 * Copyright 2014 Cloud Linux Zug GmbH
 *
 * Licensed under CLOUD LINUX LICENSE AGREEMENT
 * http://cloudlinux.com/docs/LICENSE.TXT
 *
 * The part the support library for lsapi & proxy_lsapi Apache modules
 * author Alexander Demeshko <ademeshko@cloudlinux.com>
 *
 */
 
#include <apr.h>
#include <ap_config.h>
#include "sulsphp.h"

#include <sys/param.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <string.h>
#include <time.h>
#if APR_HAVE_UNISTD_H
#include <unistd.h>
#endif

#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#if APR_HAVE_FCNTL_H
#include <fcntl.h>
#endif

#ifdef HAVE_PWD_H
#include <pwd.h>
#endif

#ifdef HAVE_GRP_H
#include <grp.h>
#endif

#include <errno.h>
#include <dlfcn.h>
#include <signal.h>

#include "sha1.h"

#if defined(PATH_MAX)
#define AP_MAXPATH PATH_MAX
#elif defined(MAXPATHLEN)
#define AP_MAXPATH MAXPATHLEN
#else
#define AP_MAXPATH 8192
#endif

#define AP_ENVBUF 256

#define AP_SULSPHP_UMASK 022

#define AP_SECRET_SIZE 16
#define AP_SALT_SIZE 16

extern char **environ;
static FILE *log = NULL;

static const char *const safe_env_lst[] =
{
    /* variable name starts with */
    "LSAPI_",
    "PHP_LSAPI_",
    NULL
};

static void log_err(const char *fmt,...) 
    __attribute__((format(printf,1,2)));
static void log_no_err(const char *fmt,...)  
    __attribute__((format(printf,1,2)));
static void err_output(int is_error, const char *fmt, va_list ap) 
    __attribute__((format(printf,2,0)));

static void err_output(int is_error, const char *fmt, va_list ap)
{
#ifdef AP_LOG_EXEC
    time_t timevar;
    struct tm *lt;

    if (!log) {
#if defined(_LARGEFILE64_SOURCE) && HAVE_FOPEN64
        if ((log = fopen64(AP_LOG_EXEC, "a")) == NULL) {
#else
        if ((log = fopen(AP_LOG_EXEC, "a")) == NULL) {
#endif
            fprintf(stderr, AP_PROGRAM_NAME " failure: could not open log file\n");
            perror("fopen");
            exit(1);
        }
    }

    if (is_error) {
        fprintf(stderr, AP_PROGRAM_NAME " policy violation: see its log for more "
                        "details\n");
    }

    time(&timevar);
    lt = localtime(&timevar);

    fprintf(log, "[%d-%.2d-%.2d %.2d:%.2d:%.2d]: ",
            lt->tm_year + 1900, lt->tm_mon + 1, lt->tm_mday,
            lt->tm_hour, lt->tm_min, lt->tm_sec);

    vfprintf(log, fmt, ap);

    fflush(log);
#endif /* AP_LOG_EXEC */
    return;
}

static void log_err(const char *fmt,...)
{
#ifdef AP_LOG_EXEC
    va_list ap;

    va_start(ap, fmt);
    err_output(1, fmt, ap); /* 1 == is_error */
    va_end(ap);
#endif /* AP_LOG_EXEC */
    return;
}

static void log_no_err(const char *fmt,...)
{
#ifdef AP_LOG_EXEC
    va_list ap;

    va_start(ap, fmt);
    err_output(0, fmt, ap); /* 0 == !is_error */
    va_end(ap);
#endif /* AP_LOG_EXEC */
    return;
}

#define AP_SIGN_SIZE (AP_SALT_SIZE + SHA1_DIGEST_SIZE)

static int verify_sign(const char *encoded_sign, 
                       const unsigned char secret[AP_SECRET_SIZE],
                       const unsigned char *signed_data, size_t data_len) {
    unsigned char sign[AP_SIGN_SIZE];
    unsigned char digest[SHA1_DIGEST_SIZE];
    
    /* Wrong length of encoded sign */
    if(strlen(encoded_sign) != 2 * AP_SIGN_SIZE) {
        return -1;
    }
    
    /* Decode the sign */
    for(int i = 0; i < AP_SIGN_SIZE; i++) {
        switch(encoded_sign[2*i]) {
        case '0':
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
        case '8':
        case '9':
            sign[i] = (encoded_sign[2*i] - '0') * 16;
            break;
            
        case 'a':
        case 'A':
            sign[i] = 0xa0;
            break;

        case 'b':
        case 'B':
            sign[i] = 0xb0;
            break;

        case 'c':
        case 'C':
            sign[i] = 0xc0;
            break;

        case 'd':
        case 'D':
            sign[i] = 0xd0;
            break;

        case 'e':
        case 'E':
            sign[i] = 0xe0;
            break;

        case 'f':
        case 'F':
            sign[i] = 0xf0;
            break;
            
        default:
            return -1;
        } // switch(encoded_sign[2*i])

        switch(encoded_sign[2*i+1]) {
        case '0':
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
        case '8':
        case '9':
            sign[i] += encoded_sign[2*i+1] - '0';
            break;
            
        case 'a':
        case 'A':
            sign[i] += 0x0a;
            break;

        case 'b':
        case 'B':
            sign[i] += 0x0b;
            break;

        case 'c':
        case 'C':
            sign[i] += 0x0c;
            break;

        case 'd':
        case 'D':
            sign[i] += 0x0d;
            break;

        case 'e':
        case 'E':
            sign[i] += 0x0e;
            break;

        case 'f':
        case 'F':
            sign[i] += 0x0f;
            break;
            
        default:
            return -1;
        } // switch(encoded_sign[2*i+1])

    } // for(int i = 0; i < AP_SIGN_SIZE; i++)
    
    SHA1_CTX sha1_context;
    SHA1_Init(&sha1_context);
    SHA1_Update(&sha1_context, sign, AP_SALT_SIZE);
    SHA1_Update(&sha1_context, secret, AP_SECRET_SIZE);
    SHA1_Update(&sha1_context, signed_data, data_len);
    SHA1_Final(&sha1_context, digest);
    if(memcmp(sign + AP_SALT_SIZE, digest, SHA1_DIGEST_SIZE) ) {
        return -1;
    }

    return 0;
}

static void read_secret(unsigned char secret[AP_SECRET_SIZE])
{
    struct stat dir_info;      /* directory info holder     */
    struct stat secret_info;   /* secret file info holder   */
    const char *dir_name;
    const char *secret_name;
    
    /*
     * Stat /etc and verify it is a directory, or error out.
     */
    dir_name = "/etc";
    if (((lstat(dir_name, &dir_info)) != 0) || !(S_ISDIR(dir_info.st_mode))) {
        log_err("cannot stat directory: (%s)\n", dir_name);
        exit(301);
    }
    
    if ((dir_info.st_uid != 0) || (dir_info.st_gid != 0)) {
        log_err("directory owned not by root: (%s)\n", dir_name);
        exit(302);
    }
    
    if ((dir_info.st_mode & S_IWOTH) || (dir_info.st_mode & S_IWGRP)) {
        log_err("directory is writable by others: (%s)\n", dir_name);
        exit(303);
    }

    /*
     * Stat /etc/sysconfig and verify it is a directory, or error out.
     */
    dir_name = "/etc/sysconfig";
    if (((lstat(dir_name, &dir_info)) != 0) || !(S_ISDIR(dir_info.st_mode))) {
        log_err("cannot stat directory: (%s)\n", dir_name);
        exit(304);
    }
    
    if ((dir_info.st_uid != 0) || (dir_info.st_gid != 0)) {
        log_err("directory owned not by root: (%s)\n", dir_name);
        exit(305);
    }
    
    if ((dir_info.st_mode & S_IWOTH) || (dir_info.st_mode & S_IWGRP)) {
        log_err("directory is writable by others: (%s)\n", dir_name);
        exit(306);
    }

    /*
     * Stat /etc/sysconfig/modlsapi.secret and verify it is a regular file, or error out.
     */
    secret_name = "/etc/sysconfig/modlsapi.secret";
    if (((lstat(secret_name, &secret_info)) != 0) || !(S_ISREG(secret_info.st_mode))) {
        log_err("cannot stat file: (%s)\n", secret_name);
        exit(307);
    }

    if ((secret_info.st_uid != 0) || (secret_info.st_gid != 0)) {
        log_err("file owned not by root: (%s)\n", secret_name);
        exit(308);
    }
    
    if ((secret_info.st_size != AP_SECRET_SIZE)) {
        log_err("wrong file size: (%s)\n", secret_name);
        exit(309);
    }
    
    if ((secret_info.st_mode & S_IRWXO) 
        || (secret_info.st_mode & S_IRWXG)
        || (secret_info.st_mode & S_IWUSR)
        || (secret_info.st_mode & S_IXUSR) ) {
        log_err("wrong file permissions: (%s)\n", secret_name);
        exit(310);
    }

    int fd = open(secret_name, O_RDONLY);
    if(fd == -1) {
        log_err("failed to open file: (%s)\n", secret_name);
        exit(311);
    }
    if(read(fd, secret, AP_SECRET_SIZE) < AP_SECRET_SIZE)
    {
        log_err("failed to read from file: (%s)\n", secret_name);
        close(fd);
        exit(312);
    }
    close(fd);
}

static int env_num;

static void clean_env(char **phprc_ptr, char **phprc_hash_ptr, char **phpug_hash_ptr)
{
    char pathbuf[512];
    char **cleanenv;
    char **ep;
    int cidx = 0;
    int idx;

    /* While cleaning the environment, the environment should be clean.
     * (e.g. malloc() may get the name of a file for writing debugging info.
     * Bad news if MALLOC_DEBUG_FILE is set to /etc/passwd.  Sprintf() may be
     * susceptible to bad locale settings....)
     * (from PR 2790)
     */
    char **envp = environ;
    char *empty_ptr = NULL;

    char *phprc = NULL;
    char *phprc_hash = NULL; 
    char *phpug_hash = NULL;


    environ = &empty_ptr; /* VERY safe environment */

    if ((cleanenv = (char **) calloc(AP_ENVBUF, sizeof(char *))) == NULL) {
        log_err("failed to malloc memory for environment\n");
        exit(120);
    }

    sprintf(pathbuf, "PATH=%s", AP_SAFE_PATH);
    cleanenv[cidx] = strdup(pathbuf);
    if (cleanenv[cidx] == NULL) {
        log_err("failed to malloc memory for environment\n");
        exit(124);
    }
    cidx++;

    for (ep = envp; *ep && cidx < AP_ENVBUF-1; ep++) {
        /*
         * Save PHPRC for later use.
         */
        if(!phprc && !strncmp(*ep, "PHPRC=", 6) ) {
            phprc = *ep;
            continue;
        }
        
        /*
         * Save PHPRC_HASH for later use.
         */
        if(!phprc_hash && !strncmp(*ep, "PHPRC_HASH=", 11) ) {
            phprc_hash = *ep;
            continue;
        }
        
        /*
         * Save PHPUG_HASH for later use.
         */
        if(!phpug_hash && !strncmp(*ep, "PHPUG_HASH=", 11) ) {
            phpug_hash = *ep;
            continue;
        }
        
        for (idx = 0; safe_env_lst[idx]; idx++) {
            if (!strncmp(*ep, safe_env_lst[idx],
                         strlen(safe_env_lst[idx]))) {
                cleanenv[cidx] = *ep;
                cidx++;
                break;
            }
        }
    }
    
    cleanenv[cidx] = NULL;

    environ = cleanenv;
    env_num = cidx;
    
    *phprc_ptr = phprc ? phprc+6 : NULL;                  /* skip PHPRC= prefix */
    *phprc_hash_ptr = phprc_hash ? phprc_hash+11 : NULL;  /* skip PHPRC_HASH= prefix */
    *phpug_hash_ptr = phpug_hash ? phpug_hash+11 : NULL;  /* skip PHPUG_HASH= prefix */
}

/*
 * We assume that the current environment will be created earlier with clean_env.
 * So allocated number of slots is equal to AP_ENVBUF, 
 * env_num contains current number of env vars,
 * and current environment does not contain PHPRC var.
 */
static void add_phprc_to_env(const char *phprc) {
    if(env_num < AP_ENVBUF - 1) {
        size_t len = strlen(phprc);
        char *ptr = malloc(6 + len + 1);
        if(!ptr) {
            log_err("failed to malloc memory for environment\n");
            exit(401);
        }
        memcpy(ptr, "PHPRC=", 6);
        memcpy(ptr+6, phprc, len+1);
        environ[env_num++] = ptr;
        environ[env_num] = NULL;
    }
}

void lve_jail(struct passwd *pw) 
{
    void *lib_handle;
    lib_handle = dlopen("liblve.so.0", RTLD_LAZY);
    if (lib_handle) {
        char *error;
        char error_msg[8192];
        int (*jail)(struct passwd *, char*) = dlsym(lib_handle, "jail");
        if ((error = dlerror()) != NULL) {
            log_err("failed to init LVE library %s\n", error);
            exit(130);
        }
        int result = jail(pw, error_msg);
        if (result < 0) {
            log_err("SecureLVE jail error %s\n", error_msg);
            exit(131);
        }
    }
}

static void set_signals(void) 
{
    sigset_t sig_set;
    sigemptyset(&sig_set);
    sigprocmask(SIG_SETMASK, &sig_set, NULL);
}

static void check_parent(void) 
{
    char buf[AP_MAXPATH];
    int fd;
    int rc;
    
    snprintf(buf, sizeof buf, "/proc/%d/cmdline", getppid());
    fd = open(buf, O_RDONLY);
    if(fd < 0) {
        log_err("Could not get parent name\n");
        exit(501);
    }
    
    rc = read(fd, buf, sizeof buf);
    close(fd);
    
    if(rc <= 0) {
        log_err("Could not get parent name\n");
        exit(502);
    }

    char *last_slash = strrchr(buf, '/');
    char *parent_name = last_slash ? last_slash+1 : buf;
    
    if(strcmp(parent_name, AP_PARENT_NAME)) {
        log_err("Wrong parent (%s) instead of (%s)\n", parent_name, AP_PARENT_NAME);
        exit(503);
    }
}


int main(int argc, char *argv[])
{
    int userdir = 0;        /* ~userdir flag             */
    uid_t real_uid;         /* real user information     */
    uid_t target_uid;       /* target user information   */
    gid_t target_gid;       /* target group placeholder  */
    char *target_socket;    /* target socket to open     */
    char *target_uname;     /* target user name          */
    char *target_gname;     /* target group name         */
    char *target_homedir;   /* target home directory     */
    char *actual_uname;     /* actual user name          */
    char *actual_gname;     /* actual group name         */
    char *cmd;              /* command to be executed    */
    char cwd[AP_MAXPATH];   /* current working directory */
    char dwd[AP_MAXPATH];   /* docroot working directory */
    unsigned char secret[AP_SECRET_SIZE];
    struct passwd *pw;      /* password entry holder     */
    struct group *gr;       /* group entry holder        */
    struct stat dir_info;   /* directory info holder     */
    struct stat prg_info;   /* program info holder       */
    char *phprc;
    char *phprc_hash; 
    char *phpug_hash;
    
    /* inherited sigmask can be very confused */
    set_signals();

    /*
     * Start with a "clean" environment
     */
    clean_env(&phprc, &phprc_hash, &phpug_hash);


    /*
     * Check existence/validity of the UID of the user
     * running this program.  Error out if invalid.
     */
    real_uid = getuid();
    if ((pw = getpwuid(real_uid)) == NULL) {
        log_err("crit: invalid uid: (%lu)\n", (unsigned long)real_uid);
        exit(102);
    }
    /*
     * See if this is a 'how were you compiled' request, and
     * comply if so.
     */
    if ((argc > 1)
        && (! strcmp(argv[1], "-V"))
        && ((real_uid == 0)
#ifdef _OSD_POSIX
        /* User name comparisons are case insensitive on BS2000/OSD */
            || (! strcasecmp(AP_HTTPD_USER, pw->pw_name)))
#else  /* _OSD_POSIX */
            || (! strcmp(AP_HTTPD_USER, pw->pw_name)))
#endif /* _OSD_POSIX */
        ) {
#ifdef AP_ALLOWED_CMD
        fprintf(stderr, " -D AP_ALLOWED_CMD=\"%s\"\n", AP_ALLOWED_CMD);
#endif
#ifdef AP_ALLOWED_DIR
        fprintf(stderr, " -D AP_ALLOWED_DIR=\"%s\"\n", AP_ALLOWED_DIR);
#endif
#ifdef AP_DOC_ROOT
        fprintf(stderr, " -D AP_DOC_ROOT=\"%s\"\n", AP_DOC_ROOT);
#endif
#ifdef AP_GID_MIN
        fprintf(stderr, " -D AP_GID_MIN=%d\n", AP_GID_MIN);
#endif
#ifdef AP_HTTPD_USER
        fprintf(stderr, " -D AP_HTTPD_USER=\"%s\"\n", AP_HTTPD_USER);
#endif
#ifdef AP_LOG_EXEC
        fprintf(stderr, " -D AP_LOG_EXEC=\"%s\"\n", AP_LOG_EXEC);
#endif
#ifdef AP_PARENT_NAME
        fprintf(stderr, " -D AP_PARENT_NAME=\"%s\"\n", AP_PARENT_NAME);
#endif
#ifdef AP_SAFE_DIR
        fprintf(stderr, " -D AP_SAFE_DIR=\"%s\"\n", AP_SAFE_DIR);
#endif
#ifdef AP_SAFE_PATH
        fprintf(stderr, " -D AP_SAFE_PATH=\"%s\"\n", AP_SAFE_PATH);
#endif
#ifdef AP_UID_MIN
        fprintf(stderr, " -D AP_UID_MIN=%d\n", AP_UID_MIN);
#endif
#ifdef AP_USERDIR_SUFFIX
        fprintf(stderr, " -D AP_USERDIR_SUFFIX=\"%s\"\n", AP_USERDIR_SUFFIX);
#endif
        exit(0);
    }
    
   check_parent();

    /*
     * If there are a proper number of arguments, set
     * all of them to variables.  Otherwise, error out.
     */
    if (argc != 5) {
        log_err("Wrong argument number\n");
        exit(101);
    }
    target_uname = argv[1];
    target_gname = argv[2];
    cmd = argv[3];
    target_socket = argv[4];

    /*
     * Check to see if the user running this program
     * is the user allowed to do so as defined in
     * sulsphp.h.  If not the allowed user, error out.
     */
#ifdef _OSD_POSIX
    /* User name comparisons are case insensitive on BS2000/OSD */
    if (strcasecmp(AP_HTTPD_USER, pw->pw_name)) {
        log_err("user mismatch (%s instead of %s)\n", pw->pw_name, AP_HTTPD_USER);
        exit(103);
    }
#else  /*_OSD_POSIX*/
    if (strcmp(AP_HTTPD_USER, pw->pw_name)) {
        log_err("user mismatch (%s instead of %s)\n", pw->pw_name, AP_HTTPD_USER);
        exit(103);
    }
#endif /*_OSD_POSIX*/

#if 0    // Disable checking for leading slash in path 
    /*
     * Check for a leading '/' (absolute path) in the command to be executed,
     * or attempts to back up out of the current directory,
     * to protect against attacks.  If any are
     * found, error out.  Naughty naughty crackers.
     */
    if ((cmd[0] == '/') || (!strncmp(cmd, "../", 3))
        || (strstr(cmd, "/../") != NULL)) {
        log_err("invalid command (%s)\n", cmd);
        exit(104);
    }
#endif

    /*
     * Check for an allowable command.
     */
    size_t allowed_cmd_len = strlen(AP_ALLOWED_CMD);
    size_t cmd_len = strlen(cmd);
    if( (cmd_len < (allowed_cmd_len+1)) 
       || (cmd[cmd_len - allowed_cmd_len - 1] != '/') 
       ||  strncmp(cmd + cmd_len - allowed_cmd_len, AP_ALLOWED_CMD, allowed_cmd_len) )
    {
        log_err("invalid command (%s)\n", cmd);
        exit(105);
    }

    /*
     * Check for an allowable (or safe) directory.
     */
    size_t safe_dir_len = strlen(AP_SAFE_DIR);
    size_t allowed_dir_len = strlen(AP_ALLOWED_DIR);
    if( ( (cmd_len != allowed_dir_len + allowed_cmd_len + 1)
            || strncmp(cmd, AP_ALLOWED_DIR, allowed_dir_len) 
            || (cmd[allowed_dir_len] != '/') )
     && ( (cmd_len < safe_dir_len + allowed_cmd_len + 1)
            || strncmp(cmd, AP_SAFE_DIR, safe_dir_len) 
            || (cmd[safe_dir_len] != '/') ) )
    {
        log_err("invalid command (%s)\n", cmd);
        exit(106);
    }
        
    /*
     * Check for attempts to back up in directory tree,
     */
    if (strstr(cmd, "/../")) 
    {
        log_err("invalid command (%s)\n", cmd);
        exit(107);
    }

    /*
     * Check to see if this is a ~userdir request.  If
     * so, set the flag, and remove the '~' from the
     * target username.
     */
    if (!strncmp("~", target_uname, 1)) {
        target_uname++;
        userdir = 1;
    }
 
    /*
     * Error out if the target username is invalid.
     */
    if (strspn(target_uname, "1234567890") != strlen(target_uname)) {
        if ((pw = getpwnam(target_uname)) == NULL) {
            log_err("invalid target user name: (%s)\n", target_uname);
            exit(108);
        }
    }
    else {
        if ((pw = getpwuid(atoi(target_uname))) == NULL) {
            log_err("invalid target user id: (%s)\n", target_uname);
            exit(109);
        }
    }

    /*
     * Error out if the target group name is invalid.
     */
    if (strspn(target_gname, "1234567890") != strlen(target_gname)) {
        if ((gr = getgrnam(target_gname)) == NULL) {
            log_err("invalid target group name: (%s)\n", target_gname);
            exit(110);
        }
    }
    else {
        if ((gr = getgrgid(atoi(target_gname))) == NULL) {
            log_err("invalid target group id: (%s)\n", target_gname);
            exit(111);
        }
    }
    target_gid = gr->gr_gid;
    if ((actual_gname = strdup(gr->gr_name)) == NULL) {
        log_err("failed to alloc memory\n");
        exit(112);
    }

#ifdef _OSD_POSIX
    /*
     * Initialize BS2000 user environment
     */
    {
        pid_t pid;
        int status;

        switch (pid = ufork(target_uname)) {
        case -1:    /* Error */
            log_err("failed to setup bs2000 environment for user %s: %s\n",
                    target_uname, strerror(errno));
            exit(113);
        case 0:     /* Child */
            break;
        default:    /* Father */
            while (pid != waitpid(pid, &status, 0))
                ;
            /* @@@ FIXME: should we deal with STOP signals as well? */
            if (WIFSIGNALED(status)) {
                kill (getpid(), WTERMSIG(status));
            }
            exit(WEXITSTATUS(status));
        }
    }
#endif /*_OSD_POSIX*/

    /*
     * Save these for later since initgroups will hose the struct
     */
    target_uid = pw->pw_uid;
    actual_uname = strdup(pw->pw_name);
    target_homedir = strdup(pw->pw_dir);
    if (actual_uname == NULL || target_homedir == NULL) {
        log_err("failed to alloc memory\n");
        exit(114);
    }

    /*
     * Read a secret from the secret file.
     */
    read_secret(secret);

    /*
     * uid and gid should be signed in any case
     */
    if(!phpug_hash) {
        log_err("not signed uid/gid\n");
        exit(115);
    }

    pid_t uidgid[2];
    uidgid[0] = target_uid;
    uidgid[1] = target_gid;
    if(verify_sign(phpug_hash, secret, (unsigned char*)uidgid, sizeof uidgid) ) {
        log_err("uid/gid sign error\n");
        exit(116);
    }
    
    /*
     * If PHPRC and its sign were found in the initial environment.
     */
    if(phprc && phprc_hash) { 
        if(!verify_sign(phprc_hash, secret, (unsigned char*)phprc, strlen(phprc)) ) {
            add_phprc_to_env(phprc);
        }
    } 
       

    /*
     * Log the transaction here to be sure we have an open log
     * before we setuid().
     */
    log_no_err("uid: (%s/%s) gid: (%s/%s) cmd: %s; socket: %s\n",
               target_uname, actual_uname,
               target_gname, actual_gname,
               cmd, target_socket );

    /*
     * Error out if attempt is made to execute as root or as
     * a UID less than AP_UID_MIN.  Tsk tsk.
     */
    if ((target_uid == 0) || (target_uid < AP_UID_MIN)) {
        log_err("cannot run as forbidden uid (%lu/%s)\n", (unsigned long)target_uid, cmd);
        exit(115);
    }

    /*
     * Error out if attempt is made to execute as root group
     * or as a GID less than AP_GID_MIN.  Tsk tsk.
     */
    if ((target_gid == 0) || (target_gid < AP_GID_MIN)) {
        log_err("cannot run as forbidden gid (%lu/%s)\n", (unsigned long)target_gid, cmd);
        exit(116);
    }
    
    /*
     *  Switch to real user to open socket. 
     */
     if (setresuid(-1, real_uid, 0) != 0) {
        log_err("failed to setuid (%lu: %s)\n", (unsigned long)real_uid, cmd);
        exit(117);
     }
     
     /*
      *  Create a listen socket.
      */
     int sock = create_listen_socket(target_socket, 10);
     if(sock < 0) {
        log_err("failed to create socket(%s): %s\n", target_socket, strerror(errno));
        exit(118);
     }
     dup2(sock, 0);
     close(sock);


    /*
     *  Switch back to superuser.
     */
     if (setresuid(-1, 0, 0) != 0) {
        log_err("failed to setuid (0: %s)\n", cmd);
        exit(118);
     }
     
    /* Entering into jail */
    lve_jail(pw); 
    
    /*
     * Change UID/GID here so that the following tests work over NFS.
     *
     * Initialize the group access list for the target user,
     * and setgid() to the target group. If unsuccessful, error out.
     */
    if (((setgid(target_gid)) != 0) || (initgroups(actual_uname, target_gid) != 0)) {
        log_err("failed to setgid (%lu: %s)\n", (unsigned long)target_gid, cmd);
        exit(120);
    }

    /*
     * setuid() to the target user.  Error out on fail.
     */
    if ((setuid(target_uid)) != 0) {
        log_err("failed to setuid (%lu: %s)\n", (unsigned long)target_uid, cmd);
        exit(121);
    }

    /*
     * Get the current working directory, as well as the proper
     * document root (dependant upon whether or not it is a
     * ~userdir request).  Error out if we cannot get either one,
     * or if the current working directory is not in the docroot.
     * Use chdir()s and getcwd()s to avoid problems with symlinked
     * directories.  Yuck.
     */
    if (getcwd(cwd, AP_MAXPATH) == NULL) {
        log_err("cannot get current working directory\n");
        exit(122);
    }

    if (userdir) {
        if (((chdir(target_homedir)) != 0) ||
            ((chdir(AP_USERDIR_SUFFIX)) != 0) ||
            ((getcwd(dwd, AP_MAXPATH)) == NULL) ||
            ((chdir(cwd)) != 0)) {
            log_err("cannot get docroot information (%s)\n", target_homedir);
            exit(123);
        }
    }
    else {
        if (((chdir(AP_DOC_ROOT)) != 0) ||
            ((getcwd(dwd, AP_MAXPATH)) == NULL) ||
            ((chdir(cwd)) != 0)) {
            log_err("cannot get docroot information (%s)\n", AP_DOC_ROOT);
            exit(124);
        }
    }

/*
    if ((strncmp(cwd, dwd, strlen(dwd))) != 0) {
        log_err("command not in docroot (%s/%s)\n", cwd, cmd);
        exit(125);
    }
*/

    /*
     * Stat the cwd and verify it is a directory, or error out.
     */
    if (((lstat(cwd, &dir_info)) != 0) || !(S_ISDIR(dir_info.st_mode))) {
        log_err("cannot stat directory: (%s)\n", cwd);
        exit(126);
    }

    /*
     * Error out if cwd is writable by others.
     */
    if ((dir_info.st_mode & S_IWOTH) || (dir_info.st_mode & S_IWGRP)) {
        log_err("directory is writable by others: (%s)\n", cwd);
        exit(127);
    }

    /*
     * Error out if we cannot stat the program.
     */
    if (stat(cmd, &prg_info) != 0) {
        log_err("cannot stat program: (%s)\n", cmd);
        exit(128);
    }

    /*
     * Error out if the program is writable by others.
     */
    if ((prg_info.st_mode & S_IWOTH) || (prg_info.st_mode & S_IWGRP)) {
        log_err("file is writable by others: (%s/%s)\n", cwd, cmd);
        exit(129);
    }

    /*
     * Error out if the file is setuid or setgid.
     */
    if ((prg_info.st_mode & S_ISUID) || (prg_info.st_mode & S_ISGID)) {
        log_err("file is either setuid or setgid: (%s/%s)\n", cwd, cmd);
        exit(130);
    }

#if 0   // Disable checking the difference of target name/group
    /*
     * Error out if the target name/group is different from
     * the name/group of the cwd or the program.
     */
    if ((target_uid != dir_info.st_uid) ||
        (target_gid != dir_info.st_gid) ||
        (target_uid != prg_info.st_uid) ||
        (target_gid != prg_info.st_gid)) {
        log_err("target uid/gid (%lu/%lu) mismatch "
                "with directory (%lu/%lu) or program (%lu/%lu)\n",
                (unsigned long)target_uid, (unsigned long)target_gid,
                (unsigned long)dir_info.st_uid, (unsigned long)dir_info.st_gid,
                (unsigned long)prg_info.st_uid, (unsigned long)prg_info.st_gid);
        exit(131);
    }
#endif 
    /*
     * Error out if the program is not executable for the user.
     * Otherwise, she won't find any error in the logs except for
     * "[error] Premature end of script headers: ..."
     */
    if (!(prg_info.st_mode & S_IXUSR)) {
        log_err("file has no execute permission: (%s/%s)\n", cwd, cmd);
        exit(132);
    }
    
    for(char *ptr = cmd+1; *ptr; ptr++) {
        if(*ptr == '/') {
            *ptr = '\0';
            if( (stat(cmd, &dir_info) != 0) || !(S_ISDIR(dir_info.st_mode))
               || (dir_info.st_mode & S_IWOTH) || (dir_info.st_mode & S_IWGRP) ) {
                
                log_err("path to file is writable for others (%s)\n", cmd);
                exit(132);
            }
            *ptr = '/';
        }
    }

#ifdef AP_SULSPHP_UMASK
    /*
     * umask() uses inverse logic; bits are CLEAR for allowed access.
     */
    umask(AP_SULSPHP_UMASK);
#endif /* AP_SULSPHP_UMASK */

    /* Be sure to close the log file so the CGI can't mess with it. */
    if (log != NULL) {
#if APR_HAVE_FCNTL_H
        /*
         * ask fcntl(2) to set the FD_CLOEXEC flag on the log file,
         * so it'll be automagically closed if the exec() call succeeds.
         */
        fflush(log);
        setbuf(log, NULL);
        if ((fcntl(fileno(log), F_SETFD, FD_CLOEXEC) == -1)) {
            log_err("error: can't set close-on-exec flag");
            exit(133);
        }
#else
        /*
         * In this case, exec() errors won't be logged because we have already
         * dropped privileges and won't be able to reopen the log file.
         */
        fclose(log);
        log = NULL;
#endif
    }

    /*
     * Execute the command, replacing our image with its own.
     */
#ifdef NEED_HASHBANG_EMUL
    /* We need the #! emulation when we want to execute scripts */
    {
        extern char **environ;

        ap_execve(cmd, &argv[3], environ);
    }
#else /*NEED_HASHBANG_EMUL*/
    execl(cmd, cmd, NULL);
#endif /*NEED_HASHBANG_EMUL*/

    /*
     * (I can't help myself...sorry.)
     *
     * Uh oh.  Still here.  Where's the kaboom?  There was supposed to be an
     * EARTH-shattering kaboom!
     *
     * Oh well, log the failure and error out.
     */
    log_err("(%d)%s: exec failed (%s)\n", errno, strerror(errno), cmd);
    exit(255);
}
