source: rtems-tools/rtemstoolkit/libiberty/pex-unix.c @ 87e0e76

4.104.11
Last change on this file since 87e0e76 was 87e0e76, checked in by Chris Johns <chrisj@…>, on Sep 13, 2014 at 2:09:16 AM

Refactor code into the RTEMS Toolkit.

  • Property mode set to 100644
File size: 19.5 KB
Line 
1/* Utilities to execute a program in a subprocess (possibly linked by pipes
2   with other subprocesses), and wait for it.  Generic Unix version
3   (also used for UWIN and VMS).
4   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2009,
5   2010 Free Software Foundation, Inc.
6
7This file is part of the libiberty library.
8Libiberty is free software; you can redistribute it and/or
9modify it under the terms of the GNU Library General Public
10License as published by the Free Software Foundation; either
11version 2 of the License, or (at your option) any later version.
12
13Libiberty is distributed in the hope that it will be useful,
14but WITHOUT ANY WARRANTY; without even the implied warranty of
15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16Library General Public License for more details.
17
18You should have received a copy of the GNU Library General Public
19License along with libiberty; see the file COPYING.LIB.  If not,
20write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
21Boston, MA 02110-1301, USA.  */
22
23#include "config.h"
24#include "libiberty.h"
25#include "pex-common.h"
26
27#include <stdio.h>
28#include <signal.h>
29#include <errno.h>
30#ifdef NEED_DECLARATION_ERRNO
31extern int errno;
32#endif
33#ifdef HAVE_STDLIB_H
34#include <stdlib.h>
35#endif
36#ifdef HAVE_STRING_H
37#include <string.h>
38#endif
39#ifdef HAVE_UNISTD_H
40#include <unistd.h>
41#endif
42
43#include <sys/types.h>
44
45#ifdef HAVE_FCNTL_H
46#include <fcntl.h>
47#endif
48#ifdef HAVE_SYS_WAIT_H
49#include <sys/wait.h>
50#endif
51#ifdef HAVE_GETRUSAGE
52#include <sys/time.h>
53#include <sys/resource.h>
54#endif
55#ifdef HAVE_SYS_STAT_H
56#include <sys/stat.h>
57#endif
58#ifdef HAVE_PROCESS_H
59#include <process.h>
60#endif
61
62#ifdef vfork /* Autoconf may define this to fork for us. */
63# define VFORK_STRING "fork"
64#else
65# define VFORK_STRING "vfork"
66#endif
67#ifdef HAVE_VFORK_H
68#include <vfork.h>
69#endif
70#if defined(VMS) && defined (__LONG_POINTERS)
71#ifndef __CHAR_PTR32
72typedef char * __char_ptr32
73__attribute__ ((mode (SI)));
74#endif
75
76typedef __char_ptr32 *__char_ptr_char_ptr32
77__attribute__ ((mode (SI)));
78
79/* Return a 32 bit pointer to an array of 32 bit pointers
80   given a 64 bit pointer to an array of 64 bit pointers.  */
81
82static __char_ptr_char_ptr32
83to_ptr32 (char **ptr64)
84{
85  int argc;
86  __char_ptr_char_ptr32 short_argv;
87
88  for (argc=0; ptr64[argc]; argc++);
89
90  /* Reallocate argv with 32 bit pointers.  */
91  short_argv = (__char_ptr_char_ptr32) decc$malloc
92    (sizeof (__char_ptr32) * (argc + 1));
93
94  for (argc=0; ptr64[argc]; argc++)
95    short_argv[argc] = (__char_ptr32) decc$strdup (ptr64[argc]);
96
97  short_argv[argc] = (__char_ptr32) 0;
98  return short_argv;
99
100}
101#else
102#define to_ptr32(argv) argv
103#endif
104
105/* File mode to use for private and world-readable files.  */
106
107#if defined (S_IRUSR) && defined (S_IWUSR) && defined (S_IRGRP) && defined (S_IWGRP) && defined (S_IROTH) && defined (S_IWOTH)
108#define PUBLIC_MODE  \
109    (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH)
110#else
111#define PUBLIC_MODE 0666
112#endif
113
114/* Get the exit status of a particular process, and optionally get the
115   time that it took.  This is simple if we have wait4, slightly
116   harder if we have waitpid, and is a pain if we only have wait.  */
117
118static pid_t pex_wait (struct pex_obj *, pid_t, int *, struct pex_time *);
119
120#ifdef HAVE_WAIT4
121
122static pid_t
123pex_wait (struct pex_obj *obj ATTRIBUTE_UNUSED, pid_t pid, int *status,
124          struct pex_time *time)
125{
126  pid_t ret;
127  struct rusage r;
128
129#ifdef HAVE_WAITPID
130  if (time == NULL)
131    return waitpid (pid, status, 0);
132#endif
133
134  ret = wait4 (pid, status, 0, &r);
135
136  if (time != NULL)
137    {
138      time->user_seconds = r.ru_utime.tv_sec;
139      time->user_microseconds= r.ru_utime.tv_usec;
140      time->system_seconds = r.ru_stime.tv_sec;
141      time->system_microseconds= r.ru_stime.tv_usec;
142    }
143
144  return ret;
145}
146
147#else /* ! defined (HAVE_WAIT4) */
148
149#ifdef HAVE_WAITPID
150
151#ifndef HAVE_GETRUSAGE
152
153static pid_t
154pex_wait (struct pex_obj *obj ATTRIBUTE_UNUSED, pid_t pid, int *status,
155          struct pex_time *time)
156{
157  if (time != NULL)
158    memset (time, 0, sizeof (struct pex_time));
159  return waitpid (pid, status, 0);
160}
161
162#else /* defined (HAVE_GETRUSAGE) */
163
164static pid_t
165pex_wait (struct pex_obj *obj ATTRIBUTE_UNUSED, pid_t pid, int *status,
166          struct pex_time *time)
167{
168  struct rusage r1, r2;
169  pid_t ret;
170
171  if (time == NULL)
172    return waitpid (pid, status, 0);
173
174  getrusage (RUSAGE_CHILDREN, &r1);
175
176  ret = waitpid (pid, status, 0);
177  if (ret < 0)
178    return ret;
179
180  getrusage (RUSAGE_CHILDREN, &r2);
181
182  time->user_seconds = r2.ru_utime.tv_sec - r1.ru_utime.tv_sec;
183  time->user_microseconds = r2.ru_utime.tv_usec - r1.ru_utime.tv_usec;
184  if (r2.ru_utime.tv_usec < r1.ru_utime.tv_usec)
185    {
186      --time->user_seconds;
187      time->user_microseconds += 1000000;
188    }
189
190  time->system_seconds = r2.ru_stime.tv_sec - r1.ru_stime.tv_sec;
191  time->system_microseconds = r2.ru_stime.tv_usec - r1.ru_stime.tv_usec;
192  if (r2.ru_stime.tv_usec < r1.ru_stime.tv_usec)
193    {
194      --time->system_seconds;
195      time->system_microseconds += 1000000;
196    }
197
198  return ret;
199}
200
201#endif /* defined (HAVE_GETRUSAGE) */
202
203#else /* ! defined (HAVE_WAITPID) */
204
205struct status_list
206{
207  struct status_list *next;
208  pid_t pid;
209  int status;
210  struct pex_time time;
211};
212
213static pid_t
214pex_wait (struct pex_obj *obj, pid_t pid, int *status, struct pex_time *time)
215{
216  struct status_list **pp;
217
218  for (pp = (struct status_list **) &obj->sysdep;
219       *pp != NULL;
220       pp = &(*pp)->next)
221    {
222      if ((*pp)->pid == pid)
223        {
224          struct status_list *p;
225
226          p = *pp;
227          *status = p->status;
228          if (time != NULL)
229            *time = p->time;
230          *pp = p->next;
231          free (p);
232          return pid;
233        }
234    }
235
236  while (1)
237    {
238      pid_t cpid;
239      struct status_list *psl;
240      struct pex_time pt;
241#ifdef HAVE_GETRUSAGE
242      struct rusage r1, r2;
243#endif
244
245      if (time != NULL)
246        {
247#ifdef HAVE_GETRUSAGE
248          getrusage (RUSAGE_CHILDREN, &r1);
249#else
250          memset (&pt, 0, sizeof (struct pex_time));
251#endif
252        }
253
254      cpid = wait (status);
255
256#ifdef HAVE_GETRUSAGE
257      if (time != NULL && cpid >= 0)
258        {
259          getrusage (RUSAGE_CHILDREN, &r2);
260
261          pt.user_seconds = r2.ru_utime.tv_sec - r1.ru_utime.tv_sec;
262          pt.user_microseconds = r2.ru_utime.tv_usec - r1.ru_utime.tv_usec;
263          if ((int) pt.user_microseconds < 0)
264            {
265              --pt.user_seconds;
266              pt.user_microseconds += 1000000;
267            }
268
269          pt.system_seconds = r2.ru_stime.tv_sec - r1.ru_stime.tv_sec;
270          pt.system_microseconds = r2.ru_stime.tv_usec - r1.ru_stime.tv_usec;
271          if ((int) pt.system_microseconds < 0)
272            {
273              --pt.system_seconds;
274              pt.system_microseconds += 1000000;
275            }
276        }
277#endif
278
279      if (cpid < 0 || cpid == pid)
280        {
281          if (time != NULL)
282            *time = pt;
283          return cpid;
284        }
285
286      psl = XNEW (struct status_list);
287      psl->pid = cpid;
288      psl->status = *status;
289      if (time != NULL)
290        psl->time = pt;
291      psl->next = (struct status_list *) obj->sysdep;
292      obj->sysdep = (void *) psl;
293    }
294}
295
296#endif /* ! defined (HAVE_WAITPID) */
297#endif /* ! defined (HAVE_WAIT4) */
298
299static void pex_child_error (struct pex_obj *, const char *, const char *, int)
300     ATTRIBUTE_NORETURN;
301static int pex_unix_open_read (struct pex_obj *, const char *, int);
302static int pex_unix_open_write (struct pex_obj *, const char *, int);
303static pid_t pex_unix_exec_child (struct pex_obj *, int, const char *,
304                                 char * const *, char * const *,
305                                 int, int, int, int,
306                                 const char **, int *);
307static int pex_unix_close (struct pex_obj *, int);
308static int pex_unix_wait (struct pex_obj *, pid_t, int *, struct pex_time *,
309                          int, const char **, int *);
310static int pex_unix_pipe (struct pex_obj *, int *, int);
311static FILE *pex_unix_fdopenr (struct pex_obj *, int, int);
312static FILE *pex_unix_fdopenw (struct pex_obj *, int, int);
313static void pex_unix_cleanup (struct pex_obj *);
314
315/* The list of functions we pass to the common routines.  */
316
317const struct pex_funcs funcs =
318{
319  pex_unix_open_read,
320  pex_unix_open_write,
321  pex_unix_exec_child,
322  pex_unix_close,
323  pex_unix_wait,
324  pex_unix_pipe,
325  pex_unix_fdopenr,
326  pex_unix_fdopenw,
327  pex_unix_cleanup
328};
329
330/* Return a newly initialized pex_obj structure.  */
331
332struct pex_obj *
333pex_init (int flags, const char *pname, const char *tempbase)
334{
335  return pex_init_common (flags, pname, tempbase, &funcs);
336}
337
338/* Open a file for reading.  */
339
340static int
341pex_unix_open_read (struct pex_obj *obj ATTRIBUTE_UNUSED, const char *name,
342                    int binary ATTRIBUTE_UNUSED)
343{
344  return open (name, O_RDONLY);
345}
346
347/* Open a file for writing.  */
348
349static int
350pex_unix_open_write (struct pex_obj *obj ATTRIBUTE_UNUSED, const char *name,
351                     int binary ATTRIBUTE_UNUSED)
352{
353  /* Note that we can't use O_EXCL here because gcc may have already
354     created the temporary file via make_temp_file.  */
355  return open (name, O_WRONLY | O_CREAT | O_TRUNC, PUBLIC_MODE);
356}
357
358/* Close a file.  */
359
360static int
361pex_unix_close (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd)
362{
363  return close (fd);
364}
365
366/* Report an error from a child process.  We don't use stdio routines,
367   because we might be here due to a vfork call.  */
368
369static void
370pex_child_error (struct pex_obj *obj, const char *executable,
371                 const char *errmsg, int err)
372{
373  int retval = 0;
374#define writeerr(s) retval |= (write (STDERR_FILE_NO, s, strlen (s)) < 0)
375  writeerr (obj->pname);
376  writeerr (": error trying to exec '");
377  writeerr (executable);
378  writeerr ("': ");
379  writeerr (errmsg);
380  writeerr (": ");
381  writeerr (xstrerror (err));
382  writeerr ("\n");
383#undef writeerr
384  /* Exit with -2 if the error output failed, too.  */
385  _exit (retval == 0 ? -1 : -2);
386}
387
388/* Execute a child.  */
389
390extern char **environ;
391
392#if defined(HAVE_SPAWNVE) && defined(HAVE_SPAWNVPE)
393/* Implementation of pex->exec_child using the Cygwin spawn operation.  */
394
395/* Subroutine of pex_unix_exec_child.  Move OLD_FD to a new file descriptor
396   to be stored in *PNEW_FD, save the flags in *PFLAGS, and arrange for the
397   saved copy to be close-on-exec.  Move CHILD_FD into OLD_FD.  If CHILD_FD
398   is -1, OLD_FD is to be closed.  Return -1 on error.  */
399
400static int
401save_and_install_fd(int *pnew_fd, int *pflags, int old_fd, int child_fd)
402{
403  int new_fd, flags;
404
405  flags = fcntl (old_fd, F_GETFD);
406
407  /* If we could not retrieve the flags, then OLD_FD was not open.  */
408  if (flags < 0)
409    {
410      new_fd = -1, flags = 0;
411      if (child_fd >= 0 && dup2 (child_fd, old_fd) < 0)
412        return -1;
413    }
414  /* If we wish to close OLD_FD, just mark it CLOEXEC.  */
415  else if (child_fd == -1)
416    {
417      new_fd = old_fd;
418      if ((flags & FD_CLOEXEC) == 0 && fcntl (old_fd, F_SETFD, FD_CLOEXEC) < 0)
419        return -1;
420    }
421  /* Otherwise we need to save a copy of OLD_FD before installing CHILD_FD.  */
422  else
423    {
424#ifdef F_DUPFD_CLOEXEC
425      new_fd = fcntl (old_fd, F_DUPFD_CLOEXEC, 3);
426      if (new_fd < 0)
427        return -1;
428#else
429      /* Prefer F_DUPFD over dup in order to avoid getting a new fd
430         in the range 0-2, right where a new stderr fd might get put.  */
431      new_fd = fcntl (old_fd, F_DUPFD, 3);
432      if (new_fd < 0)
433        return -1;
434      if (fcntl (new_fd, F_SETFD, FD_CLOEXEC) < 0)
435        return -1;
436#endif
437      if (dup2 (child_fd, old_fd) < 0)
438        return -1;
439    }
440
441  *pflags = flags;
442  if (pnew_fd)
443    *pnew_fd = new_fd;
444  else if (new_fd != old_fd)
445    abort ();
446
447  return 0;
448}
449
450/* Subroutine of pex_unix_exec_child.  Move SAVE_FD back to OLD_FD
451   restoring FLAGS.  If SAVE_FD < 0, OLD_FD is to be closed.  */
452
453static int
454restore_fd(int old_fd, int save_fd, int flags)
455{
456  /* For SAVE_FD < 0, all we have to do is restore the
457     "closed-ness" of the original.  */
458  if (save_fd < 0)
459    return close (old_fd);
460
461  /* For SAVE_FD == OLD_FD, all we have to do is restore the
462     original setting of the CLOEXEC flag.  */
463  if (save_fd == old_fd)
464    {
465      if (flags & FD_CLOEXEC)
466        return 0;
467      return fcntl (old_fd, F_SETFD, flags);
468    }
469
470  /* Otherwise we have to move the descriptor back, restore the flags,
471     and close the saved copy.  */
472#ifdef HAVE_DUP3
473  if (flags == FD_CLOEXEC)
474    {
475      if (dup3 (save_fd, old_fd, O_CLOEXEC) < 0)
476        return -1;
477    }
478  else
479#endif
480    {
481      if (dup2 (save_fd, old_fd) < 0)
482        return -1;
483      if (flags != 0 && fcntl (old_fd, F_SETFD, flags) < 0)
484        return -1;
485    }
486  return close (save_fd);
487}
488
489static pid_t
490pex_unix_exec_child (struct pex_obj *obj ATTRIBUTE_UNUSED,
491                     int flags, const char *executable,
492                     char * const * argv, char * const * env,
493                     int in, int out, int errdes, int toclose,
494                     const char **errmsg, int *err)
495{
496  int fl_in = 0, fl_out = 0, fl_err = 0, fl_tc = 0;
497  int save_in = -1, save_out = -1, save_err = -1;
498  int max, retries;
499  pid_t pid;
500
501  if (flags & PEX_STDERR_TO_STDOUT)
502    errdes = out;
503
504  /* We need the three standard file descriptors to be set up as for
505     the child before we perform the spawn.  The file descriptors for
506     the parent need to be moved and marked for close-on-exec.  */
507  if (in != STDIN_FILE_NO
508      && save_and_install_fd (&save_in, &fl_in, STDIN_FILE_NO, in) < 0)
509    goto error_dup2;
510  if (out != STDOUT_FILE_NO
511      && save_and_install_fd (&save_out, &fl_out, STDOUT_FILE_NO, out) < 0)
512    goto error_dup2;
513  if (errdes != STDERR_FILE_NO
514      && save_and_install_fd (&save_err, &fl_err, STDERR_FILE_NO, errdes) < 0)
515    goto error_dup2;
516  if (toclose >= 0
517      && save_and_install_fd (NULL, &fl_tc, toclose, -1) < 0)
518    goto error_dup2;
519
520  /* Now that we've moved the file descriptors for the child into place,
521     close the originals.  Be careful not to close any of the standard
522     file descriptors that we just set up.  */
523  max = -1;
524  if (errdes >= 0)
525    max = STDERR_FILE_NO;
526  else if (out >= 0)
527    max = STDOUT_FILE_NO;
528  else if (in >= 0)
529    max = STDIN_FILE_NO;
530  if (in > max)
531    close (in);
532  if (out > max)
533    close (out);
534  if (errdes > max && errdes != out)
535    close (errdes);
536
537  /* If we were not given an environment, use the global environment.  */
538  if (env == NULL)
539    env = environ;
540
541  /* Launch the program.  If we get EAGAIN (normally out of pid's), try
542     again a few times with increasing backoff times.  */
543  retries = 0;
544  while (1)
545    {
546      typedef const char * const *cc_cp;
547
548      if (flags & PEX_SEARCH)
549        pid = spawnvpe (_P_NOWAITO, executable, (cc_cp)argv, (cc_cp)env);
550      else
551        pid = spawnve (_P_NOWAITO, executable, (cc_cp)argv, (cc_cp)env);
552
553      if (pid > 0)
554        break;
555
556      *err = errno;
557      *errmsg = "spawn";
558      if (errno != EAGAIN || ++retries == 4)
559        return (pid_t) -1;
560      sleep (1 << retries);
561    }
562
563  /* Success.  Restore the parent's file descriptors that we saved above.  */
564  if (toclose >= 0
565      && restore_fd (toclose, toclose, fl_tc) < 0)
566    goto error_dup2;
567  if (in != STDIN_FILE_NO
568      && restore_fd (STDIN_FILE_NO, save_in, fl_in) < 0)
569    goto error_dup2;
570  if (out != STDOUT_FILE_NO
571      && restore_fd (STDOUT_FILE_NO, save_out, fl_out) < 0)
572    goto error_dup2;
573  if (errdes != STDERR_FILE_NO
574      && restore_fd (STDERR_FILE_NO, save_err, fl_err) < 0)
575    goto error_dup2;
576
577  return pid;
578
579 error_dup2:
580  *err = errno;
581  *errmsg = "dup2";
582  return (pid_t) -1;
583}
584
585#else
586/* Implementation of pex->exec_child using standard vfork + exec.  */
587
588static pid_t
589pex_unix_exec_child (struct pex_obj *obj, int flags, const char *executable,
590                     char * const * argv, char * const * env,
591                     int in, int out, int errdes,
592                     int toclose, const char **errmsg, int *err)
593{
594  pid_t pid;
595
596  /* We declare these to be volatile to avoid warnings from gcc about
597     them being clobbered by vfork.  */
598  volatile int sleep_interval;
599  volatile int retries;
600
601  /* We vfork and then set environ in the child before calling execvp.
602     This clobbers the parent's environ so we need to restore it.
603     It would be nice to use one of the exec* functions that takes an
604     environment as a parameter, but that may have portability issues.  */
605  char **save_environ = environ;
606
607  sleep_interval = 1;
608  pid = -1;
609  for (retries = 0; retries < 4; ++retries)
610    {
611      pid = vfork ();
612      if (pid >= 0)
613        break;
614      sleep (sleep_interval);
615      sleep_interval *= 2;
616    }
617
618  switch (pid)
619    {
620    case -1:
621      *err = errno;
622      *errmsg = VFORK_STRING;
623      return (pid_t) -1;
624
625    case 0:
626      /* Child process.  */
627      if (in != STDIN_FILE_NO)
628        {
629          if (dup2 (in, STDIN_FILE_NO) < 0)
630            pex_child_error (obj, executable, "dup2", errno);
631          if (close (in) < 0)
632            pex_child_error (obj, executable, "close", errno);
633        }
634      if (out != STDOUT_FILE_NO)
635        {
636          if (dup2 (out, STDOUT_FILE_NO) < 0)
637            pex_child_error (obj, executable, "dup2", errno);
638          if (close (out) < 0)
639            pex_child_error (obj, executable, "close", errno);
640        }
641      if (errdes != STDERR_FILE_NO)
642        {
643          if (dup2 (errdes, STDERR_FILE_NO) < 0)
644            pex_child_error (obj, executable, "dup2", errno);
645          if (close (errdes) < 0)
646            pex_child_error (obj, executable, "close", errno);
647        }
648      if (toclose >= 0)
649        {
650          if (close (toclose) < 0)
651            pex_child_error (obj, executable, "close", errno);
652        }
653      if ((flags & PEX_STDERR_TO_STDOUT) != 0)
654        {
655          if (dup2 (STDOUT_FILE_NO, STDERR_FILE_NO) < 0)
656            pex_child_error (obj, executable, "dup2", errno);
657        }
658
659      if (env)
660        {
661          /* NOTE: In a standard vfork implementation this clobbers the
662             parent's copy of environ "too" (in reality there's only one copy).
663             This is ok as we restore it below.  */
664          environ = (char**) env;
665        }
666
667      if ((flags & PEX_SEARCH) != 0)
668        {
669          execvp (executable, to_ptr32 (argv));
670          pex_child_error (obj, executable, "execvp", errno);
671        }
672      else
673        {
674          execv (executable, to_ptr32 (argv));
675          pex_child_error (obj, executable, "execv", errno);
676        }
677
678      /* NOTREACHED */
679      return (pid_t) -1;
680
681    default:
682      /* Parent process.  */
683
684      /* Restore environ.
685         Note that the parent either doesn't run until the child execs/exits
686         (standard vfork behaviour), or if it does run then vfork is behaving
687         more like fork.  In either case we needn't worry about clobbering
688         the child's copy of environ.  */
689      environ = save_environ;
690
691      if (in != STDIN_FILE_NO)
692        {
693          if (close (in) < 0)
694            {
695              *err = errno;
696              *errmsg = "close";
697              return (pid_t) -1;
698            }
699        }
700      if (out != STDOUT_FILE_NO)
701        {
702          if (close (out) < 0)
703            {
704              *err = errno;
705              *errmsg = "close";
706              return (pid_t) -1;
707            }
708        }
709      if (errdes != STDERR_FILE_NO)
710        {
711          if (close (errdes) < 0)
712            {
713              *err = errno;
714              *errmsg = "close";
715              return (pid_t) -1;
716            }
717        }
718
719      return pid;
720    }
721}
722#endif /* SPAWN */
723
724/* Wait for a child process to complete.  */
725
726static int
727pex_unix_wait (struct pex_obj *obj, pid_t pid, int *status,
728               struct pex_time *time, int done, const char **errmsg,
729               int *err)
730{
731  /* If we are cleaning up when the caller didn't retrieve process
732     status for some reason, encourage the process to go away.  */
733  if (done)
734    kill (pid, SIGTERM);
735
736  if (pex_wait (obj, pid, status, time) < 0)
737    {
738      *err = errno;
739      *errmsg = "wait";
740      return -1;
741    }
742
743  return 0;
744}
745
746/* Create a pipe.  */
747
748static int
749pex_unix_pipe (struct pex_obj *obj ATTRIBUTE_UNUSED, int *p,
750               int binary ATTRIBUTE_UNUSED)
751{
752  return pipe (p);
753}
754
755/* Get a FILE pointer to read from a file descriptor.  */
756
757static FILE *
758pex_unix_fdopenr (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd,
759                  int binary ATTRIBUTE_UNUSED)
760{
761  return fdopen (fd, "r");
762}
763
764static FILE *
765pex_unix_fdopenw (struct pex_obj *obj ATTRIBUTE_UNUSED, int fd,
766                  int binary ATTRIBUTE_UNUSED)
767{
768  if (fcntl (fd, F_SETFD, FD_CLOEXEC) < 0)
769    return NULL;
770  return fdopen (fd, "w");
771}
772
773static void
774pex_unix_cleanup (struct pex_obj *obj ATTRIBUTE_UNUSED)
775{
776#if !defined (HAVE_WAIT4) && !defined (HAVE_WAITPID)
777  while (obj->sysdep != NULL)
778    {
779      struct status_list *this;
780      struct status_list *next;
781
782      this = (struct status_list *) obj->sysdep;
783      next = this->next;
784      free (this);
785      obj->sysdep = (void *) next;
786    }
787#endif
788}
Note: See TracBrowser for help on using the repository browser.