whyever the aclocal call was commented out…
[alioth/cvs.git] / vms / piped_child.c
1 /*
2  * piped_child.c
3  *
4  * An experimental VMS implementation of the same routine in [-.src]run.c
5  * <benjamin@cyclic.com>
6  *
7  * Derived in part from pipe.c, in this directory.
8  */
9
10 #include "vms.h"
11 #include "vms-types.h"
12
13 #include <stdio.h>
14 #include <stdlib.h>
15 #include <string.h>
16 #include <iodef.h>
17 #include <ssdef.h>
18 #include <syidef.h>
19 #include <clidef.h>
20 #include <stsdef.h>
21 #include <dvidef.h>
22 #include <nam.h>
23 #include <descrip.h>
24 #include <errno.h>
25 #include <file.h>
26 #include <lib$routines.h>
27 #include <starlet.h>
28
29 extern int trace;
30
31 /* Subprocess IO structure */
32 typedef struct _SUBIO {
33   struct _SUBIO *self;
34   struct _SUBIO *prev;
35   struct _SUBIO *next;
36   short read_chan;
37   short write_chan;
38   FILE *read_fp;
39   FILE *write_fp;
40   struct IOSB read_iosb;
41   struct IOSB write_iosb;
42   int pid;
43   int return_status;
44   unsigned long event_flag;
45   unsigned char event_flag_byte;
46 } SUBIO;
47
48 static SUBIO *siop_head = NULL, *siop_tail = NULL;
49
50 static int piped_child_exith(int);
51
52 static struct EXHCB piped_child_exit_handler_block = 
53   {0, piped_child_exith, 1, &piped_child_exit_handler_block.exh$l_status, 0};
54
55 typedef struct
56 {
57   short length;
58   char body[NAM$C_MAXRSS+1];
59 } Vstring;
60
61 /* Subprocess Completion AST */
62 void piped_child_done(siop)
63   SUBIO *siop;
64 {
65   struct IOSB iosb;
66   int status;
67
68   if (siop->self != siop)
69      return;
70   siop->read_iosb.status = SS$_NORMAL;
71   siop->write_iosb.status = SS$_NORMAL;
72
73 }
74
75 /* Exit handler, established by piped_child() */
76 static int
77 piped_child_exith(status)
78   int status;
79 {
80   struct IOSB iosb;
81   SUBIO *siop;
82   int return_value = 0;
83   
84   siop = siop_head;
85   while (siop)
86     {
87     if (siop->self != siop)
88       {
89         return_value = -1;
90         continue;
91       }
92
93     /* Finish pending reads and shutdown */      
94     if(!siop->read_iosb.status)
95       {
96         fflush (siop->read_fp);
97         fclose (siop->read_fp);
98       }
99     else
100       fclose (siop->read_fp);
101     sys$dassgn (siop->read_chan);
102
103     /* Finish pending writes and shutdown */
104     if(!siop->write_iosb.status)
105       {
106         fflush (siop->write_fp);
107         sys$qio (0, siop->write_chan, IO$_WRITEOF, &iosb,
108                  0, 0, 0, 0, 0, 0, 0, 0);
109         fclose (siop->write_fp);
110       }
111     else
112       fclose (siop->write_fp);
113     sys$dassgn (siop->write_chan);    
114
115     sys$synch (siop->event_flag, &siop->write_iosb);
116
117     siop = siop->next;
118     }
119   return return_value;
120 }
121
122 int piped_child(command, tofdp, fromfdp)
123 char **command;
124 int *tofdp, *fromfdp;
125 {
126   static int exit_handler = 0;
127   struct IOSB iosb1, iosb2;
128   int rs1, rs2, i;
129   unsigned long flags, vmspid, return_status;
130   char cmd[1024];
131   struct dsc$descriptor_s cmddsc;
132   struct dsc$descriptor_s read_mbxdsc, write_mbxdsc;
133   SUBIO *siop;
134   static Vstring read_mbxname, write_mbxname;
135   static struct itm$list3 write_mbxlist[2] = {
136       {sizeof(write_mbxname.body)-1, DVI$_DEVNAM,
137       &write_mbxname.body, (size_t *) &write_mbxname.length},
138       {0, 0, 0, 0} };
139   static struct itm$list3 read_mbxlist[2] = {
140       {sizeof(read_mbxname.body)-1, DVI$_DEVNAM,
141       &read_mbxname.body, (size_t *) &read_mbxname.length},
142       {0, 0, 0, 0} };
143   
144   read_mbxname.length = sizeof(read_mbxname.body);
145   write_mbxname.length = sizeof(write_mbxname.body);
146
147   siop = (SUBIO *) calloc(1, sizeof(SUBIO));
148   if (!siop)
149     {
150     perror("piped_child: malloc failed\n");
151     return -1;
152     }
153
154   siop->self = siop;
155
156   /* Construct command line by concatenating argument list */
157   strcpy(cmd, command[0]);
158   for(i=1; command[i] != NULL; i++)
159      {
160      strcat(cmd, " ");
161      strcat(cmd, command[i]);
162      }
163
164   if(trace)
165     fprintf(stderr, "piped_child: running '%s'\n", cmd);
166
167   /* Allocate a pair of temporary mailboxes (2kB each) */
168   rs1 = sys$crembx (0, &siop->read_chan, 2048, 2048, 0, 0, 0, 0);
169   rs2 = sys$crembx (0, &siop->write_chan, 2048, 2048, 0, 0, 0, 0);
170
171   if (rs1 != SS$_NORMAL || rs2 != SS$_NORMAL)
172     {
173       vaxc$errno = rs1 | rs2;
174       errno = EVMSERR;
175       free (siop);
176       perror ("piped_child: $CREMBX failure");
177       return -1;
178     }
179
180   /* Get mailbox names, so we can fopen() them */
181   rs1 = sys$getdviw (0, siop->read_chan, 0, &read_mbxlist,
182                     &iosb1, 0, 0, 0);
183
184   rs2 = sys$getdviw (0, siop->write_chan, 0, &write_mbxlist,
185                     &iosb2, 0, 0, 0);
186
187   if ((rs1 != SS$_NORMAL && !(iosb1.status & STS$M_SUCCESS)) ||
188       (rs2 != SS$_NORMAL && !(iosb2.status & STS$M_SUCCESS)))
189     {
190       vaxc$errno = iosb1.status | iosb2.status;
191       errno = EVMSERR;
192       sys$dassgn (siop->read_chan);
193       sys$dassgn (siop->write_chan);
194       free (siop);
195       perror ("piped_child: $GETDVIW failure, could not get mailbox names");
196       return -1;
197     }
198
199   if (trace)
200     {
201     fprintf(stderr, "piped_child: $GETDVIW succeeded, got mailbox names\n");
202     fprintf(stderr, "piped_child: ReadMBX: %s, WriteMBX: %s\n",
203             read_mbxname.body, write_mbxname.body);
204     }
205
206   /* Make C happy */
207   write_mbxname.body[write_mbxname.length] = '\0';
208   read_mbxname.body[read_mbxname.length] = '\0';
209
210   /* Make VMS happy */
211   write_mbxdsc.dsc$w_length  = write_mbxname.length;
212   write_mbxdsc.dsc$b_dtype   = DSC$K_DTYPE_T;
213   write_mbxdsc.dsc$b_class   = DSC$K_CLASS_S;
214   write_mbxdsc.dsc$a_pointer = write_mbxname.body;
215
216   read_mbxdsc.dsc$w_length  = read_mbxname.length;
217   read_mbxdsc.dsc$b_dtype   = DSC$K_DTYPE_T;
218   read_mbxdsc.dsc$b_class   = DSC$K_CLASS_S;
219   read_mbxdsc.dsc$a_pointer = read_mbxname.body;
220
221   /* Build descriptor for command line */
222   cmddsc.dsc$w_length  = strlen(cmd);
223   cmddsc.dsc$b_dtype   = DSC$K_DTYPE_T;
224   cmddsc.dsc$b_class   = DSC$K_CLASS_S;
225   cmddsc.dsc$a_pointer = (char *) cmd;
226
227   flags = CLI$M_NOWAIT;
228
229   /* Allocate an event flag to signal process termination */
230   rs1 = lib$get_ef(&siop->event_flag);
231   if (rs1 != SS$_NORMAL)
232      {
233      vaxc$errno = rs1;
234      errno = EVMSERR;
235      sys$dassgn(siop->read_chan);
236      sys$dassgn(siop->write_chan);
237      perror("piped_child: LIB$GET_EF failed");
238      return -1;
239      }
240
241   /* Save the EFN as a byte for later calls to other routines */
242   siop->event_flag_byte = 0xff & siop->event_flag;
243
244   if (trace)
245      fprintf(stderr, "piped_child: Got an EFN: %d\n", siop->event_flag_byte);
246
247   rs1 = lib$spawn(&cmddsc, &write_mbxdsc, &read_mbxdsc, &flags, 0,
248                   &siop->pid, &siop->return_status, &siop->event_flag_byte,
249                   &piped_child_done, siop->self);
250
251   if (rs1 != SS$_NORMAL)
252      {
253        vaxc$errno = rs1;
254        errno = EVMSERR;
255        sys$dassgn(siop->read_chan);
256        sys$dassgn(siop->write_chan);
257        perror("piped_child: LIB$SPAWN failure");
258        return -1;
259      }
260
261   if (trace)
262     fprintf(stderr, "piped_child: LIB$SPAWN succeeded, pid is %08x.\n",
263             siop->pid);
264
265   /* Establish an exit handler so the process isn't prematurely terminated */
266   if (!exit_handler)
267     {
268       rs1 = sys$dclexh (&piped_child_exit_handler_block);
269       if (rs1 != SS$_NORMAL)
270         {
271           vaxc$errno = rs1;
272           errno = EVMSERR;
273           sys$dassgn (siop->read_chan);
274           sys$dassgn (siop->write_chan);
275           sys$delprc (siop->pid, 0);
276           free (siop);
277           perror("piped_child: $DCLEXH failure");
278           return -1;
279         }
280       exit_handler = 1;
281     }
282
283   /* Let's open some files */
284   siop->read_fp = fopen (read_mbxname.body, "r");
285   siop->write_fp = fopen (write_mbxname.body, "w");
286   
287   if (!siop->read_fp || !siop->write_fp)
288     {
289       sys$dassgn (siop->read_chan);
290       sys$dassgn (siop->write_chan);
291       sys$delprc (siop->pid);
292       free (siop);
293       perror("piped_child: fopen() failed");
294       return -1;
295     } 
296
297   *fromfdp = fileno(siop->read_fp);
298   *tofdp = fileno(siop->write_fp);
299
300   if (trace)
301      fprintf(stderr, "piped_child: file open successful: tofd=%d fromfd=%d\n",
302              *tofdp, *fromfdp);
303
304   /* Keep track of active subprocess I/O (SUBIO) structures */
305   if (siop_head)
306     {
307       siop_tail->next = siop;
308       siop->prev = siop_tail;
309       siop_tail = siop;
310     }
311   else
312     siop_head = siop_tail = siop;
313
314   return siop->pid;
315 }
316
317 /*
318  * Return codes
319  * >0  VMS exit status of subprocess
320  *  0  success, subprocess was shutdown
321  * -1  pid not found in list of subprocesses
322  * -2  memory corruption detected
323  */
324 int
325 piped_child_shutdown(pid)
326   pid_t pid;
327 {
328   int return_status;
329   struct IOSB iosb;
330   SUBIO *siop = siop_head;
331   
332   while (siop && siop->self == siop && siop->pid != pid)
333     siop = siop->next;
334     
335   if (!siop)
336     return -1;
337   else if (siop->self != siop)
338     return -2;
339
340   /* Finish reading and writing and shutdown */  
341   if (siop->read_iosb.status)
342     {
343       fflush (siop->read_fp);
344       fclose (siop->read_fp);
345     }
346   else
347     fclose(siop->read_fp);
348   sys$dassgn (siop->read_chan);
349   
350    if (siop->write_iosb.status)
351     {
352       fflush (siop->write_fp);
353       sys$qio (0, siop->write_chan, IO$_WRITEOF, &iosb,
354                0, 0, 0, 0, 0, 0, 0, 0);
355       fclose (siop->write_fp);
356     }
357   else
358     fclose(siop->write_fp);
359   sys$dassgn (siop->write_chan);
360
361   sys$synch (siop->event_flag, &siop->write_iosb);
362   lib$free_ef(&siop->event_flag);
363
364   /* Ditch SUBIO structure */
365   if (siop == siop_tail)
366     siop_tail = siop->prev;
367   if (siop == siop_head)
368     siop_head = siop->next;
369   if (siop->prev)
370     siop->prev->next = siop->next;
371   if (siop->next)
372     siop->next->prev = siop->prev;
373   
374   if (siop->return_status)
375     return_status = siop->return_status;
376   else
377     return_status = 0;
378
379   free (siop);
380
381   return return_status;
382 }