/* Copyright (C) 2004 Manuel Novoa III <mjn3@codepoet.org> * Copyright (C) 2000-2006 Erik Andersen <andersen@uclibc.org> * * Licensed under the LGPL v2.1, see the file COPYING.LIB in this tarball. * * Dedicated to Toni. See uClibc/DEDICATION.mjn3 for details. */ /* Jan 1, 2004 * * Rewrite popen for SUSv3 compliance. * Added a list of popen()'d to store pids and use waitpid() in pclose(). * Loop on waitpid() failure due to EINTR as required. * Close parent's popen()'d FILEs in the {v}fork()'d child. * Fix failure exit code for failed execve(). */ #include <stdio.h> #include <stdlib.h> #include <errno.h> #include <unistd.h> #include <sys/wait.h> #include <bits/uClibc_mutex.h> #ifdef __UCLIBC_MJN3_ONLY__ #warning "hmm... susv3 says Pipe streams are byte-oriented." #endif /* __UCLIBC_MJN3_ONLY__ */ #ifndef VFORK_LOCK __UCLIBC_MUTEX_STATIC(mylock, PTHREAD_MUTEX_INITIALIZER); # define VFORK_LOCK __UCLIBC_MUTEX_LOCK(mylock) # define VFORK_UNLOCK __UCLIBC_MUTEX_UNLOCK(mylock) #endif struct popen_list_item { struct popen_list_item *next; FILE *f; pid_t pid; }; static struct popen_list_item *popen_list /* = NULL (bss initialized) */; FILE *popen(const char *command, const char *modes) { FILE *fp; struct popen_list_item *pi; struct popen_list_item *po; int pipe_fd[2]; int parent_fd; int child_fd; int child_writing; /* Doubles as the desired child fildes. */ pid_t pid; child_writing = 0; /* Assume child is writing. */ if (modes[0] != 'w') { /* Parent not writing... */ ++child_writing; /* so child must be writing. */ if (modes[0] != 'r') { /* Oops! Parent not reading either! */ __set_errno(EINVAL); goto RET_NULL; } } if (!(pi = malloc(sizeof(struct popen_list_item)))) { goto RET_NULL; } if (pipe(pipe_fd)) { goto FREE_PI; } child_fd = pipe_fd[child_writing]; parent_fd = pipe_fd[1-child_writing]; if (!(fp = fdopen(parent_fd, modes))) { close(parent_fd); close(child_fd); goto FREE_PI; } VFORK_LOCK; if ((pid = vfork()) == 0) { /* Child of vfork... */ close(parent_fd); if (child_fd != child_writing) { dup2(child_fd, child_writing); close(child_fd); } /* SUSv3 requires that any previously popen()'d streams in the * parent shall be closed in the child. */ for (po = popen_list ; po ; po = po->next) { close(po->f->__filedes); } execl("/bin/sh", "sh", "-c", command, (char *)0); /* SUSv3 mandates an exit code of 127 for the child if the * command interpreter can not be invoked. */ _exit(127); } VFORK_UNLOCK; /* We need to close the child filedes whether vfork failed or * it succeeded and we're in the parent. */ close(child_fd); if (pid > 0) { /* Parent of vfork... */ pi->pid = pid; pi->f = fp; VFORK_LOCK; pi->next = popen_list; popen_list = pi; VFORK_UNLOCK; return fp; } /* If we get here, vfork failed. */ fclose(fp); /* Will close parent_fd. */ FREE_PI: free(pi); RET_NULL: return NULL; } #warning is pclose correct wrt the new mutex semantics? int pclose(FILE *stream) { struct popen_list_item *p; int status; pid_t pid; /* First, find the list entry corresponding to stream and remove it * from the list. Set p to the list item (NULL if not found). */ VFORK_LOCK; if ((p = popen_list) != NULL) { if (p->f == stream) { popen_list = p->next; } else { struct popen_list_item *t; do { t = p; if (!(p = t->next)) { __set_errno(EINVAL); /* Not required by SUSv3. */ break; } if (p->f == stream) { t->next = p->next; break; } } while (1); } } VFORK_UNLOCK; if (p) { pid = p->pid; /* Save the pid we need */ free(p); /* and free the list item. */ fclose(stream); /* The SUSv3 example code ignores the return. */ /* SUSv3 specificly requires that pclose not return before the child * terminates, in order to disallow pclose from returning on EINTR. */ do { if (waitpid(pid, &status, 0) >= 0) { return status; } if (errno != EINTR) { break; } } while (1); } return -1; }