/*

 * Utility routines to assist with the running of sub-commands

 */

#include <net-snmp/net-snmp-config.h>

#ifdef HAVE_IO_H

#include <io.h>

#endif

#include <stdio.h>

#ifdef HAVE_STDLIB_H

#include <stdlib.h>

#endif

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#ifdef HAVE_MALLOC_H

#include <malloc.h>

#endif

#include <sys/types.h>

#include <ctype.h>

#ifdef HAVE_FCNTL_H

#include <fcntl.h>

#endif

#ifdef HAVE_SYS_WAIT_H

#include <sys/wait.h>

#endif

#ifdef HAVE_SYS_SELECT_H

#include <sys/select.h>

#endif

#include <errno.h>

#include <net-snmp/net-snmp-includes.h>

#include <net-snmp/agent/net-snmp-agent-includes.h>

#include <ucd-snmp/errormib.h>

#include <net-snmp/agent/netsnmp_close_fds.h>

#include "execute.h"

#include "struct.h"

#ifdef _MSC_VER

#define popen  _popen

#define pclose _pclose

#endif

/**

 * Run a shell command by calling system() or popen().

 *

 * @command: Shell command to run.

 * @input:   Data to send to stdin. May be NULL.

 * @output:  Buffer in which to store the output written to stdout. May be NULL.

 * @out_len: Size of the output buffer. The actual number of bytes written is

 *           stored in *@out_len.

 *

 * @return >= 0 if the command has been executed; -1 if the command could not

 *           be executed.

 */

int

run_shell_command(const char *command, const char *input,

                  char *output, int *out_len)

{

#ifdef HAVE_SYSTEM

    int         result;    /* and the return value of the command */

    if (!command)

        return -1;

    DEBUGMSGTL(("run_shell_command", "running %s\n", command));

    DEBUGMSGTL(("run:shell", "running '%s'\n", command));

    result = -1;

    /*

     * Set up the command and run it.

     */

    if (input) {

        if (output) {

            const char *ifname;

            const char *ofname;    /* Filename for output redirection */

            char        shellline[STRMAX];   /* The full command to run */

            FILE       *file;

            ifname = netsnmp_mktemp();

            if(NULL == ifname)

                return -1;

            file = fopen(ifname, "w");

            if(NULL == file) {

                snmp_log(LOG_ERR,"couldn't open temporary file %s\n", ifname);

                unlink(ifname);

                return -1;

            }

            fprintf(file, "%s", input);

            fclose( file );

            ofname = netsnmp_mktemp();

            if(NULL == ofname) {

                if(ifname)

                    unlink(ifname);

                return -1;

            }

            snprintf( shellline, sizeof(shellline), "(%s) < \"%s\" > \"%s\"",

                      command, ifname, ofname );

            result = system(shellline);

            /*

             * If output was requested, then retrieve & return it.

             * Tidy up, and return the result of the command.

             */

            if (out_len && *out_len != 0) {

                int         fd;        /* For processing any output */

                int         len = 0;

                fd = open(ofname, O_RDONLY);

                if(fd >= 0)

                    len = read(fd, output, *out_len - 1);

                *out_len = len;

                if (len >= 0)

                    output[len] = 0;

                else

                    output[0] = 0;

                if (fd >= 0)

                    close(fd);

            }

            unlink(ofname);

            unlink(ifname);

        } else {

            FILE       *file;

            file = popen(command, "w");

            if (file) {

                fwrite(input, 1, strlen(input), file);

                result = pclose(file);

            }

        }

    } else {

        if (output) {

            FILE* file;

            file = popen(command, "r");

            if (file) {

                *out_len = fread(output, 1, *out_len - 1, file);

                if (*out_len >= 0)

                    output[*out_len] = 0;

                else

                    output[0] = 0;

                result = pclose(file);

            }

        } else {

            result = system(command);

        }

    }

    return result;

#else

    return -1;

#endif

}

#ifdef HAVE_EXECV

/*

 * Split the given command up into separate tokens,

 * ready to be passed to 'execv'

 */

static char **

tokenize_exec_command(const char *command, int *argc)

{

    char ctmp[STRMAX];

    const char *cp = command;

    char **argv;

    int  i;

    argv = calloc(100, sizeof(char *));

    if (!argv)

        return argv;

    for (i = 0; cp && i + 2 < 100; i++) {

        cp = copy_nword_const(cp, ctmp, sizeof(ctmp));

        argv[i] = strdup(ctmp);

    }

    if (cp)

        argv[i++] = strdup(cp);

    argv[i] = NULL;

    *argc = i;

    return argv;

}

#endif

/**

 * Run a command by calling execv().

 *

 * @command: Shell command to run.

 * @input:   Data to send to stdin. May be NULL.

 * @output:  Buffer in which to store the output written to stdout. May be NULL.

 * @out_len: Size of the output buffer. The actual number of bytes written is

 *           stored in *@out_len.

 *

 * @return >= 0 if the command has been executed; -1 if the command could not

 *           be executed.

 */

int

run_exec_command(const char *command, const char *input,

                 char *output, int *out_len)

{

#ifdef HAVE_EXECV

    int ipipe[2];

    int opipe[2];

    int i;

    int pid;

    int result;

    char **argv;

    int argc;

    DEBUGMSGTL(("run:exec", "running '%s'\n", command));

    if (pipe(ipipe) < 0) {

        snmp_log_perror("pipe");

        return -1;

    }

    if (pipe(opipe) < 0) {

        snmp_log_perror("pipe");

        close(ipipe[0]);

        close(ipipe[1]);

        return -1;

    }

    if ((pid = fork()) == 0) {

        /*

         * Child process

         */

        /*

         * Set stdin/out/err to use the pipe

         *   and close everything else

         */

        if (dup2(ipipe[0], STDIN_FILENO) < 0) {

            snmp_log_perror("dup2(STDIN_FILENO)");

            exit(1);

        }

        close(ipipe[0]);

        close(ipipe[1]);

        if (dup2(opipe[1], STDOUT_FILENO) < 0) {

            snmp_log_perror("dup2(STDOUT_FILENO)");

            exit(1);

        }

        close(opipe[0]);

        close(opipe[1]);

        if (dup2(STDOUT_FILENO, STDERR_FILENO) < 0) {

            snmp_log_perror("dup2(STDERR_FILENO)");

            exit(1);

        }

        netsnmp_close_fds(2);

        /*

         * Set up the argv array and execute it

         * This is being run in the child process,

         *   so will release resources when it terminates.

         */

        argv = tokenize_exec_command(command, &argc);

        if (!argv)

            exit(1);

        execv(argv[0], argv);

        snmp_log_perror(argv[0]);

        for (i = 0; i < argc; i++)

            free(argv[i]);

        free(argv);

        exit(1);        /* End of child */

    } else if (pid > 0) {

        char            cache[NETSNMP_MAXCACHESIZE];

        char           *cache_ptr;

        ssize_t         count, cache_size, offset = 0;

        int             waited = 0, numfds;

        fd_set          readfds;

        struct timeval  timeout;

        /*

         * Parent process

         */

        /*

         * Pass the input message (if any) to the child,

         * wait for the child to finish executing, and read

         *    any output into the output buffer (if provided)

         */

        close(ipipe[0]);

        close(opipe[1]);

        if (input && write(ipipe[1], input, strlen(input)) < 0)

            snmp_log_perror("write() to input pipe");

        close(ipipe[1]);

        /*

         * child will block if it writes a lot of data and

         * fills up the pipe before exiting, so we read data

         * to keep the pipe empty.

         */

        if (output && ((NULL == out_len) || (0 == *out_len))) {

            DEBUGMSGTL(("run:exec",

                        "invalid params; no output will be returned\n"));

            output = NULL;

        }

        if (output) {

            cache_ptr = output;

            cache_size = *out_len - 1;

        } else {

            cache_ptr = cache;

            cache_size = sizeof(cache);

        }

        /*

         * xxx: some of this code was lifted from get_exec_output

         * in util_funcs.c. Probably should be moved to a common

         * routine for both to use.

         */

        DEBUGMSGTL(("verbose:run:exec","  waiting for child %d...\n", pid));

        numfds = opipe[0] + 1;

        i = NETSNMP_MAXREADCOUNT;

        for (; i; --i) {

            /*

             * set up data for select

             */

            FD_ZERO(&readfds);

            FD_SET(opipe[0], &readfds);

            timeout.tv_sec = 1;

            timeout.tv_usec = 0;

            DEBUGMSGTL(("verbose:run:exec", "    calling select\n"));

            count = select(numfds, &readfds, NULL, NULL, &timeout);

            if (count == -1) {

                if (EAGAIN == errno) {

                    continue;

                } else {

                    DEBUGMSGTL(("verbose:run:exec", "      errno %d\n",

                                errno));

                    snmp_log_perror("read");

                    break;

                }

            } else if (0 == count) {

                DEBUGMSGTL(("verbose:run:exec", "      timeout\n"));

                continue;

            }

            if (!FD_ISSET(opipe[0], &readfds)) {

                DEBUGMSGTL(("verbose:run:exec", "    fd not ready!\n"));

                continue;

            }

            /*

             * read data from the pipe, optionally saving to output buffer

             */

            count = read(opipe[0], &cache_ptr[offset], cache_size);

            DEBUGMSGTL(("verbose:run:exec",

                        "    read %d bytes\n", (int)count));

            if (0 == count) {

                int rc;

                /*

                 * we shouldn't get no data, because select should

                 * wait til the fd is ready. before we go back around,

                 * check to see if the child exited.

                 */

                DEBUGMSGTL(("verbose:run:exec", "    no data!\n"));

                if ((rc = waitpid(pid, &result, WNOHANG)) <= 0) {

                    if (rc < 0) {

                        snmp_log_perror("waitpid");

                        break;

                    } else

                        DEBUGMSGTL(("verbose:run:exec",

                                    "      child not done!?!\n"));

                } else {

                    DEBUGMSGTL(("verbose:run:exec", "      child done\n"));

                    waited = 1; /* don't wait again */

                    break;

                }

            } else if (count > 0) {

                /*

                 * got some data. fix up offset, if needed.

                 */

                if(output) {

                    offset += count;

                    cache_size -= count;

                    if (cache_size <= 0) {

                        DEBUGMSGTL(("verbose:run:exec",

                                    "      output full\n"));

                        break;

                    }

                    DEBUGMSGTL(("verbose:run:exec",

                                "    %d left in buffer\n", (int)cache_size));

                }

            } else if (count == -1 && EAGAIN != errno) {

                /*

                 * if error, break

                 */

                DEBUGMSGTL(("verbose:run:exec", "      errno %d\n",

                            errno));

                snmp_log_perror("read");

                break;

            }

        }

        DEBUGMSGTL(("verbose:run:exec", "  done reading\n"));

        if (output)

            DEBUGMSGTL(("run:exec", "  got %d bytes\n", *out_len));

        /*

         * close pipe to signal that we aren't listening any more.

         */

        close(opipe[0]);

        /*

         * if we didn't wait successfully above, wait now.

         * xxx-rks: seems like this is a waste of the agent's

         * time. maybe start a time to wait(WNOHANG) once a second,

         * and late the agent continue?

         */

        if (!waited && waitpid(pid, &result, 0) < 0) {

            snmp_log_perror("waitpid");

            return -1;

        }

        /*

         * null terminate any output

         */

        if (output) {

            output[offset] = 0;

            *out_len = offset;

        }

        DEBUGMSGTL(("run:exec","  child %d finished. result=%d\n",

                    pid,result));

        return WEXITSTATUS(result);

    } else {

        /*

         * Parent process - fork failed

         */

        snmp_log_perror("fork");

        close(ipipe[0]);

        close(ipipe[1]);

        close(opipe[0]);

        close(opipe[1]);

        return -1;

    }

#else

    /*

     * If necessary, fall back to using 'system'

     */

    DEBUGMSGTL(("run:exec", "running shell command '%s'\n", command));

    return run_shell_command( command, input, output, out_len );

#endif

}