1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26
27 /*
28 * dosys.cc
29 *
30 * Execute one commandline
31 */
32
33 /*
34 * Included files
35 */
36 #include <sys/wait.h> /* WIFEXITED(status) */
37 #include <avo/avo_alloca.h> /* alloca() */
38
39 #if defined(TEAMWARE_MAKE_CMN) || defined(MAKETOOL) /* tolik */
40 # include <avo/strings.h> /* AVO_STRDUP() */
41 #if defined(DISTRIBUTED)
42 # include <dm/Avo_CmdOutput.h>
43 # include <rw/xdrstrea.h>
44 #endif
45 #endif
46
47 #include <stdio.h> /* errno */
48 #include <errno.h> /* errno */
49 #include <fcntl.h> /* open() */
50 #include <mksh/dosys.h>
51 #include <mksh/macro.h> /* getvar() */
52 #include <mksh/misc.h> /* getmem(), fatal_mksh(), errmsg() */
53 #include <mksdmsi18n/mksdmsi18n.h> /* libmksdmsi18n_init() */
54 #include <sys/signal.h> /* SIG_DFL */
55 #include <sys/stat.h> /* open() */
56 #include <sys/wait.h> /* wait() */
57 #include <ulimit.h> /* ulimit() */
58 #include <unistd.h> /* close(), dup2() */
59
60
61
62 /*
63 * Defined macros
64 */
65 #if defined(DISTRIBUTED) || defined(MAKETOOL) /* tolik */
66 #define SEND_MTOOL_MSG(cmds) \
67 if (send_mtool_msgs) { \
68 cmds \
69 }
70 #else
71 #define SEND_MTOOL_MSG(cmds)
72 #endif
73
74 /*
75 * typedefs & structs
76 */
77
78 /*
79 * Static variables
80 */
81
82 /*
83 * File table of contents
84 */
85 static Boolean exec_vp(register char *name, register char **argv, char **envp, register Boolean ignore_error, pathpt vroot_path);
86
87 /*
88 * Workaround for NFS bug. Sometimes, when running 'open' on a remote
89 * dmake server, it fails with "Stale NFS file handle" error.
90 * The second attempt seems to work.
91 */
92 int
93 my_open(const char *path, int oflag, mode_t mode) {
94 int res = open(path, oflag, mode);
95 if (res < 0 && (errno == ESTALE || errno == EAGAIN)) {
96 /* Stale NFS file handle. Try again */
97 res = open(path, oflag, mode);
98 }
99 return res;
100 }
101
102 /*
103 * void
104 * redirect_io(char *stdout_file, char *stderr_file)
105 *
106 * Redirects stdout and stderr for a child mksh process.
107 */
108 void
109 redirect_io(char *stdout_file, char *stderr_file)
110 {
111 long descriptor_limit;
112 int i;
113
114 if ((descriptor_limit = ulimit(UL_GDESLIM)) < 0) {
115 fatal_mksh(catgets(libmksdmsi18n_catd, 1, 89, "ulimit() failed: %s"), errmsg(errno));
116 }
117 for (i = 3; i < descriptor_limit; i++) {
118 (void) close(i);
119 }
120 if ((i = my_open(stdout_file,
121 O_WRONLY | O_CREAT | O_TRUNC | O_DSYNC,
122 S_IREAD | S_IWRITE)) < 0) {
123 fatal_mksh(catgets(libmksdmsi18n_catd, 1, 90, "Couldn't open standard out temp file `%s': %s"),
124 stdout_file,
125 errmsg(errno));
126 } else {
127 if (dup2(i, 1) == -1) {
128 fatal_mksh(NOCATGETS("*** Error: dup2(3, 1) failed: %s"),
129 errmsg(errno));
130 }
131 close(i);
132 }
133 if (stderr_file == NULL) {
134 if (dup2(1, 2) == -1) {
135 fatal_mksh(NOCATGETS("*** Error: dup2(1, 2) failed: %s"),
136 errmsg(errno));
137 }
138 } else if ((i = my_open(stderr_file,
139 O_WRONLY | O_CREAT | O_TRUNC | O_DSYNC,
140 S_IREAD | S_IWRITE)) < 0) {
141 fatal_mksh(catgets(libmksdmsi18n_catd, 1, 91, "Couldn't open standard error temp file `%s': %s"),
142 stderr_file,
143 errmsg(errno));
144 } else {
145 if (dup2(i, 2) == -1) {
146 fatal_mksh(NOCATGETS("*** Error: dup2(3, 2) failed: %s"),
147 errmsg(errno));
148 }
149 close(i);
150 }
151 }
152
153 /*
154 * dosys_mksh(command, ignore_error, call_make, silent_error, target)
155 *
156 * Check if command string contains meta chars and dispatch to
157 * the proper routine for executing one command line.
158 *
159 * Return value:
160 * Indicates if the command execution failed
161 *
162 * Parameters:
163 * command The command to run
164 * ignore_error Should we abort when an error is seen?
165 * call_make Did command reference $(MAKE) ?
166 * silent_error Should error messages be suppressed for dmake?
167 * target Target we are building
168 *
169 * Global variables used:
170 * do_not_exec_rule Is -n on?
171 * working_on_targets We started processing real targets
172 */
173 Doname
174 dosys_mksh(register Name command, register Boolean ignore_error, register Boolean call_make, Boolean silent_error, Boolean always_exec, Name target, Boolean redirect_out_err, char *stdout_file, char *stderr_file, pathpt vroot_path, int nice_prio)
175 {
176 register int length = command->hash.length;
177 register wchar_t *p;
178 register wchar_t *q;
179 register wchar_t *cmd_string;
180 struct stat before;
181 Doname result;
182 Boolean working_on_targets_mksh = true;
183 Wstring wcb(command);
184 p = wcb.get_string();
185 cmd_string = p;
186
187 /* Strip spaces from head of command string */
188 while (iswspace(*p)) {
189 p++, length--;
190 }
191 if (*p == (int) nul_char) {
192 return build_failed;
193 }
194 /* If we are faking it we just return */
195 if (do_not_exec_rule &&
196 working_on_targets_mksh &&
197 !call_make &&
198 !always_exec) {
199 return build_ok;
200 }
201
202 /* Copy string to make it OK to write it. */
203 q = ALLOC_WC(length + 1);
204 (void) wscpy(q, p);
205 /* Write the state file iff this command uses make. */
206 /* XXX - currently does not support recursive make's, $(MAKE)'s
207 if (call_make && command_changed) {
208 write_state_file(0, false);
209 }
210 (void) stat(make_state->string_mb, &before);
211 */
212 /*
213 * Run command directly if it contains no shell meta chars,
214 * else run it using the shell.
215 */
216 /* XXX - command->meta *may* not be set correctly */
217 if (await(ignore_error,
218 silent_error,
219 target,
220 cmd_string,
221 command->meta ?
222 doshell(q, ignore_error, redirect_out_err, stdout_file, stderr_file, nice_prio) :
223 doexec(q, ignore_error, redirect_out_err, stdout_file, stderr_file, vroot_path, nice_prio),
224 false,
225 NULL,
226 -1)) {
227
228 #ifdef PRINT_EXIT_STATUS
229 warning_mksh(NOCATGETS("I'm in dosys_mksh(), and await() returned result of build_ok."));
230 #endif
231
232 result = build_ok;
233 } else {
234
235 #ifdef PRINT_EXIT_STATUS
236 warning_mksh(NOCATGETS("I'm in dosys_mksh(), and await() returned result of build_failed."));
237 #endif
238
239 result = build_failed;
240 }
241 retmem(q);
242
243 /* XXX - currently does not support recursive make's, $(MAKE)'s
244 if ((report_dependencies_level == 0) &&
245 call_make) {
246 make_state->stat.time = (time_t)file_no_time;
247 (void)exists(make_state);
248 if (before.st_mtime == make_state->stat.time) {
249 return result;
250 }
251 makefile_type = reading_statefile;
252 if (read_trace_level > 1) {
253 trace_reader = true;
254 }
255 (void) read_simple_file(make_state,
256 false,
257 false,
258 false,
259 false,
260 false,
261 true);
262 trace_reader = false;
263 }
264 */
265 return result;
266 }
267
268 /*
269 * doshell(command, ignore_error)
270 *
271 * Used to run command lines that include shell meta-characters.
272 * The make macro SHELL is supposed to contain a path to the shell.
273 *
274 * Return value:
275 * The pid of the process we started
276 *
277 * Parameters:
278 * command The command to run
279 * ignore_error Should we abort on error?
280 *
281 * Global variables used:
282 * filter_stderr If -X is on we redirect stderr
283 * shell_name The Name "SHELL", used to get the path to shell
284 */
285 int
286 doshell(wchar_t *command, register Boolean ignore_error, Boolean redirect_out_err, char *stdout_file, char *stderr_file, int nice_prio)
287 {
288 char *argv[6];
289 int argv_index = 0;
290 int cmd_argv_index;
291 int length;
292 char nice_prio_buf[MAXPATHLEN];
293 register Name shell = getvar(shell_name);
294 register char *shellname;
295 char *tmp_mbs_buffer;
296
297
298 if (IS_EQUAL(shell->string_mb, "")) {
299 shell = shell_name;
300 }
301 if ((shellname = strrchr(shell->string_mb, (int) slash_char)) == NULL) {
302 shellname = shell->string_mb;
303 } else {
304 shellname++;
305 }
306
307 /*
308 * Only prepend the /usr/bin/nice command to the original command
309 * if the nice priority, nice_prio, is NOT zero (0).
310 * Nice priorities can be a positive or a negative number.
311 */
312 if (nice_prio != 0) {
313 argv[argv_index++] = (char *)NOCATGETS("nice");
314 (void) sprintf(nice_prio_buf, NOCATGETS("-%d"), nice_prio);
315 argv[argv_index++] = strdup(nice_prio_buf);
316 }
317 argv[argv_index++] = shellname;
318 argv[argv_index++] = (char*)(ignore_error ? NOCATGETS("-c") : NOCATGETS("-ce"));
319 if ((length = wslen(command)) >= MAXPATHLEN) {
320 tmp_mbs_buffer = getmem((length * MB_LEN_MAX) + 1);
321 (void) wcstombs(tmp_mbs_buffer, command, (length * MB_LEN_MAX) + 1);
322 cmd_argv_index = argv_index;
323 argv[argv_index++] = strdup(tmp_mbs_buffer);
324 retmem_mb(tmp_mbs_buffer);
325 } else {
326 WCSTOMBS(mbs_buffer, command);
327 cmd_argv_index = argv_index;
328 argv[argv_index++] = strdup(mbs_buffer);
329 }
330 argv[argv_index] = NULL;
331 (void) fflush(stdout);
332 if ((childPid = fork()) == 0) {
333 enable_interrupt((void (*) (int)) SIG_DFL);
334 if (redirect_out_err) {
335 redirect_io(stdout_file, stderr_file);
336 }
337 #if 0
338 if (filter_stderr) {
339 redirect_stderr();
340 }
341 #endif
342 if (nice_prio != 0) {
343 (void) execve(NOCATGETS("/usr/bin/nice"), argv, environ);
344 fatal_mksh(catgets(libmksdmsi18n_catd, 1, 92, "Could not load `/usr/bin/nice': %s"),
345 errmsg(errno));
346 } else {
347 (void) execve(shell->string_mb, argv, environ);
348 fatal_mksh(catgets(libmksdmsi18n_catd, 1, 93, "Could not load Shell from `%s': %s"),
349 shell->string_mb,
350 errmsg(errno));
351 }
352 }
353 if (childPid == -1) {
354 fatal_mksh(catgets(libmksdmsi18n_catd, 1, 94, "fork failed: %s"),
355 errmsg(errno));
356 }
357 retmem_mb(argv[cmd_argv_index]);
358 return childPid;
359 }
360
361 /*
362 * exec_vp(name, argv, envp, ignore_error)
363 *
364 * Like execve, but does path search.
365 * This starts command when make invokes it directly (without a shell).
366 *
367 * Return value:
368 * Returns false if the exec failed
369 *
370 * Parameters:
371 * name The name of the command to run
372 * argv Arguments for the command
373 * envp The environment for it
374 * ignore_error Should we abort on error?
375 *
376 * Global variables used:
377 * shell_name The Name "SHELL", used to get the path to shell
378 * vroot_path The path used by the vroot package
379 */
380 static Boolean
381 exec_vp(register char *name, register char **argv, char **envp, register Boolean ignore_error, pathpt vroot_path)
382 {
383 register Name shell = getvar(shell_name);
384 register char *shellname;
385 char *shargv[4];
386 Name tmp_shell;
387
388 if (IS_EQUAL(shell->string_mb, "")) {
389 shell = shell_name;
390 }
391
392 for (int i = 0; i < 5; i++) {
393 (void) execve_vroot(name,
394 argv + 1,
395 envp,
396 vroot_path,
397 VROOT_DEFAULT);
398 switch (errno) {
399 case ENOEXEC:
400 case ENOENT:
401 /* That failed. Let the shell handle it */
402 shellname = strrchr(shell->string_mb, (int) slash_char);
403 if (shellname == NULL) {
404 shellname = shell->string_mb;
405 } else {
406 shellname++;
407 }
408 shargv[0] = shellname;
409 shargv[1] = (char*)(ignore_error ? NOCATGETS("-c") : NOCATGETS("-ce"));
410 shargv[2] = argv[0];
411 shargv[3] = NULL;
412 tmp_shell = getvar(shell_name);
413 if (IS_EQUAL(tmp_shell->string_mb, "")) {
414 tmp_shell = shell_name;
415 }
416 (void) execve_vroot(tmp_shell->string_mb,
417 shargv,
418 envp,
419 vroot_path,
420 VROOT_DEFAULT);
421 return failed;
422 case ETXTBSY:
423 /*
424 * The program is busy (debugged?).
425 * Wait and then try again.
426 */
427 (void) sleep((unsigned) i);
428 case EAGAIN:
429 break;
430 default:
431 return failed;
432 }
433 }
434 return failed;
435 }
436
437 /*
438 * doexec(command, ignore_error)
439 *
440 * Will scan an argument string and split it into words
441 * thus building an argument list that can be passed to exec_ve()
442 *
443 * Return value:
444 * The pid of the process started here
445 *
446 * Parameters:
447 * command The command to run
448 * ignore_error Should we abort on error?
449 *
450 * Global variables used:
451 * filter_stderr If -X is on we redirect stderr
452 */
453 int
454 doexec(register wchar_t *command, register Boolean ignore_error, Boolean redirect_out_err, char *stdout_file, char *stderr_file, pathpt vroot_path, int nice_prio)
455 {
456 int arg_count = 5;
457 char **argv;
458 int length;
459 char nice_prio_buf[MAXPATHLEN];
460 register char **p;
461 wchar_t *q;
462 register wchar_t *t;
463 char *tmp_mbs_buffer;
464
465 /*
466 * Only prepend the /usr/bin/nice command to the original command
467 * if the nice priority, nice_prio, is NOT zero (0).
468 * Nice priorities can be a positive or a negative number.
469 */
470 if (nice_prio != 0) {
471 arg_count += 2;
472 }
473 for (t = command; *t != (int) nul_char; t++) {
474 if (iswspace(*t)) {
475 arg_count++;
476 }
477 }
478 argv = (char **)alloca(arg_count * (sizeof(char *)));
479 /*
480 * Reserve argv[0] for sh in case of exec_vp failure.
481 * Don't worry about prepending /usr/bin/nice command to argv[0].
482 * In fact, doing it may cause the sh command to fail!
483 */
484 p = &argv[1];
485 if ((length = wslen(command)) >= MAXPATHLEN) {
486 tmp_mbs_buffer = getmem((length * MB_LEN_MAX) + 1);
487 (void) wcstombs(tmp_mbs_buffer, command, (length * MB_LEN_MAX) + 1);
488 argv[0] = strdup(tmp_mbs_buffer);
489 retmem_mb(tmp_mbs_buffer);
490 } else {
491 WCSTOMBS(mbs_buffer, command);
492 argv[0] = strdup(mbs_buffer);
493 }
494
495 if (nice_prio != 0) {
496 *p++ = strdup(NOCATGETS("/usr/bin/nice"));
497 (void) sprintf(nice_prio_buf, NOCATGETS("-%d"), nice_prio);
498 *p++ = strdup(nice_prio_buf);
499 }
500 /* Build list of argument words. */
501 for (t = command; *t;) {
502 if (p >= &argv[arg_count]) {
503 /* This should never happen, right? */
504 WCSTOMBS(mbs_buffer, command);
505 fatal_mksh(catgets(libmksdmsi18n_catd, 1, 95, "Command `%s' has more than %d arguments"),
506 mbs_buffer,
507 arg_count);
508 }
509 q = t;
510 while (!iswspace(*t) && (*t != (int) nul_char)) {
511 t++;
512 }
513 if (*t) {
514 for (*t++ = (int) nul_char; iswspace(*t); t++);
515 }
516 if ((length = wslen(q)) >= MAXPATHLEN) {
517 tmp_mbs_buffer = getmem((length * MB_LEN_MAX) + 1);
518 (void) wcstombs(tmp_mbs_buffer, q, (length * MB_LEN_MAX) + 1);
519 *p++ = strdup(tmp_mbs_buffer);
520 retmem_mb(tmp_mbs_buffer);
521 } else {
522 WCSTOMBS(mbs_buffer, q);
523 *p++ = strdup(mbs_buffer);
524 }
525 }
526 *p = NULL;
527
528 /* Then exec the command with that argument list. */
529 (void) fflush(stdout);
530 if ((childPid = fork()) == 0) {
531 enable_interrupt((void (*) (int)) SIG_DFL);
532 if (redirect_out_err) {
533 redirect_io(stdout_file, stderr_file);
534 }
535 #if 0
536 if (filter_stderr) {
537 redirect_stderr();
538 }
539 #endif
540 (void) exec_vp(argv[1], argv, environ, ignore_error, vroot_path);
541 fatal_mksh(catgets(libmksdmsi18n_catd, 1, 96, "Cannot load command `%s': %s"), argv[1], errmsg(errno));
542 }
543 if (childPid == -1) {
544 fatal_mksh(catgets(libmksdmsi18n_catd, 1, 97, "fork failed: %s"),
545 errmsg(errno));
546 }
547 for (int i = 0; argv[i] != NULL; i++) {
548 retmem_mb(argv[i]);
549 }
550 return childPid;
551 }
552
553 /*
554 * await(ignore_error, silent_error, target, command, running_pid)
555 *
556 * Wait for one child process and analyzes
557 * the returned status when the child process terminates.
558 *
559 * Return value:
560 * Returns true if commands ran OK
561 *
562 * Parameters:
563 * ignore_error Should we abort on error?
564 * silent_error Should error messages be suppressed for dmake?
565 * target The target we are building, for error msgs
566 * command The command we ran, for error msgs
567 * running_pid The pid of the process we are waiting for
568 *
569 * Static variables used:
570 * filter_file The fd for the filter file
571 * filter_file_name The name of the filter file
572 *
573 * Global variables used:
574 * filter_stderr Set if -X is on
575 */
576 #if defined(DISTRIBUTED) || defined(MAKETOOL) /* tolik */
577 Boolean
578 await(register Boolean ignore_error, register Boolean silent_error, Name target, wchar_t *command, pid_t running_pid, Boolean send_mtool_msgs, XDR *xdrs_p, int job_msg_id)
579 #else
580 Boolean
581 await(register Boolean ignore_error, register Boolean silent_error, Name target, wchar_t *command, pid_t running_pid, Boolean send_mtool_msgs, void *xdrs_p, int job_msg_id)
582 #endif
583 {
584 int status;
585 char *buffer;
586 int core_dumped;
587 int exit_status;
588 #if defined(DISTRIBUTED) || defined(MAKETOOL) /* tolik */
589 Avo_CmdOutput *make_output_msg;
590 #endif
591 FILE *outfp;
592 register pid_t pid;
593 struct stat stat_buff;
594 int termination_signal;
595 char tmp_buf[MAXPATHLEN];
596 #if defined(DISTRIBUTED) || defined(MAKETOOL) /* tolik */
597 RWCollectable *xdr_msg;
598 #endif
599
600 while ((pid = wait(&status)) != running_pid) {
601 if (pid == -1) {
602 fatal_mksh(catgets(libmksdmsi18n_catd, 1, 98, "wait() failed: %s"), errmsg(errno));
603 }
604 }
605 (void) fflush(stdout);
606 (void) fflush(stderr);
607
608 if (status == 0) {
609
610 #ifdef PRINT_EXIT_STATUS
611 warning_mksh(NOCATGETS("I'm in await(), and status is 0."));
612 #endif
613
614 return succeeded;
615 }
616
617 #ifdef PRINT_EXIT_STATUS
618 warning_mksh(NOCATGETS("I'm in await(), and status is *NOT* 0."));
619 #endif
620
621
622 exit_status = WEXITSTATUS(status);
623
624 #ifdef PRINT_EXIT_STATUS
625 warning_mksh(NOCATGETS("I'm in await(), and exit_status is %d."), exit_status);
626 #endif
627
628 termination_signal = WTERMSIG(status);
629 core_dumped = WCOREDUMP(status);
630
631 /*
632 * If the child returned an error, we now try to print a
633 * nice message about it.
634 */
635 SEND_MTOOL_MSG(
636 make_output_msg = new Avo_CmdOutput();
637 (void) sprintf(tmp_buf, "%d", job_msg_id);
638 make_output_msg->appendOutput(AVO_STRDUP(tmp_buf));
639 );
640
641 tmp_buf[0] = (int) nul_char;
642 if (!silent_error) {
643 if (exit_status != 0) {
644 (void) fprintf(stdout,
645 catgets(libmksdmsi18n_catd, 1, 103, "*** Error code %d"),
646 exit_status);
647 SEND_MTOOL_MSG(
648 (void) sprintf(&tmp_buf[strlen(tmp_buf)],
649 catgets(libmksdmsi18n_catd, 1, 104, "*** Error code %d"),
650 exit_status);
651 );
652 } else {
653 (void) fprintf(stdout,
654 catgets(libmksdmsi18n_catd, 1, 105, "*** Signal %d"),
655 termination_signal);
656 SEND_MTOOL_MSG(
657 (void) sprintf(&tmp_buf[strlen(tmp_buf)],
658 catgets(libmksdmsi18n_catd, 1, 106, "*** Signal %d"),
659 termination_signal);
660 );
661 if (core_dumped) {
662 (void) fprintf(stdout,
663 catgets(libmksdmsi18n_catd, 1, 107, " - core dumped"));
664 SEND_MTOOL_MSG(
665 (void) sprintf(&tmp_buf[strlen(tmp_buf)],
666 catgets(libmksdmsi18n_catd, 1, 108, " - core dumped"));
667 );
668 }
669 }
670 if (ignore_error) {
671 (void) fprintf(stdout,
672 catgets(libmksdmsi18n_catd, 1, 109, " (ignored)"));
673 SEND_MTOOL_MSG(
674 (void) sprintf(&tmp_buf[strlen(tmp_buf)],
675 catgets(libmksdmsi18n_catd, 1, 110, " (ignored)"));
676 );
677 }
678 (void) fprintf(stdout, "\n");
679 (void) fflush(stdout);
680 SEND_MTOOL_MSG(
681 make_output_msg->appendOutput(AVO_STRDUP(tmp_buf));
682 );
683 }
684 SEND_MTOOL_MSG(
685 xdr_msg = (RWCollectable*) make_output_msg;
686 xdr(xdrs_p, xdr_msg);
687 delete make_output_msg;
688 );
689
690 #ifdef PRINT_EXIT_STATUS
691 warning_mksh(NOCATGETS("I'm in await(), returning failed."));
692 #endif
693
694 return failed;
695 }
696
697 /*
698 * sh_command2string(command, destination)
699 *
700 * Run one sh command and capture the output from it.
701 *
702 * Return value:
703 *
704 * Parameters:
705 * command The command to run
706 * destination Where to deposit the output from the command
707 *
708 * Static variables used:
709 *
710 * Global variables used:
711 */
712 void
713 sh_command2string(register String command, register String destination)
714 {
715 register FILE *fd;
716 register int chr;
717 int status;
718 Boolean command_generated_output = false;
719
720 command->text.p = (int) nul_char;
721 WCSTOMBS(mbs_buffer, command->buffer.start);
722 if ((fd = popen(mbs_buffer, "r")) == NULL) {
723 WCSTOMBS(mbs_buffer, command->buffer.start);
724 fatal_mksh(catgets(libmksdmsi18n_catd, 1, 111, "Could not run command `%s' for :sh transformation"),
725 mbs_buffer);
726 }
727 while ((chr = getc(fd)) != EOF) {
728 if (chr == (int) newline_char) {
729 chr = (int) space_char;
730 }
731 command_generated_output = true;
732 append_char(chr, destination);
733 }
734
735 /*
736 * We don't want to keep the last LINE_FEED since usually
737 * the output of the 'sh:' command is used to evaluate
738 * some MACRO. ( /bin/sh and other shell add a line feed
739 * to the output so that the prompt appear in the right place.
740 * We don't need that
741 */
742 if (command_generated_output){
743 if ( *(destination->text.p-1) == (int) space_char) {
744 * (-- destination->text.p) = '\0';
745 }
746 } else {
747 /*
748 * If the command didn't generate any output,
749 * set the buffer to a null string.
750 */
751 *(destination->text.p) = '\0';
752 }
753
754 status = pclose(fd);
755 if (status != 0) {
756 WCSTOMBS(mbs_buffer, command->buffer.start);
757 fatal_mksh(catgets(libmksdmsi18n_catd, 1, 112, "The command `%s' returned status `%d'"),
758 mbs_buffer,
759 WEXITSTATUS(status));
760 }
761 }
762
763