Subversion Repositories or1k

/*  Copyright (C) 2004     Manuel Novoa III
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Library General Public
 *  License as published by the Free Software Foundation; either
 *  version 2 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Library General Public License for more details.
 *
 *  You should have received a copy of the GNU Library General Public
 *  License along with this library; if not, write to the Free
 *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
/* 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>
 
/* uClinux-2.0 has vfork, but Linux 2.0 doesn't */
#include <sys/syscall.h>
#if ! defined __NR_vfork
# define vfork fork	
# define VFORK_LOCK		((void) 0)
# define VFORK_UNLOCK	((void) 0)
#endif
 
#ifdef __UCLIBC_HAS_THREADS__
#include <pthread.h>
static pthread_mutex_t mylock = PTHREAD_MUTEX_INITIALIZER;
# define LOCK			__pthread_mutex_lock(&mylock)
# define UNLOCK			__pthread_mutex_unlock(&mylock);
#else
# define LOCK			((void) 0)
# define UNLOCK			((void) 0)
#endif      
 
#ifndef VFORK_LOCK
# define VFORK_LOCK		LOCK
# define VFORK_UNLOCK	UNLOCK
#endif
 
/* Temporarily support old stdio code. */
#ifndef __MASK_READING
#define __filedes		filedes
#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;
		LOCK;
		pi->next = popen_list;
		popen_list = pi;
		UNLOCK;
 
		return fp;
	}
 
	/* If we get here, vfork failed. */
	fclose(fp);					/* Will close parent_fd. */
 
 FREE_PI:
	free(pi);
 
 RET_NULL:
	return NULL;
}
 
int pclose(FILE *stream)
{
	struct popen_list_item *p;
	int stat;
	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). */
	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);
		}
	}
	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, &stat, 0) >= 0) {
				return stat;
			}
			if (errno != EINTR) {
				break;
			}
		} while (1);
	}
 
	return -1;
}