--- libelwix/src/pio.c 2013/12/05 14:56:42 1.1 +++ libelwix/src/pio.c 2013/12/15 22:54:41 1.2 @@ -0,0 +1,344 @@ +/************************************************************************* +* (C) 2013 AITNET ltd - Sofia/Bulgaria - +* by Michael Pounov +* +* $Author: misho $ +* $Id: pio.c,v 1.2 2013/12/15 22:54:41 misho Exp $ +* +************************************************************************** +The ELWIX and AITNET software is distributed under the following +terms: + +All of the documentation and software included in the ELWIX and AITNET +Releases is copyrighted by ELWIX - Sofia/Bulgaria + +Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 + by Michael Pounov . All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. All advertising materials mentioning features or use of this software + must display the following acknowledgement: +This product includes software developed by Michael Pounov +ELWIX - Embedded LightWeight unIX and its contributors. +4. Neither the name of AITNET nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY AITNET AND CONTRIBUTORS ``AS IS'' AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +SUCH DAMAGE. +*/ +#include "global.h" + + +extern char **environ; + +pio_pid_t pio_pidlist = SLIST_HEAD_INITIALIZER(pio_pidlist); +static pthread_mutex_t pidlist_mutex = PTHREAD_MUTEX_INITIALIZER; + +#define THREAD_LOCK() if (__isthreaded) pthread_mutex_lock(&pidlist_mutex) +#define THREAD_UNLOCK() if (__isthreaded) pthread_mutex_unlock(&pidlist_mutex) + + +/* + * e_popen() - ELWIX replacement of standard popen + * + * @command = command + * @type = type + * @ppid = return pid of child program + * return: NULL error or !=NULL open program + */ +#ifdef POPEN_STREAM +FILE * +#else +int +#endif +e_popen(const char *command, const char *type, pid_t *ppid) +{ + struct tagPIOPID *cur, *p; + int pdes[2], pid, twoway, cloexec; + char *argv[4]; + + if (!command || !type) +#ifdef POPEN_STREAM + return NULL; +#else + return -1; +#endif + + cloexec = strchr(type, 'e') != NULL; + /* + * Lite2 introduced two-way popen() pipes using _socketpair(). + * FreeBSD's pipe() is bidirectional, so we use that. + */ + if (strchr(type, '+')) { + twoway = 1; + type = "r+"; + } else { + twoway = 0; + if ((*type != 'r' && *type != 'w') || + (type[1] && (type[1] != 'e' || type[2]))) +#ifdef POPEN_STREAM + return NULL; +#else + return -1; +#endif + } + if (socketpair(AF_UNIX, SOCK_STREAM | (cloexec ? O_CLOEXEC : 0), + 0, pdes) < 0) { + LOGERR; +#ifdef POPEN_STREAM + return NULL; +#else + return -1; +#endif + } + + if (!(cur = e_malloc(sizeof(struct tagPIOPID)))) { + close(pdes[0]); + close(pdes[1]); +#ifdef POPEN_STREAM + return NULL; +#else + return -1; +#endif + } + + argv[0] = "sh"; + argv[1] = "-c"; + argv[2] = (char *) command; + argv[3] = NULL; + + THREAD_LOCK(); + switch (pid = vfork()) { + case -1: /* Error. */ + LOGERR; + THREAD_UNLOCK(); + close(pdes[0]); + close(pdes[1]); + e_free(cur); +#ifdef POPEN_STREAM + return NULL; +#else + return -1; +#endif + /* NOTREACHED */ + case 0: /* Child. */ + if (*type == 'r') { + /* + * The _dup2() to STDIN_FILENO is repeated to avoid + * writing to pdes[1], which might corrupt the + * parent's copy. This isn't good enough in + * general, since the _exit() is no return, so + * the compiler is free to corrupt all the local + * variables. + */ + if (!cloexec) + close(pdes[0]); + if (pdes[1] != STDOUT_FILENO) { + dup2(pdes[1], STDOUT_FILENO); + if (!cloexec) + close(pdes[1]); + if (twoway) + dup2(STDOUT_FILENO, STDIN_FILENO); + } else if (twoway && (pdes[1] != STDIN_FILENO)) { + dup2(pdes[1], STDIN_FILENO); + if (cloexec) + fcntl(pdes[1], F_SETFD, 0); + } else if (cloexec) + fcntl(pdes[1], F_SETFD, 0); + } else { + if (pdes[0] != STDIN_FILENO) { + dup2(pdes[0], STDIN_FILENO); + if (!cloexec) + close(pdes[0]); + } else if (cloexec) + fcntl(pdes[0], F_SETFD, 0); + if (!cloexec) + close(pdes[1]); + } + SLIST_FOREACH(p, &pio_pidlist, next) +#ifdef POPEN_STREAM + close(fileno(p->f.fp)); +#else + close(p->f.fd); +#endif + execve(_PATH_BSHELL, argv, environ); + _exit(127); + /* NOTREACHED */ + default: + if (ppid) + *ppid = pid; + } + THREAD_UNLOCK(); + + /* Parent; assume fdopen can't fail. */ + if (*type == 'r') { +#ifdef POPEN_STREAM + cur->f.fp = fdopen(pdes[0], type); +#else + cur->f.fd = pdes[0]; +#endif + close(pdes[1]); + } else { +#ifdef POPEN_STREAM + cur->f.fp = fdopen(pdes[1], type); +#else + cur->f.fd = pdes[1]; +#endif + close(pdes[0]); + } + + /* Link into list of file descriptors. */ + cur->pid = pid; + THREAD_LOCK(); + SLIST_INSERT_HEAD(&pio_pidlist, cur, next); + THREAD_UNLOCK(); + +#ifdef POPEN_STREAM + return cur->f.fp; +#else + return cur->f.fd; +#endif +} + +/* + * e_pclose() - ELWIX replacement of standard pclose + * + * @iop = popen handle + * return: -1 error or !=-1 pid status + */ +int +#ifdef POPEN_STREAM +e_pclose(FILE *iop) +#else +e_pclose(int iop) +#endif +{ + struct tagPIOPID *cur, *last = NULL; + int pstat; + pid_t pid; + + if (!iop) + return -1; + + /* + * Find the appropriate file pointer and remove it from the list. + */ + THREAD_LOCK(); + SLIST_FOREACH(cur, &pio_pidlist, next) { +#ifdef POPEN_STREAM + if (cur->f.fp == iop) +#else + if (cur->f.fd == iop) +#endif + break; + last = cur; + } + if (!cur) { + THREAD_UNLOCK(); + return (-1); + } + if (!last) + SLIST_REMOVE_HEAD(&pio_pidlist, next); + else + SLIST_REMOVE_AFTER(last, next); + THREAD_UNLOCK(); + +#ifdef POPEN_STREAM + fclose(iop); +#else + close(iop); +#endif + + do { + pid = wait4(cur->pid, &pstat, 0, NULL); + } while (pid == -1 && errno == EINTR); + + e_free(cur); + + return (pid == -1 ? -1 : pstat); +} + +/* + * pio_pgetpid() - Get tagPIOPID structure from file handle + * + * @iop = popen handle + * return: NULL error or !=NULL tagPIOPID structure + */ +struct tagPIOPID * +#ifdef POPEN_STREAM +pio_pgetpid(FILE *iop) +#else +pio_pgetpid(int iop) +#endif +{ + struct tagPIOPID *p; + + if (!iop) + return NULL; + + THREAD_LOCK(); + SLIST_FOREACH(p, &pio_pidlist, next) +#ifdef POPEN_STREAM + if (p->f.fp == iop) +#else + if (p->f.fd == iop) +#endif + break; + THREAD_UNLOCK(); + + return p; +} + +/* + * pio_pchkpid() - Check exit status of child programs + * + * @pids = return tagPIOPID structures of exited programs, + * if !=NULL must call array_Destroy() + * return: -1 error or >-1 exited programs + */ +int +pio_pchkpid(array_t ** __restrict pids) +{ + register int ret = 0; + struct tagPIOPID *p; + array_t *pa; + + if (pids) { + if (!(pa = array_Init(0))) + return -1; + else + *pids = pa; + } + + THREAD_LOCK(); + SLIST_FOREACH(p, &pio_pidlist, next) +#ifdef POPEN_STREAM + if (p->f.fp && waitpid(p->pid, &p->stat, WNOHANG) > 0) { +#else + if (p->f.fd && waitpid(p->pid, &p->stat, WNOHANG) > 0) { +#endif + if (pids) + array_Push(pa, p, 0); + ret++; + } + THREAD_UNLOCK(); + + return ret; +}