[BACK]Return to pa_exec.C CVS log [TXT] [DIR] Up to [parser3project] / parser3 / src / main

Diff for /parser3/src/main/pa_exec.C between versions 1.2 and 1.46

version 1.2, 2001/04/17 19:00:41 version 1.46, 2002/12/24 08:31:31
Line 1 Line 1
 /** @file  /** @file
         Parser: program executing for different OS-es.          Parser: program executing for different OS-es.
   
         Copyright(c) 2000,2001 ArtLebedev Group(http://www.artlebedev.com)          Copyright(c) 2000,2001, 2002 ArtLebedev Group(http://www.artlebedev.com)
           Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
   
         Author: Alexander Petrosyan <paf@design.ru>(http://design.ru/paf)          @todo setrlimit
   
         $Id$  
 */  */
   
   static const char* IDENT_EXEC_C="$Date$";
   
 #include "pa_config_includes.h"  #include "pa_config_includes.h"
   
   #include "pa_exec.h"
   #include "pa_exception.h"
   #include "pa_common.h"
   
 #ifdef WIN32  #ifdef WIN32
 #       include <windows.h>  #       include <windows.h>
 #else  #else
Line 18 Line 23
 #       include <sys/wait.h>  #       include <sys/wait.h>
 #endif  #endif
   
 #include <stdio.h>  
 #include <errno.h>  
   
 #include "pa_exec.h"  
 #include "pa_exception.h"  
 #include "pa_common.h"  
   
   
 #ifdef WIN32  #ifdef WIN32
   
 /// this func from http://www.ccas.ru/~posp/popov/spawn.htm  /// this func from http://www.ccas.ru/~posp/popov/spawn.htm
 static BOOL WINAPI CreateHiddenConsoleProcess( LPCTSTR szChildName,  static DWORD CreateHiddenConsoleProcess(LPCTSTR szCmdLine,
                                                                                 char *szEnv,                                                                                  char *szEnv,
                                         PROCESS_INFORMATION* ppi,                                           PROCESS_INFORMATION* ppi, 
                                         LPHANDLE phInWrite,                                          LPHANDLE phInWrite,
                                         LPHANDLE phOutRead,                                          LPHANDLE phOutRead,
                                         LPHANDLE phErrRead )                                          LPHANDLE phErrRead)
 {  {
     BOOL fCreated;      DWORD result=0;
           BOOL fCreated;
     STARTUPINFO si;      STARTUPINFO si;
     SECURITY_ATTRIBUTES sa={0};      SECURITY_ATTRIBUTES sa={0};
     HANDLE hInRead;      HANDLE hInRead;
Line 45  static BOOL WINAPI CreateHiddenConsolePr Line 43  static BOOL WINAPI CreateHiddenConsolePr
   
     // Create pipes      // Create pipes
     // initialize security attributes for handle inheritance (for WinNT)      // initialize security attributes for handle inheritance (for WinNT)
     sa.nLength = sizeof( sa );      sa.nLength=sizeof(sa);
     sa.bInheritHandle = TRUE;      sa.bInheritHandle=TRUE;
     sa.lpSecurityDescriptor  = NULL;      sa.lpSecurityDescriptor=NULL;
   
     // create STDIN pipe      // create STDIN pipe
     if( !CreatePipe( &hInRead, phInWrite, &sa, 0 ))      if(!CreatePipe(&hInRead, phInWrite, &sa, 0))
         goto error;          goto error;
   
     // create STDOUT pipe      // create STDOUT pipe
     if( !CreatePipe( phOutRead, &hOutWrite, &sa, 0 ))      if(!CreatePipe(phOutRead, &hOutWrite, &sa, 0))
         goto error;          goto error;
   
     // create STDERR pipe      // create STDERR pipe
     if( !CreatePipe( phErrRead, &hErrWrite, &sa, 0 ))      if(!CreatePipe(phErrRead, &hErrWrite, &sa, 0))
         goto error;          goto error;
   
     // process startup information      // process startup information
     memset( &si, 0, sizeof( si ));      memset(&si, 0, sizeof(si));
     si.cb = sizeof( si );       si.cb=sizeof(si); 
     si.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;      si.dwFlags=STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;
     // child process' console must be hidden for Win95 compatibility      // child process' console must be hidden for Win95 compatibility
     si.wShowWindow = SW_HIDE;      si.wShowWindow=SW_HIDE;
     // assign "other" sides of pipes      // assign "other" sides of pipes
 //    si.hStdInput = hInRead;      si.hStdInput=hInRead;
     si.hStdOutput = hOutWrite;      si.hStdOutput=hOutWrite;
     si.hStdError = hErrWrite;      si.hStdError=hErrWrite;
   
           // calculating script's directory
           char dir[MAX_STRING];
           strncpy(dir, szCmdLine, MAX_STRING-1); dir[MAX_STRING-1]=0;
           lsplit(dir,' '); // trim arguments
           rsplit(dir,'/'); rsplit(dir,'\\'); // trim filename
           chdir(dir);
   
     // Create a child process (suspended)      // Create a child process (suspended)
     fCreated = CreateProcess( NULL,      fCreated=CreateProcess(NULL,
                               (LPTSTR)szChildName,                                (LPTSTR)szCmdLine,
                               NULL,                                NULL,
                               NULL,                                NULL,
                               TRUE,                                TRUE,
                               DETACHED_PROCESS,                                CREATE_NO_WINDOW,
                               szEnv,                                szEnv,
                               NULL,                                dir,
                               &si,                                &si,
                               ppi );                                ppi);
           if(!fCreated)
     CloseHandle( hInRead );                  result=GetLastError();
     CloseHandle( hOutWrite );  
     CloseHandle( hErrWrite );      CloseHandle(hInRead);
       CloseHandle(hOutWrite);
       CloseHandle(hErrWrite);
   
     if( !fCreated )      if(!fCreated)
         goto error;          goto error;
   
     return TRUE;      return result;
   
 error:  error:
     CloseHandle( *phInWrite );          if(!result/*yet*/)
     CloseHandle( *phOutRead );                  result=GetLastError(); // get it
     CloseHandle( *phErrRead );  
       CloseHandle(*phInWrite);
       CloseHandle(*phOutRead);
       CloseHandle(*phErrRead);
   
     return FALSE;      return result;
 }  }
   
 static void read_pipe(String& result, HANDLE hOutRead, const char *file_spec){  static void read_pipe(String& result, HANDLE hOutRead, const char *file_spec, 
                                             String::Untaint_lang lang){
         while(true) {          while(true) {
                 char *buf=(char *)result.pool().malloc(MAX_STRING);                  char *buf=(char *)result.pool().malloc(MAX_STRING);
                 unsigned long size;                  unsigned long size;
                 ReadFile( hOutRead, buf, MAX_STRING, &size, NULL );                  if(!ReadFile(hOutRead, buf, MAX_STRING, &size, NULL) || !size) 
                 if(!size)   
                         break;                          break;
                 result.APPEND_CLEAN(buf, size, file_spec, 0);                  result.APPEND(buf, size, lang, file_spec, 0);
     }      }
 }  }
   
Line 116  static void read_pipe(String& result, HA Line 126  static void read_pipe(String& result, HA
 static const char *buildCommand(Pool& pool,   static const char *buildCommand(Pool& pool, 
                                                                 const String& origin_string,                                                                  const String& origin_string,
                                                                 const char *file_spec_cstr, const Array *argv) {                                                                  const char *file_spec_cstr, const Array *argv) {
         FILE *f=fopen(file_spec_cstr, "r");          const char *result=file_spec_cstr;
         if(f) {          if(FILE *f=fopen(file_spec_cstr, "r")) {
                 char buf[MAX_STRING];                  char buf[MAX_STRING];
                 size_t size=fread(buf, 1, MAX_STRING-1, f);                  size_t size=fread(buf, 1, MAX_STRING-1, f);
                 if(size>2) {                  if(size>2) {
                         buf[size]=0;                          buf[size]=0;
                         if(strncmp(buf, "#!", 2)==0) {                          if(strncmp(buf, "#!", 2)==0) {
                                 char *atEOL=strchr(buf, '\n');                                  const char *begin=buf+2;
                                 if(atEOL) {                                  if(*begin==' ') // alx: were an old magic for some linux-es
                                           begin++;
                                   if(char *end=strchr(begin, '\n')) {
                                         String string(pool);                                          String string(pool);
                                         string.APPEND_CLEAN(buf+2, atEOL-(buf+2),                                           string.APPEND_AS_IS(begin, end-begin, 
                                                 origin_string.origin().file, 0);                                                  origin_string.origin().file, 0);
                                         string << " " << file_spec_cstr;                                          string << " " << file_spec_cstr;
                                         if(argv)                                          result=string.cstr();
                                                 for(int i=0; i<argv->size(); i++)  
                                                         string << argv->get_string(i)->cstr(String::UL_AS_IS);  
                                         file_spec_cstr=string.cstr();  
                                 }                                  }
                         }                          }
                 }                  }
                 fclose(f);                  fclose(f);
         }          }
         return file_spec_cstr;          if(argv) {
                   String buf(pool);
                   buf << result;
                   for(int i=0; i<argv->size(); i++) {
                           buf << " ";
                           buf << *argv->get_string(i);
                   }
   
                   result=buf.cstr();
           }
   
           return result;
 }  }
   
 #else  #else
   
 static int execle_piped(const char *path,   static pid_t execve_piped(const char *file_spec_cstr, 
                                                 const char *arg1,                          char * const argv[], char * const env[],
                                                 const char *arg2,                          int *pipe_in, int *pipe_out, int *pipe_err) {
                                                 const char *arg3,          pid_t pid;
                                                 const char *arg4,  
                                                 const char *arg5,  
                                                 char * const env[],  
                                                 int *pipe_in, int *pipe_out, int *pipe_err) {  
         int pid;  
         int in_fds[2];          int in_fds[2];
         int out_fds[2];          int out_fds[2];
         int err_fds[2];          int err_fds[2];
Line 196  static int execle_piped(const char *path Line 211  static int execle_piped(const char *path
                         close(err_fds[0]); close(err_fds[1]);                          close(err_fds[0]); close(err_fds[1]);
                 }                  }
                 errno=save_errno;                  errno=save_errno;
                 return 0;                  return -1;
         }          }
                   
         if(!pid) {          if(!pid) {
Line 220  static int execle_piped(const char *path Line 235  static int execle_piped(const char *path
                         close(err_fds[1]);                          close(err_fds[1]);
                 }                  }
                                   
                 /* HP-UX SIGCHLD fix goes here, if someone will remind me what it is... */                  /* grabbed this from Apache source: */
                   /*  HP-UX SIGCHLD fix goes here, if someone will remind me what it is... */
                 signal(SIGCHLD, SIG_DFL);       /* Was that it? */                  signal(SIGCHLD, SIG_DFL);       /* Was that it? */
                   
                 execle(path, arg1, arg2, arg3, arg4, arg5, NULL, env);                  // chdir to script's directory
                   char dir[MAX_STRING];
                   strncpy(dir, file_spec_cstr, MAX_STRING-1); dir[MAX_STRING-1]=0;
                   rsplit(dir,'/'); // trim filename
                   chdir(dir);
   
                   //  execute
                   execve(file_spec_cstr, argv, env);
                 exit(-errno);                  exit(-errno);
         }          }
                   
Line 255  static int get_exit_status(int pid) { Line 278  static int get_exit_status(int pid) {
                 WEXITSTATUS(status) : -2;                  WEXITSTATUS(status) : -2;
 }  }
   
 static void read_pipe(String& result, int file, const char *file_spec){  static void read_pipe(String& result, int file, const char *file_spec, String::Untaint_lang lang){
         while(true) {          while(true) {
                 char *buf=(char *)result.pool().malloc(MAX_STRING);                  char *buf=(char *)result.pool().malloc(MAX_STRING);
                 size_t size=read(file, buf, MAX_STRING);                  ssize_t size=read(file, buf, MAX_STRING);
                 if(!size)                   if(size<=0)
                         break;                          break;
                 result.APPEND_CLEAN(buf, size, file_spec, 0);                  result.APPEND(buf, size, lang, file_spec, 0);
     }      }
 }  }
   
 #endif  #endif
   
   ///@test maybe here and at argv construction --- cstr(String::UL_UNSPECIFIED
 static void append_env_pair(const Hash::Key& key, Hash::Val *value, void *info) {  static void append_env_pair(const Hash::Key& key, Hash::Val *value, void *info) {
 #ifdef WIN32  #ifdef WIN32
         String& string=*static_cast<String *>(info);          String& string=*static_cast<String *>(info);
                   
         string << key << "=" << *static_cast<String *>(value);          string << key << "=" << *static_cast<String *>(value);
         string.APPEND_CLEAN("", 1, 0, 0); // zero byte          string.APPEND_AS_IS("", 1, 0, 0); // zero byte
 #else  #else
         String string(key.pool());          String string(key.pool());
         string << key << "=" << *static_cast<String *>(value);          string << key << "=" << *static_cast<String *>(value);
   
         char ***env_ref=static_cast<char ***>(info);          char ***env_ref=static_cast<char ***>(info);
         **env_ref=string.cstr();  (*env_ref)++;          **env_ref=string.cstr(String::UL_UNSPECIFIED);  (*env_ref)++;
 #endif  #endif
 }  }
 int pa_exec(const String& file_spec,   
   int pa_exec(
                           bool forced_allow,
                           const String& file_spec, 
                         const Hash *env,                          const Hash *env,
                         const Array *argv,                          const Array *argv,
                         const String& in, String& out, String& err) {                          const String& in, String& out, String& err) {
         Pool& pool=file_spec.pool();          Pool& pool=file_spec.pool();
   
 #ifdef WIN32  #ifdef NO_PA_EXECS
           if(!forced_allow)
                   throw Exception("parser.runtime",
                           &file_spec,
                           "parser execs are disabled [recompile parser without --disable-execs configure option]");
   #endif
   
         char pwd[MAX_STRING];  #ifdef WIN32
         GetCurrentDirectory(sizeof(pwd), pwd);  
         char *dir=file_spec.cstr(String::UL_FILE_NAME);  
         rsplit(dir, '/'); SetCurrentDirectory(dir);  
   
         PROCESS_INFORMATION pi;           PROCESS_INFORMATION pi; 
         HANDLE hInWrite, hOutRead, hErrRead;          HANDLE hInWrite, hOutRead, hErrRead;
         char *file_spec_cstr=file_spec.cstr(String::UL_FILE_NAME);           char *file_spec_cstr=file_spec.cstr(String::UL_FILE_SPEC); 
         const char *cmd=buildCommand(file_spec.pool(), file_spec, file_spec_cstr, argv);          const char *cmd=buildCommand(file_spec.pool(), file_spec, file_spec_cstr, argv);
         char *env_cstr=0;          char *env_cstr=0;
         if(env) {          if(env) {
                 String string(env->pool());                  String string(env->pool());
                 env->for_each(append_env_pair, &string);                  env->for_each(append_env_pair, &string);
                 env_cstr=string.cstr(String::UL_AS_IS);                  env_cstr=string.cstr(String::UL_UNSPECIFIED);
         }          }
         if( CreateHiddenConsoleProcess(cmd, env_cstr, &pi, &hInWrite, &hOutRead, &hErrRead )) {          if(DWORD error=CreateHiddenConsoleProcess(cmd, env_cstr, &pi, &hInWrite, &hOutRead, &hErrRead)) {
                 SetCurrentDirectory(pwd);                  char szErrorDesc[MAX_STRING];
                   char *param="the file you tried to run";
                 read_pipe(out, hOutRead, file_spec_cstr);                  size_t error_size=FormatMessage(
                 read_pipe(err, hErrRead, file_spec_cstr);                          FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_ARGUMENT_ARRAY , NULL, error,
                 CloseHandle( hInWrite );                          MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL),
                 CloseHandle( hOutRead );                          szErrorDesc, sizeof(szErrorDesc), &param);
                 CloseHandle( hErrRead );                  if(error_size>3) // ".\r\n"
                           szErrorDesc[error_size-3]=0;
               
                   throw Exception(0,
                           &file_spec,
                           "exec failed - %s (%ld). Consider adding shbang line (#!x:\\interpreter\\command line)", 
                                   error_size?szErrorDesc:"<unknown>", (long)error);
           } else {
                   const char *in_cstr=in.cstr();
                   DWORD written_size;
                   WriteFile(hInWrite, in_cstr, in.size(), &written_size, NULL);
                   // EOF for stupid text reads
                   // normally they should read CONTENT_LENGTH bytes,
                   // without this char
                   WriteFile(hInWrite, "\x1A", 1, &written_size, NULL);
                   CloseHandle(hInWrite);
                   read_pipe(out, hOutRead, file_spec_cstr, String::UL_AS_IS);
                   CloseHandle(hOutRead);
                   read_pipe(err, hErrRead, file_spec_cstr, String::UL_TAINTED);           
                   CloseHandle(hErrRead);
 /*        /*      
 from http://www.apache.org/websrc/cvsweb.cgi/apache-1.3/src/main/util_script.c?rev=1.151&content-type=text/vnd.viewcvs-markup  from http://www.apache.org/websrc/cvsweb.cgi/apache-1.3/src/main/util_script.c?rev=1.151&content-type=text/vnd.viewcvs-markup
   
Line 320  from http://www.apache.org/websrc/cvsweb Line 368  from http://www.apache.org/websrc/cvsweb
 */        */      
                 CloseHandle(pi.hProcess);                  CloseHandle(pi.hProcess);
         CloseHandle(pi.hThread);          CloseHandle(pi.hThread);
         } else {  
                 SetCurrentDirectory(pwd);  
   
                 DWORD error=GetLastError();  
                 char szErrorDesc[MAX_STRING];  
                 FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, error,  
                 MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL),  
                 szErrorDesc, sizeof(szErrorDesc), NULL);  
                 size_t error_size=strlen(szErrorDesc);  
                 if(error_size>3) // ".\r\n"  
                         szErrorDesc[error_size-3]=0;  
               
                 PTHROW(0, 0,  
                         &file_spec,  
                         "exec failed - %s (%d)",  
                                 szErrorDesc,  
                                 (long)error);  
         }          }
   
 #else  #else
   
         int pipe_write, pipe_read, pipe_err;          int pipe_write, pipe_read, pipe_err;
         const char *argv_cstrs[5]={"", "", "", "", ""};          char *file_spec_cstr=file_spec.cstr(String::UL_FILE_SPEC);
   
   #ifdef NO_FOREIGN_GROUP_FILES
           if(!forced_allow) {
                   struct stat finfo;
                   if(stat(file_spec_cstr, &finfo)!=0)
                           throw Exception("file.missing", 
                                           &file_spec, 
                                           "stat failed: %s (%d), actual filename '%s'", 
                                                   strerror(errno), errno, file_spec_cstr);
   
                   if(finfo.st_gid/*foreign?*/!=getegid())
                           throw Exception("parser.runtime",
                                   &file_spec,
                                   "parser executing files of foreign group is     disabled [recompile parser without --disable-foreign-group-files configure option], actual filename '%s'", 
                                           file_spec_cstr);
           }
   #endif
   
           char *argv_cstrs[1+10+1]={file_spec_cstr, 0};
         if(argv) {          if(argv) {
                 int size=min(5, argv->size());                  const int argv_size=argv->size();
                 for(int i=0; i<size; i++)                  const int argv_max=sizeof(argv_cstrs)/sizeof(argv_cstrs[0])-1-1;
                         argv_cstrs[i]=argv->get_string(i)->cstr(String::UL_AS_IS);                  if(argv_size>argv_max)
                           throw Exception("parser.runtime",
                                   &file_spec,
                                   "too many arguments (%d > max %d)", argv_size, argv_max);
                   for(int i=0; i<argv_size; i++)
                           argv_cstrs[1+i]=argv->get_string(i)->cstr();
                   argv_cstrs[1+argv_size]=0;
         }          }
         const char *file_spec_cstr=file_spec.cstr(String::UL_FILE_NAME);  
         char **env_cstrs=0;          char **env_cstrs=0;
         if(env) {          if(env) {
                 env_cstrs=                  env_cstrs=
Line 357  from http://www.apache.org/websrc/cvsweb Line 412  from http://www.apache.org/websrc/cvsweb
                 env->for_each(append_env_pair, &env_ref);                  env->for_each(append_env_pair, &env_ref);
                 *env_ref=0;                  *env_ref=0;
         }          }
         if(int pid=execle_piped(  
                 file_spec_cstr,  
                 argv_cstrs[0], argv_cstrs[1], argv_cstrs[2], argv_cstrs[3], argv_cstrs[4],  
                 env_cstrs,  
                 &pipe_write, &pipe_read, &pipe_err)) {  
   
                 const char *in_cstr=in.cstr(String::UL_AS_IS);          pid_t pid=execve_piped(
                 write(pipe_write, in_cstr, in.size());                  file_spec_cstr,
                   argv_cstrs, env_cstrs,
                   &pipe_write, &pipe_read, &pipe_err);
           if(pid>0) {
                   // in child
                   const char *in_cstr=in.cstr();
                   if(*in_cstr) // there is some in data
                           write(pipe_write, in_cstr, in.size());
                 close(pipe_write);                  close(pipe_write);
                 read_pipe(out, pipe_read, file_spec_cstr);                  read_pipe(out, pipe_read, file_spec_cstr, String::UL_AS_IS);
                 read_pipe(err, pipe_err, file_spec_cstr);  
                 close(pipe_read);                  close(pipe_read);
                   read_pipe(err, pipe_err, file_spec_cstr, String::UL_TAINTED);
                 close(pipe_err);                  close(pipe_err);
   
                 return get_exit_status(pid); // negative may mean "-errno[execl()]"                  return get_exit_status(pid); // negative may mean "-errno[execl()]"
         } else           } else 
                 PTHROW(0, 0,                  throw Exception(0,
                         &file_spec,                          &file_spec,
                         "pipe error");                          "%s error: %s (%d)", pid<0?"fork":"pipe", strerror(errno), errno); 
 #endif  #endif
   
         return 0;          return 0;
Removed from v.1.2  
changed lines
  Added in v.1.46

E-mail: