Annotation of parser3/src/main/pa_exec.C, revision 1.64
1.1 paf 1: /** @file
2: Parser: program executing for different OS-es.
3:
1.57 paf 4: Copyright(c) 2000,2001-2004 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.64 ! paf 10: static const char * const IDENT_EXEC_C="$Date: 2004/07/07 11:29:06 $";
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.51 paf 30: char *szEnv,
1.1 paf 31: PROCESS_INFORMATION* ppi,
32: LPHANDLE phInWrite,
33: LPHANDLE phOutRead,
1.9 parser 34: LPHANDLE phErrRead)
1.1 paf 35: {
1.51 paf 36: DWORD result=0;
1.36 paf 37: BOOL fCreated;
1.51 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)
46: sa.nLength=sizeof(sa);
47: sa.bInheritHandle=TRUE;
48: sa.lpSecurityDescriptor=NULL;
49:
50: // create STDIN pipe
51: if(!CreatePipe(&hInRead, phInWrite, &sa, 0))
52: goto error;
53:
54: // create STDOUT pipe
55: if(!CreatePipe(phOutRead, &hOutWrite, &sa, 0))
56: goto error;
57:
58: // create STDERR pipe
59: if(!CreatePipe(phErrRead, &hErrWrite, &sa, 0))
60: goto error;
61:
62: // process startup information
63: memset(&si, 0, sizeof(si));
64: si.cb=sizeof(si);
65: si.dwFlags=STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES;
66: // child process' console must be hidden for Win95 compatibility
67: si.wShowWindow=SW_HIDE;
68: // assign "other" sides of pipes
69: si.hStdInput=hInRead;
70: si.hStdOutput=hOutWrite;
71: si.hStdError=hErrWrite;
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
1.51 paf 78:
79: // Create a child process (suspended)
80: fCreated=CreateProcess(NULL,
81: (LPTSTR)szCmdLine,
82: NULL,
83: NULL,
84: TRUE,
85: CREATE_NO_WINDOW,
86: szEnv,
87: dir,
88: &si,
89: ppi);
1.36 paf 90: if(!fCreated)
91: result=GetLastError();
1.51 paf 92:
93: CloseHandle(hInRead);
94: CloseHandle(hOutWrite);
95: CloseHandle(hErrWrite);
96:
97: if(!fCreated)
98: goto error;
99:
100: return result;
101:
1.1 paf 102: error:
1.36 paf 103: if(!result/*yet*/)
104: result=GetLastError(); // get it
1.51 paf 105:
106: CloseHandle(*phInWrite);
107: CloseHandle(*phOutRead);
108: CloseHandle(*phErrRead);
109:
110: return result;
111: }
1.36 paf 112:
1.51 paf 113: static void read_pipe(String& result, HANDLE hOutRead, String::Language lang){
114: while(true) {
115: char *buf=new(PointerFreeGC) char[MAX_STRING];
116: unsigned long size;
117: if(!ReadFile(hOutRead, buf, MAX_STRING-1, &size, NULL) || !size)
118: break;
119: buf[size]=0;
120: result.append_know_length(buf, size, lang);
121: }
1.1 paf 122: }
123:
1.51 paf 124: static const char* buildCommand(const char* file_spec_cstr, const ArrayString& argv) {
125: const char* result=file_spec_cstr;
1.4 paf 126: if(FILE *f=fopen(file_spec_cstr, "r")) {
1.51 paf 127: try {
1.1 paf 128: char buf[MAX_STRING];
129: size_t size=fread(buf, 1, MAX_STRING-1, f);
130: if(size>2) {
131: buf[size]=0;
132: if(strncmp(buf, "#!", 2)==0) {
1.51 paf 133: const char* begin=buf+2;
1.4 paf 134: if(*begin==' ') // alx: were an old magic for some linux-es
135: begin++;
136: if(char *end=strchr(begin, '\n')) {
1.51 paf 137: String string(pa_strdup(begin, end-begin));
1.1 paf 138: string << " " << file_spec_cstr;
1.8 parser 139: result=string.cstr();
1.1 paf 140: }
141: }
142: }
1.51 paf 143: } catch(...) {
144: fclose(f);
145: rethrow;
146: }
1.1 paf 147: fclose(f);
148: }
1.51 paf 149: { // appending argv
150: String string(result);
151: for(size_t i=0; i<argv.count(); i++) {
152: string << " ";
153: string << *argv[i];
1.8 parser 154: }
155:
1.51 paf 156: result=string.cstr();
1.8 parser 157: }
158:
159: return result;
1.1 paf 160: }
161:
1.51 paf 162: #else
1.1 paf 163:
1.51 paf 164: static pid_t execve_piped(const char* file_spec_cstr,
1.27 paf 165: char * const argv[], char * const env[],
166: int *pipe_in, int *pipe_out, int *pipe_err) {
1.46 paf 167: pid_t pid;
1.1 paf 168: int in_fds[2];
169: int out_fds[2];
170: int err_fds[2];
171: int save_errno;
172:
173: if(pipe_in && pipe(in_fds)<0) {
174: save_errno=errno;
175: errno=save_errno;
176: return 0;
177: }
178:
179: if(pipe_out && pipe(out_fds)<0) {
180: save_errno=errno;
181: if(pipe_in) {
182: close(in_fds[0]); close(in_fds[1]);
183: }
184: errno=save_errno;
185: return 0;
186: }
187:
188: if(pipe_err && pipe(err_fds)<0) {
189: save_errno=errno;
190: if(pipe_in) {
191: close(in_fds[0]); close(in_fds[1]);
192: }
193: if(pipe_out) {
194: close(out_fds[0]); close(out_fds[1]);
195: }
196: errno=save_errno;
197: return 0;
198: }
199:
200: if((pid=fork())<0) {
201: save_errno=errno;
202: if(pipe_in) {
203: close(in_fds[0]); close(in_fds[1]);
204: }
205: if(pipe_out) {
206: close(out_fds[0]); close(out_fds[1]);
207: }
208: if(pipe_err) {
209: close(err_fds[0]); close(err_fds[1]);
210: }
211: errno=save_errno;
1.46 paf 212: return -1;
1.1 paf 213: }
214:
215: if(!pid) {
216: /* Child process */
217:
218: if(pipe_out) {
219: close(out_fds[0]);
220: dup2(out_fds[1], STDOUT_FILENO);
221: close(out_fds[1]);
222: }
223:
224: if(pipe_in) {
225: close(in_fds[1]);
226: dup2(in_fds[0], STDIN_FILENO);
227: close(in_fds[0]);
228: }
229:
230: if(pipe_err) {
231: close(err_fds[0]);
232: dup2(err_fds[1], STDERR_FILENO);
233: close(err_fds[1]);
234: }
235:
1.42 paf 236: /* grabbed this from Apache source: */
237: /* HP-UX SIGCHLD fix goes here, if someone will remind me what it is... */
1.1 paf 238: signal(SIGCHLD, SIG_DFL); /* Was that it? */
239:
1.31 paf 240: // chdir to script's directory
241: char dir[MAX_STRING];
242: strncpy(dir, file_spec_cstr, MAX_STRING-1); dir[MAX_STRING-1]=0;
243: rsplit(dir,'/'); // trim filename
244: chdir(dir);
245:
246: // execute
247: execve(file_spec_cstr, argv, env);
1.1 paf 248: exit(-errno);
249: }
250:
251: /* Parent process */
252:
253: if(pipe_out) {
254: close(out_fds[1]);
255: *pipe_out=out_fds[0];
256: }
257:
258: if(pipe_in) {
259: close(in_fds[0]);
260: *pipe_in=in_fds[1];
261: }
262:
263: if(pipe_err) {
264: close(err_fds[1]);
265: *pipe_err=err_fds[0];
266: }
267:
268: return pid;
269: }
270:
271: static int get_exit_status(int pid) {
272: int status;
1.58 paf 273: pid_t cid;
274: while ((cid=waitpid(pid, &status, WUNTRACED)) == -1 && errno == EINTR);
275: if(!cid)
1.1 paf 276: return -1;
277: return WIFEXITED(status) ?
278: WEXITSTATUS(status) : -2;
279: }
280:
1.51 paf 281: static void read_pipe(String& result, int file, String::Language lang){
1.1 paf 282: while(true) {
1.51 paf 283: char *buf=new(PointerFreeGC) char[MAX_STRING];
284: ssize_t length=read(file, buf, MAX_STRING-1);
285: if(length<=0)
1.49 paf 286: break;
1.51 paf 287: buf[length]=0;
288: result.append_know_length(buf, length, lang);
289: }
1.1 paf 290: }
291:
1.51 paf 292: #endif
1.1 paf 293:
1.51 paf 294: #ifndef DOXYGEN
295: struct Append_env_pair_info {
1.1 paf 296: #ifdef WIN32
1.62 paf 297: String::Body& body;
298: Append_env_pair_info(String::Body& abody): body(abody) {}
1.51 paf 299: #else
300: char **env_ref;
301: #endif
302: };
303: #endif
304: ///@test maybe here and at argv construction --- cstr(String::L_UNSPECIFIED
305: static void append_env_pair(HashStringString::key_type key, HashStringString::value_type value,
306: Append_env_pair_info *info) {
307: #ifdef WIN32
1.62 paf 308: info->body << key << "=" << value;
309: info->body.append_know_length("\1", 1); // placeholder for of zero byte
1.1 paf 310: #else
1.52 paf 311: String::Body body;
1.63 paf 312: body << key << "=" << value.cstr();
1.1 paf 313:
1.61 paf 314: *(info->env_ref++)=body.cstrm();
1.1 paf 315: #endif
316: }
1.31 paf 317:
1.51 paf 318: PA_exec_result pa_exec(
1.53 paf 319: bool
1.55 paf 320: #if defined(NO_PA_EXEC) || defined(PA_SAFE_MODE)
1.53 paf 321: forced_allow
322: #endif
323: ,
1.32 paf 324: const String& file_spec,
1.51 paf 325: const HashStringString* env,
326: const ArrayString& argv,
327: String& in) {
328: PA_exec_result result;
1.1 paf 329:
1.28 paf 330: #ifdef NO_PA_EXECS
1.32 paf 331: if(!forced_allow)
1.34 paf 332: throw Exception("parser.runtime",
1.32 paf 333: &file_spec,
334: "parser execs are disabled [recompile parser without --disable-execs configure option]");
335: #endif
1.28 paf 336:
1.1 paf 337: #ifdef WIN32
338:
339: PROCESS_INFORMATION pi;
340: HANDLE hInWrite, hOutRead, hErrRead;
1.51 paf 341: const char* cmd=buildCommand(file_spec.cstr(String::L_FILE_SPEC), argv);
1.53 paf 342: char* env_cstr=0;
1.1 paf 343: if(env) {
1.62 paf 344: String::Body body;
345: Append_env_pair_info info(body);
1.51 paf 346: env->for_each(append_env_pair, &info);
1.62 paf 347: env_cstr=info.body.cstrm();
1.51 paf 348: for(char* replacer=env_cstr; *replacer; replacer++)
349: if(*replacer=='\1')
350: *replacer=0;
1.1 paf 351: }
1.36 paf 352: if(DWORD error=CreateHiddenConsoleProcess(cmd, env_cstr, &pi, &hInWrite, &hOutRead, &hErrRead)) {
353: char szErrorDesc[MAX_STRING];
1.51 paf 354: const char* param="the file you tried to run";
1.36 paf 355: size_t error_size=FormatMessage(
356: FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_ARGUMENT_ARRAY , NULL, error,
357: MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL),
1.51 paf 358: szErrorDesc, sizeof(szErrorDesc), (va_list *)¶m);
1.36 paf 359: if(error_size>3) // ".\r\n"
360: szErrorDesc[error_size-3]=0;
361:
362: throw Exception(0,
363: &file_spec,
1.56 paf 364: "exec failed - %s (%u). Consider adding shbang line (#!x:\\interpreter\\command line)",
365: error_size?szErrorDesc:"<unknown>", error);
1.36 paf 366: } else {
1.51 paf 367: const char* in_cstr=in.cstr();
1.5 paf 368: DWORD written_size;
1.51 paf 369: WriteFile(hInWrite, in_cstr, in.length(), &written_size, NULL);
1.5 paf 370: // EOF for stupid text reads
371: // normally they should read CONTENT_LENGTH bytes,
372: // without this char
373: WriteFile(hInWrite, "\x1A", 1, &written_size, NULL);
1.9 parser 374: CloseHandle(hInWrite);
1.51 paf 375: read_pipe(result.out, hOutRead, String::L_AS_IS);
1.9 parser 376: CloseHandle(hOutRead);
1.51 paf 377: read_pipe(result.err, hErrRead, String::L_TAINTED);
1.9 parser 378: CloseHandle(hErrRead);
1.1 paf 379: /*
380: 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
381:
382: * We must close the handles to the new process and its main thread
383: * to prevent handle and memory leaks.
384: */
385: CloseHandle(pi.hProcess);
386: CloseHandle(pi.hThread);
387: }
388:
389: #else
1.53 paf 390:
391: // execve needs non const
392: char* file_spec_cstr=file_spec.cstrm(String::L_FILE_SPEC);
1.1 paf 393:
394: int pipe_write, pipe_read, pipe_err;
1.31 paf 395:
1.47 paf 396: #ifdef PA_SAFE_MODE
1.32 paf 397: if(!forced_allow) {
398: struct stat finfo;
399: if(stat(file_spec_cstr, &finfo)!=0)
1.34 paf 400: throw Exception("file.missing",
1.51 paf 401: &file_spec,
402: "stat failed: %s (%d), actual filename '%s'",
403: strerror(errno), errno, file_spec_cstr);
1.31 paf 404:
1.50 paf 405: check_safe_mode(finfo, file_spec, file_spec_cstr);
1.32 paf 406: }
1.31 paf 407: #endif
408:
1.51 paf 409: char* argv_cstrs[1+10+1]={file_spec_cstr, 0};
410: const int argv_size=argv.count();
411: const int argv_max=sizeof(argv_cstrs)/sizeof(argv_cstrs[0])-1-1;
412: if(argv_size>argv_max)
413: throw Exception("parser.runtime",
414: &file_spec,
415: "too many arguments (%d > max %d)", argv_size, argv_max);
416: for(int i=0; i<argv_size; i++)
417: argv_cstrs[1+i]=argv[i]->cstrm();
418: argv_cstrs[1+argv_size]=0;
419:
420: char **env_cstrs;
1.1 paf 421: if(env) {
1.51 paf 422: env_cstrs=new(PointerFreeGC) char *[env->count()+1/*0*/];
423: Append_env_pair_info info={env_cstrs};
424: env->for_each(append_env_pair, &info);
425: *info.env_ref=0;
426: } else
427: env_cstrs=0;
1.31 paf 428:
1.46 paf 429: pid_t pid=execve_piped(
1.1 paf 430: file_spec_cstr,
1.27 paf 431: argv_cstrs, env_cstrs,
1.22 paf 432: &pipe_write, &pipe_read, &pipe_err);
1.46 paf 433: if(pid>0) {
1.21 paf 434: // in child
1.51 paf 435: if(in.length()) {// there is some in data
436: const char* in_cstr=in.cstr();
437: write(pipe_write, in_cstr, in.length());
438: }
1.1 paf 439: close(pipe_write);
1.51 paf 440: read_pipe(result.out, pipe_read, String::L_AS_IS);
1.5 paf 441: close(pipe_read);
1.51 paf 442: read_pipe(result.err, pipe_err, String::L_TAINTED);
1.1 paf 443: close(pipe_err);
444:
1.51 paf 445: result.status=get_exit_status(pid); // negative may mean "-errno[execl()]"
1.59 paf 446: } else {
447: const char* str=strerror(errno);
1.34 paf 448: throw Exception(0,
1.2 paf 449: &file_spec,
1.59 paf 450: "%s error: %s (%d)", pid<0?"fork":"pipe", str?str:"<unknown>", errno);
451: }
1.1 paf 452: #endif
453:
1.51 paf 454: return result;
1.1 paf 455: }
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