xdasd_exec.c

Go to the documentation of this file.

/*----------------------------------------------------------------------------
 * Copyright (c) 2006, Novell, Inc.
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without 
 * modification, are permitted provided that the following conditions are 
 * met:
 * 
 *     * Redistributions of source code must retain the above copyright 
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright 
 *       notice, this list of conditions and the following disclaimer in the 
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the Novell nor the names of its contributors 
 *       may be used to endorse or promote products derived from this 
 *       software without specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *--------------------------------------------------------------------------*/

#include "xdasd_exec.h"
#include "xdasd_log.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

#ifdef _WIN32
# define WIN32_LEAN_AND_MEAN
# include <windows.h>
# include <process.h>
# include <direct.h>
#else
# include <unistd.h>
# include <sys/types.h>
# include <sys/wait.h>
#endif

#ifdef XDASD_EXEC_TEST
# define INITIAL_BUFSZ_MULTIPLIER   1
#else
# define INITIAL_BUFSZ_MULTIPLIER   2
#endif

#define XDAS_FIELD_COUNT 33

static char * ex_substitute_vars(const char * script, const char ** msgflds)
{
   char * p, * text;
   size_t scriptsz = strlen(script) + 1;
   size_t allocsz = scriptsz * INITIAL_BUFSZ_MULTIPLIER;

   if ((text = (char *)malloc(allocsz)) == 0)
   {
      xdasd_log(0, "exec: Memory allocation failure.\n");
      return 0;
   }
   memcpy(text, script, scriptsz);

   p = text;
   while ((p = strstr(p, "$XDAS")) != 0)
   {
      int fldnum = 0;
      size_t flen;                     /* length of field value */
      size_t vlen = 5;                 /* length of var (5 in "$XDAS") */
      const char * msg = msgflds[0];   /* assume no trailing field number */
      const char * limit = msgflds[XDAS_FIELD_COUNT] - 1;

      /* locate field if field value specified */
      if (p[5] == '(')
      {
         while (p[vlen++] != ')') /* empty */ ; /* count to closing paren */
         fldnum = strtoul(p + 6, 0, 0);
         /* assert(fldnum >= 0 && fldnum <= 32); */
         msg = msgflds[fldnum];
         limit = msgflds[fldnum + 1] - 1;
      }

      /* grow buffer if necessary - if new scriptsz grows beyond allocsz */
      flen = limit - msg;
      if (scriptsz + flen - vlen > allocsz)
      {
         char * newtext;
         while (scriptsz + flen - vlen > allocsz)
            allocsz *= 2;
         if ((newtext = (char *)realloc(text, allocsz)) == 0)
         {
            xdasd_log(0, "exec: Memory allocation failure.\n");
            free(text);
            return 0;
         }
         p = newtext + (p - text);  /* repoint into new buffer */
         text = newtext;
      }

      /* replace variable text with message field text */
      memmove(p + flen, p + vlen, scriptsz - (p - text + vlen));
      memcpy(p, msg, flen);
      scriptsz += flen - vlen;   /* Note that flen - vlen may be negative */

      /* move p past inserted text */
      p += flen;
   }
   return text;
}

static int ex_exec_script(const char * script)
{
#ifdef _WIN32

# define SHELL_ENVAR    "COMSPEC"
# define DEFAULT_SHELL  "CMD.EXE"

# if 0   /* batch file mode disabled */

   /* This is the batch file method - this method would be needed on MSDOS
    * systems, and Win95/98, but we don't care about them anymore.
    */
   static char tmpath[MAX_PATH - 18] = "";

   char cmdline[MAX_PATH + 3];
   PROCESS_INFORMATION pi;
   STARTUPINFO sui;
   DWORD pecode = 0;
   FILE * fp;
   char * shell;

   if ((shell = getenv(SHELL_ENVAR)) == 0)
      shell = DEFAULT_SHELL;

   if (*tmpath == 0 && GetTempPath(sizeof(tmpath), tmpath) == 0)
   {
      xdasd_log(0, "exec: Error getting TEMP directory, %ul.\n", GetLastError());
      return -1;
   }
   strcpy(cmdline, "/c ");
   if (GetTempFileName(tmpath, "XDAS", 0, cmdline + 3) == 0)
   {
      xdasd_log(0, "exec: Error generating temporary batch file name, %ul.\n", 
            GetLastError());
      return -1;
   }
   strcat(cmdline, ".bat");
   if ((fp = fopen(cmdline, "w")) == 0)
   {
      xdasd_log(0, "exec: Unable to open temp batch file for write, %d - %s.\n", 
            errno, strerror(errno));
      return -1;
   }
   fputs(script, fp);
   fclose(fp);
   
   memset(&sui, 0, sizeof(sui));
   sui.cb = sizeof(sui);
   if (CreateProcess(shell, cmdline, 0, 0, TRUE, 0, 0, 0, &sui, &pi) == FALSE)
   {
      xdasd_log(0, "exec: Error creating child process, %ul.\n", GetLastError());
      pecode = (DWORD)(-1);
   }
   else 
   {
      if (WaitForSingleObject(pi.hProcess, INFINITE) != WAIT_OBJECT_0)
         xdasd_log(0, "exec: Error waiting for child process, %ul.\n", 
               GetLastError());
      else if (GetExitCodeProcess(pi.hProcess, &pecode) == FALSE)
         xdasd_log(0, "exec: Error retrieving child process status code, %ul.\n", 
               GetLastError());
      CloseHandle(pi.hProcess);
      CloseHandle(pi.hThread);
   }
   _unlink(cmdline + 3);
   return (int)pecode;

# else   /* !0 */

   /* This is the process stdin/stdout redirection method - this method 
    * words on NT and XP because cmd.exe is now smart enough (finally) to 
    * accept stdin from a file (or pipe) and treat it as if it were a 
    * script file specified on the command line after a /c option.
    */
   SECURITY_ATTRIBUTES sa;
   PROCESS_INFORMATION pi;
   STARTUPINFOA sui;
   HANDLE hinrd = INVALID_HANDLE_VALUE;
   HANDLE hinwr = INVALID_HANDLE_VALUE;
   HANDLE houtrd = INVALID_HANDLE_VALUE;
   HANDLE houtwr = INVALID_HANDLE_VALUE;
   HANDLE hcurproc = GetCurrentProcess();
   DWORD pecode = (DWORD)(-1);
   BOOL status;
   char * shell;

   /* get the SHELL (COMSPEC) environment variable */
   if ((shell = getenv(SHELL_ENVAR)) == 0)
      shell = DEFAULT_SHELL;

   /* set pipe security attributes to allow all handles to be inherited */
   memset(&sa, 0, sizeof(sa));
   sa.nLength = sizeof(sa);
   sa.bInheritHandle = TRUE;

   /* create a pipe for the child process's stdout */
   if ((status = CreatePipe(&houtrd, &houtwr, &sa, 0)) != FALSE)
   {
      /* switch to noninheritable read handle */
      HANDLE htmp;
      if ((status = DuplicateHandle(hcurproc, houtrd, hcurproc, 
            &htmp, 0, FALSE, DUPLICATE_SAME_ACCESS)) != FALSE)
      {
         CloseHandle(houtrd);
         houtrd = htmp;
      }
   }
   if (!status)
   {
      xdasd_log(0, "exec: Error creating child process STDOUT pipe, %ul.\n", 
            GetLastError());
      goto errout;
   }

   /* create a pipe for the child process's stdin */ 
   if ((status = CreatePipe(&hinrd, &hinwr, &sa, 0)) != FALSE)
   {
      /* switch to noninheritable write handle */
      HANDLE htmp;
      if ((status = DuplicateHandle(hcurproc, hinwr, hcurproc, 
            &htmp, 0, FALSE, DUPLICATE_SAME_ACCESS)) != FALSE)
      {
         CloseHandle(hinwr);
         hinwr = htmp;
      }
   }
   if (!status)
   {
      xdasd_log(0, "exec: Error creating child process STDIN pipe, %ul.\n", 
            GetLastError());
      goto errout;
   }

   /* configure startup parameters, including stdin/stdout handles */
   memset(&sui, 0, sizeof(sui));
   sui.cb = sizeof(sui);
   sui.hStdInput = hinrd;
   sui.hStdOutput = houtwr;
   sui.hStdError = houtwr;
   sui.dwFlags |= STARTF_USESTDHANDLES;

   /* create child process */
   if (!CreateProcessA(shell, 0, 0, 0, TRUE, 0, 0, 0, &sui, &pi))
      xdasd_log(0, "exec: Error creating child process, %ul.\n", 
            GetLastError());
   else 
   {
      DWORD bytes_read, bytes_written; 
      char buf[1024];

      CloseHandle(hinrd);  hinrd = INVALID_HANDLE_VALUE;
      CloseHandle(houtwr); houtwr = INVALID_HANDLE_VALUE;

      /* write the script to the child process */
      if (!WriteFile(hinwr, script, (DWORD)strlen(script), &bytes_written, 0))
      {
         xdasd_log(0, "exec: Error writing script to child process, %ul.\n", 
               GetLastError());
         goto errout;
      }

      /* close the output pipe handle so the child process stops reading
         close our side so the pipe is destroyed completely */
      CloseHandle(hinwr);  hinwr = INVALID_HANDLE_VALUE;

      /* read output from the child process, and toss it in the bit-bucket */
      while (ReadFile(houtrd, buf, sizeof(buf), &bytes_read, 0) && bytes_read)
#  ifdef LOG_TO_STDOUT  /* except during debugging, print it to stdout */
         WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), buf, 
               bytes_read, &bytes_written, 0)
#  endif
         ;

      /* close the read pipe handle and our side as well */
      CloseHandle(houtrd); houtrd = INVALID_HANDLE_VALUE;

      pecode = 0; /* from this point on, we don't fail the call on error */

      /* wait for child to terminate, get status code */
      if (WaitForSingleObject(pi.hProcess, INFINITE) != WAIT_OBJECT_0)
         xdasd_log(0, "exec: Error waiting for child process, %ul.\n", 
               GetLastError());
      else if (GetExitCodeProcess(pi.hProcess, &pecode) == FALSE)
         xdasd_log(0, "exec: Error retrieving child process status "
               "code, %ul.\n", GetLastError());

      /* close process and thread handles */
      CloseHandle(pi.hProcess);
      CloseHandle(pi.hThread);
   }

errout:  /* close all currently open pipe handles, if needed */
   if (hinwr  != INVALID_HANDLE_VALUE) CloseHandle(hinwr);
   if (houtwr != INVALID_HANDLE_VALUE) CloseHandle(houtwr);
   if (hinrd  != INVALID_HANDLE_VALUE) CloseHandle(hinrd);
   if (houtrd != INVALID_HANDLE_VALUE) CloseHandle(houtrd);

   return (int)pecode;

# endif  /* ?0 */

#else    /* !_WIN32 */

# define SHELL_ENVAR    "SHELL"
# define DEFAULT_SHELL  "/bin/sh"

   int rv = -1;
   pid_t pid;
   int fdstdout[2] = {-1, -1};
   int fdstdin[2] = {-1, -1};
   char * shell;

   if ((shell = getenv(SHELL_ENVAR)) == 0)
      shell = DEFAULT_SHELL;

   /* open pipes for child's stdout and stdin channels */
   if (pipe(fdstdout) == -1 || pipe(fdstdin) == -1)
   {
      xdasd_log(0, "exec: Error creating child process pipes, (%d) %s.\n", 
            errno, strerror(errno));
      close(fdstdout[0]); close(fdstdout[1]);
      return -1;
   }

   /* fork - create a child process */
   if ((pid = fork()) < 0) /* error */
   {
      xdasd_log(0, "exec: Error creating child process, (%d) %s.\n", 
            errno, strerror(errno));
      close(fdstdin[0]);  close(fdstdin[1]);
      close(fdstdout[0]); close(fdstdout[1]);
      return -1;
   }

   if (pid > 0)       /* parent process */
   {
      int status;
      int bytes;
      char buf[1024];

      /* close the ends we don't need */
      close(fdstdin[0]);   /* child's stdin read handle */
      close(fdstdout[1]);  /* child's stdout write handle */

      /* write script to child process's STDIN pipe, close pipe */
      write(fdstdin[1], script, strlen(script));
      close(fdstdin[1]);

      /* read output from child's STDOUT pipe (and toss it), close pipe */
      while ((bytes = read(fdstdout[0], buf, sizeof(buf))) > 0)
#  ifdef LOG_TO_STDOUT  /* except during debugging, print it to stdout */
         printf("%.*s", bytes, buf)
#  endif
         ;

      close(fdstdout[0]);

      /* wait for child */
      if (waitpid(pid, &status, 0) >= 0)
         rv = WEXITSTATUS(status);
   }
   else                    /* child process */
   {
      /* close the pipe ends we don't need */
      close(fdstdin[1]);   /* child's stdin write handle */
      close(fdstdout[0]);  /* child's stdout read handle */

      /* dup STDIN read pipe handle onto stdin */
      if (fdstdin[0] != STDIN_FILENO)
      {
         int fdtmp = dup2(fdstdin[0], STDIN_FILENO);
         close(fdstdin[0]);
         if (fdtmp != STDIN_FILENO)
            exit(-1);
      }

      /* dup STDOUT write pipe handle onto stdout - ignore errors */
      if (fdstdout[1] != STDOUT_FILENO)
      {
         dup2(fdstdout[1], STDOUT_FILENO);
         close(fdstdout[1]);
      }

      /* dup STDOUT handle onto stderr - ignore errors */
      if (STDOUT_FILENO != STDERR_FILENO)
         dup2(STDOUT_FILENO, STDERR_FILENO); 

      /* now exec shell process, allow to inherit dup'ed handles */
      if (execl(shell, 0) < 0)
         exit(-1);

      /* [ == success or failure, we'll never leave this scope alive == ] */
   }
   return rv;

#endif   /* ?_WIN32 */
}

int xdasd_exec(const char * script, const char ** msgflds)
{
   int rv;
   char * text;

   if ((text = ex_substitute_vars(script, msgflds)) == 0)
      return -1;

   rv = ex_exec_script(text);

   free(text);
   return rv;
}

/*==========================================================================*/

#ifdef XDASD_EXEC_TEST

#include <stdarg.h>

void xdasd_log(int level, const char * fmt, ... ) 
{
#ifdef LOG_TO_STDOUT
   va_list args;
   va_start(args, fmt);
   vprintf(fmt, args);
   va_end(args);
#else
   (void)fmt;
#endif
}

int main(int argc, char ** argv)
{
   static char * script =
   {
      "echo \"Replace $XDAS with entire message (really long text).\"\n"
      "echo \"Replace $XDAS(10) with the 10th field (< than the var).\"\n"
      "echo \"Replace $XDAS(11) with the 11th field (> than the var).\""
   };
   static char * msg = 
   /*  0 */ "HDR:"
   /*  1 */ "00A8:"
   /*  2 */ "OX1:"
   /*  3 */ "2234934821:"
   /*  4 */ ":"
   /*  5 */ ":"
   /*  6 */ "time.nist.gov:"
   /*  7 */ "MST7MDT:"
   /*  8 */ "0x10000001:"
   /*  9 */ "0:"
   /* 10 */ "ORG:"
   /* 11 */ "org_location_name:"
   /* 12 */ "org_location_address:"
   /* 13 */ "org_service_type:"
   /* 14 */ "org_auth_authority:"
   /* 15 */ "org_principal_name:"
   /* 16 */ "org_principal_id:"
   /* 17 */ "INT:"
   /* 18 */ "int_auth_authority:"
   /* 19 */ "int_domain_specific_name:"
   /* 20 */ "int_domain_specific_id:"
   /* 21 */ "TGT:"
   /* 22 */ "tgt_location_name:"
   /* 23 */ "tgt_location_address:"
   /* 24 */ "tgt_service_type:"
   /* 25 */ "tgt_auth_authority:"
   /* 26 */ "tgt_principal_name:"
   /* 27 */ "tgt_principal_id:"
   /* 28 */ "SRC:"
   /* 29 */ "pointer_to_source_domain:"
   /* 30 */ "EVT:"
   /* 31 */ "event_specific_information:"
   /* 32 */ "END";

   unsigned i;
   char * cp = msg;
   const char * msgflds[XDAS_FIELD_COUNT + 1];

   (void)argc;
   (void)argv;

   for (i = 0; i < XDAS_FIELD_COUNT; i++)
   {
      msgflds[i] = cp;
      while (*cp && *cp != ':')
         cp++;
      cp++;
   }
   msgflds[i] = cp;

   return xdasd_exec(script, msgflds);
}

#endif