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