src/common/unix_process.c

#ifndef lint
static const char       RCSid[] = "$Id: unix_process.c,v 3.15 2019/12/28 18:05:14 greg Exp $";
#endif
/*
 * Routines to communicate with separate process via dual pipes
 * Unix version
 *
 * External symbols declared in standard.h
 */

#include "copyright.h"

#include <sys/wait.h>
#include <stdlib.h>

#include "rtprocess.h"
#include "rtio.h"


SUBPROC         sp_inactive = SP_INACTIVE;


int
open_process(           /* open communication to separate process */
        SUBPROC *pd,
        char    *av[]
)
{
        char    *compath;
        int     p0[2], p1[2];

        if (pd->pid > 0)
                return(-1);             /* need to close, first */
        
        if ((pd->flags & (PF_FILT_INP|PF_FILT_OUT)) == (PF_FILT_INP|PF_FILT_OUT))
                return(-1);             /* circular process not supported */

        pd->flags &= ~PF_RUNNING;       /* not running for sure */
        pd->pid = -1;

        if (av == NULL)                 /* cloning operation? */
                compath = NULL;
        else if ((compath = getpath(av[0], getenv("PATH"), X_OK)) == NULL)
                return(0);

        if (pd->flags & PF_FILT_INP) {  /* filterning input stream? */
                if ((pd->r < 0) | (pd->r == 1))
                        return(-1);
                p0[0] = pd->r;
                p0[1] = -1;
        } else if (pipe(p0) < 0)
                return(-1);

        if (pd->flags & PF_FILT_OUT) {  /* filtering output stream? */
                if (pd->w < 1)
                        return(-1);
                p1[0] = -1;
                p1[1] = pd->w;
        } else if (pipe(p1) < 0)
                return(-1);
#ifdef BSD
        if (compath != NULL)
                pd->pid = vfork();      /* more efficient with exec() */
        else
#endif
        pd->pid = fork();
        if (pd->pid == 0) {             /* if child... */
                close(p0[1]);
                close(p1[0]);
                if (p0[0] != 0) {       /* connect p0 to stdin */
                        if (dup2(p0[0], 0) < 0)
                                return(-1);
                        close(p0[0]);
                }
                if (p1[1] != 1) {       /* connect p1 to stdout */
                        if (dup2(p1[1], 1) < 0)
                                return(-1);
                        close(p1[1]);
                }
                if (compath == NULL)    /* just cloning? */
                        return(0);
                                        /* else clear streams' FD_CLOEXEC */
                if (p0[0] == 0)
                        fcntl(0, F_SETFD, 0);
                if (p1[1] == 1)
                        fcntl(1, F_SETFD, 0);
                execv(compath, av);     /* exec command */
                perror(compath);
                _exit(127);
        }
        if (pd->pid == -1)
                return(-1);
                                        /* connect parent's streams */
        if (!(pd->flags & PF_FILT_INP)) {
                close(p0[0]);
                pd->r = p1[0];
        } else if (p1[0] != pd->r) {
                if (dup2(p1[0], pd->r) < 0)
                        return(-1);
                close(p1[0]);
        }
        if (!(pd->flags & PF_FILT_OUT)) {
                close(p1[1]);
                pd->w = p0[1];
        } else if (p0[1] != pd->w) {
                if (dup2(p0[1], pd->w) < 0)
                        return(-1);
                close(p0[1]);
        }
        /*
         * Close write stream on exec to avoid multiprocessing deadlock.
         * No use in read stream without it, so set flag there as well.
         * GW: This bug took me two days to figure out!!
         */
        if (pd->r >= 0)
                fcntl(pd->r, F_SETFD, FD_CLOEXEC);
        if (pd->w >= 0)
                fcntl(pd->w, F_SETFD, FD_CLOEXEC);
        pd->flags |= PF_RUNNING;
        return(PIPE_BUF);
}


int
close_processes(        /* close pipes and wait for processes to finish */
        SUBPROC pd[],
        int nproc
)
{
        int     togo = nproc;
        int     status, rtn_status = 0;
        RT_PID  pid;
        int     i;

        for (i = 0; i < nproc; i++)             /* close pipes, first */
                if (pd[i].flags & PF_RUNNING) {
                        close(pd[i].w);
                        close(pd[i].r);
                        pd[i].flags &= ~PF_RUNNING;
                } else 
                        togo -= (pd[i].pid < 0);
        if (nproc == 1) {                       /* await specific process? */
                status = 0;
                if (waitpid(pd->pid, &status, 0) != pd->pid)
                        return(-1);
                *pd = sp_inactive;
                return(status>>8 & 0xff);
        }
                                                /* else unordered wait */
        while (togo > 0 && (pid = wait(&status)) >= 0) {
                for (i = nproc; i-- > 0; )
                        if (pd[i].pid == pid) {
                                pd[i] = sp_inactive;
                                --togo;
                                break;
                        }
                if (i < 0)
                        continue;               /* child we don't know? */
                status = status>>8 & 0xff;
                if (status)                     /* record non-zero status */
                        rtn_status = status;
        }
        if (togo)                               /* child went missing? */
                return(-1);
        return(rtn_status);
}
Revision:	3.16
Committed:	Fri Feb 28 05:18:49 2020 UTC (4 years, 3 months ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 3.15:	+68 -22 lines
Log Message:	Added filtering capabilities to Unix version of open_process()
#	User	Rev	Content
1	schorsch	3.1	#ifndef lint
2	greg	3.16	static const char RCSid[] = "$Id: unix_process.c,v 3.15 2019/12/28 18:05:14 greg Exp $";
3	schorsch	3.1	#endif
4			/*
5			* Routines to communicate with separate process via dual pipes
6			* Unix version
7			*
8			* External symbols declared in standard.h
9			*/
10
11			#include "copyright.h"
12	schorsch	3.2
13			#include <sys/wait.h>
14	greg	3.7	#include <stdlib.h>
15	schorsch	3.1
16			#include "rtprocess.h"
17	greg	3.7	#include "rtio.h"
18	schorsch	3.1
19
20	greg	3.16	SUBPROC sp_inactive = SP_INACTIVE;
21
22
23	schorsch	3.1	int
24			open_process( /* open communication to separate process */
25	greg	3.16	SUBPROC *pd,
26			char *av[]
27	schorsch	3.1	)
28			{
29			char *compath;
30			int p0[2], p1[2];
31
32	greg	3.16	if (pd->pid > 0)
33			return(-1); /* need to close, first */
34
35			if ((pd->flags & (PF_FILT_INP\|PF_FILT_OUT)) == (PF_FILT_INP\|PF_FILT_OUT))
36			return(-1); /* circular process not supported */
37
38			pd->flags &= ~PF_RUNNING; /* not running for sure */
39	greg	3.12	pd->pid = -1;
40	greg	3.16
41	greg	3.10	if (av == NULL) /* cloning operation? */
42			compath = NULL;
43			else if ((compath = getpath(av[0], getenv("PATH"), X_OK)) == NULL)
44	schorsch	3.1	return(0);
45	greg	3.16
46			if (pd->flags & PF_FILT_INP) { /* filterning input stream? */
47			if ((pd->r < 0) \| (pd->r == 1))
48			return(-1);
49			p0[0] = pd->r;
50			p0[1] = -1;
51			} else if (pipe(p0) < 0)
52			return(-1);
53
54			if (pd->flags & PF_FILT_OUT) { /* filtering output stream? */
55			if (pd->w < 1)
56			return(-1);
57			p1[0] = -1;
58			p1[1] = pd->w;
59			} else if (pipe(p1) < 0)
60	schorsch	3.1	return(-1);
61	greg	3.14	#ifdef BSD
62			if (compath != NULL)
63			pd->pid = vfork(); /* more efficient with exec() */
64			else
65			#endif
66			pd->pid = fork();
67			if (pd->pid == 0) { /* if child... */
68	schorsch	3.1	close(p0[1]);
69			close(p1[0]);
70			if (p0[0] != 0) { /* connect p0 to stdin */
71	greg	3.16	if (dup2(p0[0], 0) < 0)
72			return(-1);
73	schorsch	3.1	close(p0[0]);
74			}
75			if (p1[1] != 1) { /* connect p1 to stdout */
76	greg	3.16	if (dup2(p1[1], 1) < 0)
77			return(-1);
78	schorsch	3.1	close(p1[1]);
79			}
80	greg	3.10	if (compath == NULL) /* just cloning? */
81			return(0);
82	greg	3.16	/* else clear streams' FD_CLOEXEC */
83			if (p0[0] == 0)
84			fcntl(0, F_SETFD, 0);
85			if (p1[1] == 1)
86			fcntl(1, F_SETFD, 0);
87			execv(compath, av); /* exec command */
88	schorsch	3.1	perror(compath);
89			_exit(127);
90			}
91			if (pd->pid == -1)
92			return(-1);
93	greg	3.16	/* connect parent's streams */
94			if (!(pd->flags & PF_FILT_INP)) {
95			close(p0[0]);
96			pd->r = p1[0];
97			} else if (p1[0] != pd->r) {
98			if (dup2(p1[0], pd->r) < 0)
99			return(-1);
100			close(p1[0]);
101			}
102			if (!(pd->flags & PF_FILT_OUT)) {
103			close(p1[1]);
104			pd->w = p0[1];
105			} else if (p0[1] != pd->w) {
106			if (dup2(p0[1], pd->w) < 0)
107			return(-1);
108			close(p0[1]);
109			}
110	greg	3.6	/*
111			* Close write stream on exec to avoid multiprocessing deadlock.
112			* No use in read stream without it, so set flag there as well.
113			* GW: This bug took me two days to figure out!!
114			*/
115	greg	3.16	if (pd->r >= 0)
116			fcntl(pd->r, F_SETFD, FD_CLOEXEC);
117			if (pd->w >= 0)
118			fcntl(pd->w, F_SETFD, FD_CLOEXEC);
119			pd->flags \|= PF_RUNNING;
120	schorsch	3.1	return(PIPE_BUF);
121			}
122
123
124			int
125	greg	3.11	close_processes( /* close pipes and wait for processes to finish */
126	greg	3.16	SUBPROC pd[],
127			int nproc
128	schorsch	3.1	)
129			{
130	greg	3.11	int togo = nproc;
131			int status, rtn_status = 0;
132			RT_PID pid;
133			int i;
134
135			for (i = 0; i < nproc; i++) /* close pipes, first */
136	greg	3.16	if (pd[i].flags & PF_RUNNING) {
137	greg	3.11	close(pd[i].w);
138			close(pd[i].r);
139	greg	3.16	pd[i].flags &= ~PF_RUNNING;
140	greg	3.13	} else
141			togo -= (pd[i].pid < 0);
142	greg	3.11	if (nproc == 1) { /* await specific process? */
143	greg	3.16	status = 0;
144	greg	3.11	if (waitpid(pd->pid, &status, 0) != pd->pid)
145			return(-1);
146	greg	3.16	*pd = sp_inactive;
147	greg	3.5	return(status>>8 & 0xff);
148	greg	3.11	}
149			/* else unordered wait */
150			while (togo > 0 && (pid = wait(&status)) >= 0) {
151			for (i = nproc; i-- > 0; )
152			if (pd[i].pid == pid) {
153	greg	3.16	pd[i] = sp_inactive;
154	greg	3.11	--togo;
155			break;
156			}
157			if (i < 0)
158			continue; /* child we don't know? */
159			status = status>>8 & 0xff;
160			if (status) /* record non-zero status */
161			rtn_status = status;
162			}
163			if (togo) /* child went missing? */
164			return(-1);
165			return(rtn_status);
166	schorsch	3.1	}