Annotation of parser3/src/main/pa_exec.C, revision 1.36
1.1 paf 1: /** @file
2: Parser: program executing for different OS-es.
3:
1.24 paf 4: Copyright(c) 2000,2001, 2002 ArtLebedev Group(http://www.artlebedev.com)
1.25 paf 5: Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
1.1 paf 6:
1.36 ! paf 7: $Id: pa_exec.C,v 1.35 2002/04/16 09:38:49 paf Exp $
1.18 paf 8:
9:
10: @todo setrlimit
1.1 paf 11: */
12:
13: #include "pa_config_includes.h"
14:
1.19 paf 15: #include "pa_exec.h"
16: #include "pa_exception.h"
17: #include "pa_common.h"
18:
1.1 paf 19: #ifdef WIN32
20: # include <windows.h>
21: #else
22: # include <signal.h>
23: # include <sys/types.h>
24: # include <sys/wait.h>
25: #endif
26:
27: #ifdef WIN32
28:
29: /// this func from http://www.ccas.ru/~posp/popov/spawn.htm
1.36 ! paf 30: static DWORD CreateHiddenConsoleProcess(LPCTSTR szCmdLine,
1.1 paf 31: char *szEnv,
32: PROCESS_INFORMATION* ppi,
33: LPHANDLE phInWrite,
34: LPHANDLE phOutRead,
1.9 parser 35: LPHANDLE phErrRead)
1.1 paf 36: {
1.36 ! paf 37: DWORD result=0;
! 38: BOOL fCreated;
1.1 paf 39: STARTUPINFO si;
40: SECURITY_ATTRIBUTES sa={0};
41: HANDLE hInRead;
42: HANDLE hOutWrite;
43: HANDLE hErrWrite;
44:
45: // Create pipes
46: // initialize security attributes for handle inheritance (for WinNT)
1.9 parser 47: sa.nLength=sizeof(sa);
48: sa.bInheritHandle=TRUE;
49: sa.lpSecurityDescriptor=NULL;
1.1 paf 50:
51: // create STDIN pipe
1.9 parser 52: if(!CreatePipe(&hInRead, phInWrite, &sa, 0))
1.1 paf 53: goto error;
54:
55: // create STDOUT pipe
1.9 parser 56: if(!CreatePipe(phOutRead, &hOutWrite, &sa, 0))
1.1 paf 57: goto error;
58:
59: // create STDERR pipe
1.9 parser 60: if(!CreatePipe(phErrRead, &hErrWrite, &sa, 0))
1.1 paf 61: goto error;
62:
63: // process startup information
1.9 parser 64: memset(&si, 0, sizeof(si));
65: si.cb=sizeof(si);
66: si.dwFlags=STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;
1.1 paf 67: // child process' console must be hidden for Win95 compatibility
1.9 parser 68: si.wShowWindow=SW_HIDE;
1.1 paf 69: // assign "other" sides of pipes
1.9 parser 70: si.hStdInput=hInRead;
71: si.hStdOutput=hOutWrite;
72: si.hStdError=hErrWrite;
1.1 paf 73:
1.31 paf 74: // calculating script's directory
75: char dir[MAX_STRING];
76: strncpy(dir, szCmdLine, MAX_STRING-1); dir[MAX_STRING-1]=0;
1.33 paf 77: lsplit(dir,' '); // trim arguments
1.31 paf 78: rsplit(dir,'/'); rsplit(dir,'\\'); // trim filename
79: chdir(dir);
80:
1.1 paf 81: // Create a child process (suspended)
1.9 parser 82: fCreated=CreateProcess(NULL,
1.26 paf 83: (LPTSTR)szCmdLine,
1.1 paf 84: NULL,
85: NULL,
86: TRUE,
1.30 paf 87: CREATE_NO_WINDOW,
1.1 paf 88: szEnv,
1.31 paf 89: dir,
1.1 paf 90: &si,
1.9 parser 91: ppi);
1.36 ! paf 92: if(!fCreated)
! 93: result=GetLastError();
1.1 paf 94:
1.9 parser 95: CloseHandle(hInRead);
96: CloseHandle(hOutWrite);
97: CloseHandle(hErrWrite);
1.1 paf 98:
1.9 parser 99: if(!fCreated)
1.1 paf 100: goto error;
101:
1.36 ! paf 102: return result;
1.1 paf 103:
104: error:
1.36 ! paf 105: if(!result/*yet*/)
! 106: result=GetLastError(); // get it
! 107:
1.9 parser 108: CloseHandle(*phInWrite);
109: CloseHandle(*phOutRead);
110: CloseHandle(*phErrRead);
1.1 paf 111:
1.36 ! paf 112: return result;
1.1 paf 113: }
114:
1.35 paf 115: static void read_pipe(String& result, HANDLE hOutRead, const char *file_spec,
116: String::Untaint_lang lang){
1.1 paf 117: while(true) {
118: char *buf=(char *)result.pool().malloc(MAX_STRING);
119: unsigned long size;
1.30 paf 120: if(!ReadFile(hOutRead, buf, MAX_STRING, &size, NULL) || !size)
1.1 paf 121: break;
1.35 paf 122: result.APPEND(buf, size, lang, file_spec, 0);
1.1 paf 123: }
124: }
125:
126:
127: static const char *buildCommand(Pool& pool,
128: const String& origin_string,
129: const char *file_spec_cstr, const Array *argv) {
1.8 parser 130: const char *result=file_spec_cstr;
1.4 paf 131: if(FILE *f=fopen(file_spec_cstr, "r")) {
1.1 paf 132: char buf[MAX_STRING];
133: size_t size=fread(buf, 1, MAX_STRING-1, f);
134: if(size>2) {
135: buf[size]=0;
136: if(strncmp(buf, "#!", 2)==0) {
1.4 paf 137: const char *begin=buf+2;
138: if(*begin==' ') // alx: were an old magic for some linux-es
139: begin++;
140: if(char *end=strchr(begin, '\n')) {
1.1 paf 141: String string(pool);
1.4 paf 142: string.APPEND_AS_IS(begin, end-begin,
1.1 paf 143: origin_string.origin().file, 0);
144: string << " " << file_spec_cstr;
145: if(argv)
146: for(int i=0; i<argv->size(); i++)
1.16 paf 147: string << argv->get_string(i)->cstr();
1.8 parser 148: result=string.cstr();
1.1 paf 149: }
150: }
151: }
152: fclose(f);
153: }
1.8 parser 154: if(argv) {
155: String buf(pool);
156: buf << result;
157: for(int i=0; i<argv->size(); i++) {
158: buf << " ";
159: buf << *argv->get_string(i);
160: }
161:
1.16 paf 162: result=buf.cstr();
1.8 parser 163: }
164:
165: return result;
1.1 paf 166: }
167:
168: #else
169:
1.31 paf 170: static int execve_piped(const char *file_spec_cstr,
1.27 paf 171: char * const argv[], char * const env[],
172: int *pipe_in, int *pipe_out, int *pipe_err) {
1.1 paf 173: int pid;
174: int in_fds[2];
175: int out_fds[2];
176: int err_fds[2];
177: int save_errno;
178:
179: if(pipe_in && pipe(in_fds)<0) {
180: save_errno=errno;
181: errno=save_errno;
182: return 0;
183: }
184:
185: if(pipe_out && pipe(out_fds)<0) {
186: save_errno=errno;
187: if(pipe_in) {
188: close(in_fds[0]); close(in_fds[1]);
189: }
190: errno=save_errno;
191: return 0;
192: }
193:
194: if(pipe_err && pipe(err_fds)<0) {
195: save_errno=errno;
196: if(pipe_in) {
197: close(in_fds[0]); close(in_fds[1]);
198: }
199: if(pipe_out) {
200: close(out_fds[0]); close(out_fds[1]);
201: }
202: errno=save_errno;
203: return 0;
204: }
205:
206: if((pid=fork())<0) {
207: save_errno=errno;
208: if(pipe_in) {
209: close(in_fds[0]); close(in_fds[1]);
210: }
211: if(pipe_out) {
212: close(out_fds[0]); close(out_fds[1]);
213: }
214: if(pipe_err) {
215: close(err_fds[0]); close(err_fds[1]);
216: }
217: errno=save_errno;
218: return 0;
219: }
220:
221: if(!pid) {
222: /* Child process */
223:
224: if(pipe_out) {
225: close(out_fds[0]);
226: dup2(out_fds[1], STDOUT_FILENO);
227: close(out_fds[1]);
228: }
229:
230: if(pipe_in) {
231: close(in_fds[1]);
232: dup2(in_fds[0], STDIN_FILENO);
233: close(in_fds[0]);
234: }
235:
236: if(pipe_err) {
237: close(err_fds[0]);
238: dup2(err_fds[1], STDERR_FILENO);
239: close(err_fds[1]);
240: }
241:
242: /* HP-UX SIGCHLD fix goes here, if someone will remind me what it is... */
243: signal(SIGCHLD, SIG_DFL); /* Was that it? */
244:
1.31 paf 245: // chdir to script's directory
246: char dir[MAX_STRING];
247: strncpy(dir, file_spec_cstr, MAX_STRING-1); dir[MAX_STRING-1]=0;
248: rsplit(dir,'/'); // trim filename
249: chdir(dir);
250:
251: // execute
252: execve(file_spec_cstr, argv, env);
1.1 paf 253: exit(-errno);
254: }
255:
256: /* Parent process */
257:
258: if(pipe_out) {
259: close(out_fds[1]);
260: *pipe_out=out_fds[0];
261: }
262:
263: if(pipe_in) {
264: close(in_fds[0]);
265: *pipe_in=in_fds[1];
266: }
267:
268: if(pipe_err) {
269: close(err_fds[1]);
270: *pipe_err=err_fds[0];
271: }
272:
273: return pid;
274: }
275:
276: static int get_exit_status(int pid) {
277: int status;
278: if(!waitpid(pid, &status, 0))
279: return -1;
280: return WIFEXITED(status) ?
281: WEXITSTATUS(status) : -2;
282: }
283:
1.35 paf 284: static void read_pipe(String& result, int file, const char *file_spec, String::Untaint_lang lang){
1.1 paf 285: while(true) {
1.2 paf 286: char *buf=(char *)result.pool().malloc(MAX_STRING);
1.1 paf 287: size_t size=read(file, buf, MAX_STRING);
1.30 paf 288: if(!size)
1.1 paf 289: break;
1.35 paf 290: result.APPEND(buf, size, lang, file_spec, 0);
1.1 paf 291: }
292: }
293:
294: #endif
295:
1.30 paf 296: ///@test maybe here and at argv construction --- cstr(String::UL_UNSPECIFIED
1.1 paf 297: static void append_env_pair(const Hash::Key& key, Hash::Val *value, void *info) {
298: #ifdef WIN32
299: String& string=*static_cast<String *>(info);
300:
301: string << key << "=" << *static_cast<String *>(value);
1.3 paf 302: string.APPEND_AS_IS("", 1, 0, 0); // zero byte
1.1 paf 303: #else
304: String string(key.pool());
305: string << key << "=" << *static_cast<String *>(value);
306:
1.2 paf 307: char ***env_ref=static_cast<char ***>(info);
308: **env_ref=string.cstr(); (*env_ref)++;
1.1 paf 309: #endif
310: }
1.31 paf 311:
1.32 paf 312: int pa_exec(
313: bool forced_allow,
314: const String& file_spec,
1.1 paf 315: const Hash *env,
316: const Array *argv,
317: const String& in, String& out, String& err) {
318: Pool& pool=file_spec.pool();
319:
1.28 paf 320: #ifdef NO_PA_EXECS
1.32 paf 321: if(!forced_allow)
1.34 paf 322: throw Exception("parser.runtime",
1.32 paf 323: &file_spec,
324: "parser execs are disabled [recompile parser without --disable-execs configure option]");
325: #endif
1.28 paf 326:
1.1 paf 327: #ifdef WIN32
328:
329: PROCESS_INFORMATION pi;
330: HANDLE hInWrite, hOutRead, hErrRead;
1.12 parser 331: char *file_spec_cstr=file_spec.cstr(String::UL_FILE_SPEC);
1.1 paf 332: const char *cmd=buildCommand(file_spec.pool(), file_spec, file_spec_cstr, argv);
333: char *env_cstr=0;
334: if(env) {
335: String string(env->pool());
336: env->for_each(append_env_pair, &string);
1.16 paf 337: env_cstr=string.cstr();
1.1 paf 338: }
1.36 ! paf 339: if(DWORD error=CreateHiddenConsoleProcess(cmd, env_cstr, &pi, &hInWrite, &hOutRead, &hErrRead)) {
! 340: char szErrorDesc[MAX_STRING];
! 341: char *param="the file you tried to run";
! 342: size_t error_size=FormatMessage(
! 343: FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_ARGUMENT_ARRAY , NULL, error,
! 344: MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL),
! 345: szErrorDesc, sizeof(szErrorDesc), ¶m);
! 346: if(error_size>3) // ".\r\n"
! 347: szErrorDesc[error_size-3]=0;
! 348:
! 349: throw Exception(0,
! 350: &file_spec,
! 351: "exec failed - %s (%ld). Consider adding shbang line (#!x:\\interpreter\\command line)",
! 352: error_size?szErrorDesc:"<unknown>", (long)error);
! 353: } else {
1.16 paf 354: const char *in_cstr=in.cstr();
1.5 paf 355: DWORD written_size;
356: WriteFile(hInWrite, in_cstr, in.size(), &written_size, NULL);
357: // EOF for stupid text reads
358: // normally they should read CONTENT_LENGTH bytes,
359: // without this char
360: WriteFile(hInWrite, "\x1A", 1, &written_size, NULL);
1.9 parser 361: CloseHandle(hInWrite);
1.35 paf 362: read_pipe(out, hOutRead, file_spec_cstr, String::UL_AS_IS);
1.9 parser 363: CloseHandle(hOutRead);
1.35 paf 364: read_pipe(err, hErrRead, file_spec_cstr, String::UL_TAINTED);
1.9 parser 365: CloseHandle(hErrRead);
1.1 paf 366: /*
367: 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
368:
369: * We must close the handles to the new process and its main thread
370: * to prevent handle and memory leaks.
371: */
372: CloseHandle(pi.hProcess);
373: CloseHandle(pi.hThread);
374: }
375:
376: #else
377:
378: int pipe_write, pipe_read, pipe_err;
1.27 paf 379: char *file_spec_cstr=file_spec.cstr(String::UL_FILE_SPEC);
1.31 paf 380:
381: #ifdef NO_FOREIGN_GROUP_FILES
1.32 paf 382: if(!forced_allow) {
383: struct stat finfo;
384: if(stat(file_spec_cstr, &finfo)!=0)
1.34 paf 385: throw Exception("file.missing",
1.32 paf 386: &file_spec,
387: "stat failed: %s (%d), actual filename '%s'",
388: strerror(errno), errno, file_spec_cstr);
1.31 paf 389:
1.32 paf 390: if(finfo.st_gid/*foreign?*/!=getegid())
1.34 paf 391: throw Exception("parser.runtime",
1.32 paf 392: &file_spec,
393: "parser executing files of foreign group is disabled [recompile parser without --disable-foreign-group-files configure option], actual filename '%s'",
394: file_spec_cstr);
395: }
1.31 paf 396: #endif
397:
1.27 paf 398: char *argv_cstrs[1+10+1]={file_spec_cstr, 0};
1.1 paf 399: if(argv) {
1.20 paf 400: const int argv_size=argv->size();
1.27 paf 401: const int argv_max=sizeof(argv_cstrs)/sizeof(argv_cstrs[0])-1-1;
1.20 paf 402: if(argv_size>argv_max)
1.34 paf 403: throw Exception("parser.runtime",
1.20 paf 404: &file_spec,
405: "too many arguments (%d > max %d)", argv_size, argv_max);
406: for(int i=0; i<argv_size; i++)
1.27 paf 407: argv_cstrs[1+i]=argv->get_string(i)->cstr();
408: argv_cstrs[1+argv_size]=0;
1.1 paf 409: }
1.2 paf 410: char **env_cstrs=0;
1.1 paf 411: if(env) {
1.2 paf 412: env_cstrs=
1.1 paf 413: (char **)env->pool().malloc(sizeof(char *)*(env->size()+1/*0*/));
1.2 paf 414: char **env_ref=env_cstrs;
415: env->for_each(append_env_pair, &env_ref);
416: *env_ref=0;
1.1 paf 417: }
1.31 paf 418:
1.27 paf 419: int pid=execve_piped(
1.1 paf 420: file_spec_cstr,
1.27 paf 421: argv_cstrs, env_cstrs,
1.22 paf 422: &pipe_write, &pipe_read, &pipe_err);
1.21 paf 423: if(pid) {
424: // in child
1.16 paf 425: const char *in_cstr=in.cstr();
1.1 paf 426: write(pipe_write, in_cstr, in.size());
427: close(pipe_write);
1.35 paf 428: read_pipe(out, pipe_read, file_spec_cstr, String::UL_AS_IS);
1.5 paf 429: close(pipe_read);
1.35 paf 430: read_pipe(err, pipe_err, file_spec_cstr, String::UL_TAINTED);
1.1 paf 431: close(pipe_err);
432:
433: return get_exit_status(pid); // negative may mean "-errno[execl()]"
434: } else
1.34 paf 435: throw Exception(0,
1.2 paf 436: &file_spec,
1.1 paf 437: "pipe error");
438: #endif
439:
440: return 0;
441: }
E-mail:
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pa_exec.C CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [parser3project] / parser3 / src / main