xref: /freebsd/usr.sbin/ppp/chat.c (revision 1b6c2589164a3a7b2f62d4c28c2ffa1be860959e) 
1 /*-
2  * Copyright (c) 1998 Brian Somers <brian@Awfulhak.org>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  *
26  * $FreeBSD$
27  */
28 
29 #include <sys/param.h>
30 #include <netinet/in.h>
31 #include <netinet/in_systm.h>
32 #include <netinet/ip.h>
33 #include <sys/socket.h>
34 #include <sys/un.h>
35 
36 #include <errno.h>
37 #include <fcntl.h>
38 #include <paths.h>
39 #include <stdio.h>
40 #include <stdlib.h>
41 #include <string.h>
42 #include <sys/wait.h>
43 #include <termios.h>
44 #include <unistd.h>
45 
46 #include "layer.h"
47 #include "mbuf.h"
48 #include "log.h"
49 #include "defs.h"
50 #include "timer.h"
51 #include "lqr.h"
52 #include "hdlc.h"
53 #include "throughput.h"
54 #include "fsm.h"
55 #include "lcp.h"
56 #include "ccp.h"
57 #include "link.h"
58 #include "async.h"
59 #include "descriptor.h"
60 #include "physical.h"
61 #include "chat.h"
62 #include "mp.h"
63 #include "auth.h"
64 #include "chap.h"
65 #include "slcompress.h"
66 #include "iplist.h"
67 #include "ncpaddr.h"
68 #include "ip.h"
69 #include "ipcp.h"
70 #include "filter.h"
71 #include "cbcp.h"
72 #include "command.h"
73 #include "datalink.h"
74 #ifndef NORADIUS
75 #include "radius.h"
76 #endif
77 #include "ipv6cp.h"
78 #include "ncp.h"
79 #include "bundle.h"
80 #include "id.h"
81 
82 #define BUFLEFT(c) (sizeof (c)->buf - ((c)->bufend - (c)->buf))
83 
84 static void ExecStr(struct physical *, char *, char *, int);
85 static char *ExpandString(struct chat *, const char *, char *, int, int);
86 
87 static void
88 chat_PauseTimer(void *v)
89 {
90   struct chat *c = (struct chat *)v;
91   timer_Stop(&c->pause);
92   c->pause.load = 0;
93 }
94 
95 static void
96 chat_Pause(struct chat *c, u_long load)
97 {
98   timer_Stop(&c->pause);
99   c->pause.load += load;
100   c->pause.func = chat_PauseTimer;
101   c->pause.name = "chat pause";
102   c->pause.arg = c;
103   timer_Start(&c->pause);
104 }
105 
106 static void
107 chat_TimeoutTimer(void *v)
108 {
109   struct chat *c = (struct chat *)v;
110   timer_Stop(&c->timeout);
111   c->TimedOut = 1;
112 }
113 
114 static void
115 chat_SetTimeout(struct chat *c)
116 {
117   timer_Stop(&c->timeout);
118   if (c->TimeoutSec > 0) {
119     c->timeout.load = SECTICKS * c->TimeoutSec;
120     c->timeout.func = chat_TimeoutTimer;
121     c->timeout.name = "chat timeout";
122     c->timeout.arg = c;
123     timer_Start(&c->timeout);
124   }
125 }
126 
127 static char *
128 chat_NextChar(char *ptr, char ch)
129 {
130   for (; *ptr; ptr++)
131     if (*ptr == ch)
132       return ptr;
133     else if (*ptr == '\\')
134       if (*++ptr == '\0')
135         return NULL;
136 
137   return NULL;
138 }
139 
140 static int
141 chat_UpdateSet(struct fdescriptor *d, fd_set *r, fd_set *w, fd_set *e, int *n)
142 {
143   struct chat *c = descriptor2chat(d);
144   int special, gotabort, gottimeout, needcr;
145   int TimedOut = c->TimedOut;
146   static char arg_term;		/* An empty string */
147 
148   if (c->pause.state == TIMER_RUNNING)
149     return 0;
150 
151   if (TimedOut) {
152     log_Printf(LogCHAT, "Expect timeout\n");
153     if (c->nargptr == NULL)
154       c->state = CHAT_FAILED;
155     else {
156       /* c->state = CHAT_EXPECT; */
157       c->argptr = &arg_term;
158     }
159     c->TimedOut = 0;
160   }
161 
162   if (c->state != CHAT_EXPECT && c->state != CHAT_SEND)
163     return 0;
164 
165   gottimeout = gotabort = 0;
166 
167   if (c->arg < c->argc && (c->arg < 0 || *c->argptr == '\0')) {
168     /* Go get the next string */
169     if (c->arg < 0 || c->state == CHAT_SEND)
170       c->state = CHAT_EXPECT;
171     else
172       c->state = CHAT_SEND;
173 
174     special = 1;
175     while (special && (c->nargptr || c->arg < c->argc - 1)) {
176       if (c->arg < 0 || (!TimedOut && c->state == CHAT_SEND))
177         c->nargptr = NULL;
178 
179       if (c->nargptr != NULL) {
180         /* We're doing expect-send-expect.... */
181         c->argptr = c->nargptr;
182         /* Put the '-' back in case we ever want to rerun our script */
183         c->nargptr[-1] = '-';
184         c->nargptr = chat_NextChar(c->nargptr, '-');
185         if (c->nargptr != NULL)
186           *c->nargptr++ = '\0';
187       } else {
188         int minus;
189 
190         if ((c->argptr = c->argv[++c->arg]) == NULL) {
191           /* End of script - all ok */
192           c->state = CHAT_DONE;
193           return 0;
194         }
195 
196         if (c->state == CHAT_EXPECT) {
197           /* Look for expect-send-expect sequence */
198           c->nargptr = c->argptr;
199           minus = 0;
200           while ((c->nargptr = chat_NextChar(c->nargptr, '-'))) {
201             c->nargptr++;
202             minus++;
203           }
204 
205           if (minus % 2)
206             log_Printf(LogWARN, "chat_UpdateSet: \"%s\": Uneven number of"
207                       " '-' chars, all ignored\n", c->argptr);
208           else if (minus) {
209             c->nargptr = chat_NextChar(c->argptr, '-');
210             *c->nargptr++ = '\0';
211           }
212         }
213       }
214 
215       /*
216        * c->argptr now temporarily points into c->script (via c->argv)
217        * If it's an expect-send-expect sequence, we've just got the correct
218        * portion of that sequence.
219        */
220 
221       needcr = c->state == CHAT_SEND &&
222                (*c->argptr != '!' || c->argptr[1] == '!');
223 
224       /* We leave room for a potential HDLC header in the target string */
225       ExpandString(c, c->argptr, c->exp + 2, sizeof c->exp - 2, needcr);
226 
227       /*
228        * Now read our string.  If it's not a special string, we unset
229        * ``special'' to break out of the loop.
230        */
231       if (gotabort) {
232         if (c->abort.num < MAXABORTS) {
233           int len, i;
234 
235           len = strlen(c->exp+2);
236           for (i = 0; i < c->abort.num; i++)
237             if (len > c->abort.string[i].len) {
238               int last;
239 
240               for (last = c->abort.num; last > i; last--) {
241                 c->abort.string[last].data = c->abort.string[last-1].data;
242                 c->abort.string[last].len = c->abort.string[last-1].len;
243               }
244               break;
245             }
246           c->abort.string[i].len = len;
247           c->abort.string[i].data = (char *)malloc(len+1);
248           memcpy(c->abort.string[i].data, c->exp+2, len+1);
249           c->abort.num++;
250         } else
251           log_Printf(LogERROR, "chat_UpdateSet: too many abort strings\n");
252         gotabort = 0;
253       } else if (gottimeout) {
254         c->TimeoutSec = atoi(c->exp + 2);
255         if (c->TimeoutSec <= 0)
256           c->TimeoutSec = 30;
257         gottimeout = 0;
258       } else if (c->nargptr == NULL && !strcmp(c->exp+2, "ABORT"))
259         gotabort = 1;
260       else if (c->nargptr == NULL && !strcmp(c->exp+2, "TIMEOUT"))
261         gottimeout = 1;
262       else {
263         if (c->exp[2] == '!' && c->exp[3] != '!')
264           ExecStr(c->physical, c->exp + 3, c->exp + 3, sizeof c->exp - 3);
265 
266         if (c->exp[2] == '\0') {
267           /* Empty string, reparse (this may be better as a `goto start') */
268           c->argptr = &arg_term;
269           return chat_UpdateSet(d, r, w, e, n);
270         }
271 
272         special = 0;
273       }
274     }
275 
276     if (special) {
277       if (gottimeout)
278         log_Printf(LogWARN, "chat_UpdateSet: TIMEOUT: Argument expected\n");
279       else if (gotabort)
280         log_Printf(LogWARN, "chat_UpdateSet: ABORT: Argument expected\n");
281 
282       /* End of script - all ok */
283       c->state = CHAT_DONE;
284       return 0;
285     }
286 
287     /* set c->argptr to point in the right place */
288     c->argptr = c->exp + (c->exp[2] == '!' ? 3 : 2);
289     c->arglen = strlen(c->argptr);
290 
291     if (c->state == CHAT_EXPECT) {
292       /* We must check to see if the string's already been found ! */
293       char *begin, *end;
294 
295       end = c->bufend - c->arglen + 1;
296       if (end < c->bufstart)
297         end = c->bufstart;
298       for (begin = c->bufstart; begin < end; begin++)
299         if (!strncmp(begin, c->argptr, c->arglen)) {
300           c->bufstart = begin + c->arglen;
301           c->argptr += c->arglen;
302           c->arglen = 0;
303           /* Continue - we've already read our expect string */
304           return chat_UpdateSet(d, r, w, e, n);
305         }
306 
307       log_Printf(LogCHAT, "Expect(%d): %s\n", c->TimeoutSec, c->argptr);
308       chat_SetTimeout(c);
309     }
310   }
311 
312   /*
313    * We now have c->argptr pointing at what we want to expect/send and
314    * c->state saying what we want to do... we now know what to put in
315    * the fd_set :-)
316    */
317 
318   if (c->state == CHAT_EXPECT)
319     return physical_doUpdateSet(&c->physical->desc, r, NULL, e, n, 1);
320   else
321     return physical_doUpdateSet(&c->physical->desc, NULL, w, e, n, 1);
322 }
323 
324 static int
325 chat_IsSet(struct fdescriptor *d, const fd_set *fdset)
326 {
327   struct chat *c = descriptor2chat(d);
328   return c->argptr && physical_IsSet(&c->physical->desc, fdset);
329 }
330 
331 static void
332 chat_UpdateLog(struct chat *c, int in)
333 {
334   if (log_IsKept(LogCHAT) || log_IsKept(LogCONNECT)) {
335     /*
336      * If a linefeed appears in the last `in' characters of `c's input
337      * buffer, output from there, all the way back to the last linefeed.
338      * This is called for every read of `in' bytes.
339      */
340     char *ptr, *end, *stop, ch;
341     int level;
342 
343     level = log_IsKept(LogCHAT) ? LogCHAT : LogCONNECT;
344     if (in == -1)
345       end = ptr = c->bufend;
346     else {
347       ptr = c->bufend - in;
348       for (end = c->bufend - 1; end >= ptr; end--)
349         if (*end == '\n')
350           break;
351     }
352 
353     if (end >= ptr) {
354       for (ptr = c->bufend - (in == -1 ? 1 : in + 1); ptr >= c->bufstart; ptr--)
355         if (*ptr == '\n')
356           break;
357       ptr++;
358       stop = NULL;
359       while (stop < end) {
360         if ((stop = memchr(ptr, '\n', end - ptr)) == NULL)
361           stop = end;
362         ch = *stop;
363         *stop = '\0';
364         if (level == LogCHAT || strstr(ptr, "CONNECT"))
365           log_Printf(level, "Received: %s\n", ptr);
366         *stop = ch;
367         ptr = stop + 1;
368       }
369     }
370   }
371 }
372 
373 static void
374 chat_Read(struct fdescriptor *d, struct bundle *bundle, const fd_set *fdset)
375 {
376   struct chat *c = descriptor2chat(d);
377 
378   if (c->state == CHAT_EXPECT) {
379     ssize_t in;
380     char *abegin, *ebegin, *begin, *aend, *eend, *end;
381     int n;
382 
383     /*
384      * XXX - should this read only 1 byte to guarantee that we don't
385      * swallow any ppp talk from the peer ?
386      */
387     in = BUFLEFT(c);
388     if (in > sizeof c->buf / 2)
389       in = sizeof c->buf / 2;
390 
391     in = physical_Read(c->physical, c->bufend, in);
392     if (in <= 0)
393       return;
394 
395     /* `begin' and `end' delimit where we're going to strncmp() from */
396     ebegin = c->bufend - c->arglen + 1;
397     eend = ebegin + in;
398     if (ebegin < c->bufstart)
399       ebegin = c->bufstart;
400 
401     if (c->abort.num) {
402       abegin = c->bufend - c->abort.string[0].len + 1;
403       aend = c->bufend - c->abort.string[c->abort.num-1].len + in + 1;
404       if (abegin < c->bufstart)
405         abegin = c->bufstart;
406     } else {
407       abegin = ebegin;
408       aend = eend;
409     }
410     begin = abegin < ebegin ? abegin : ebegin;
411     end = aend < eend ? eend : aend;
412 
413     c->bufend += in;
414 
415     chat_UpdateLog(c, in);
416 
417     if (c->bufend > c->buf + sizeof c->buf / 2) {
418       /* Shuffle our receive buffer back a bit */
419       int chop;
420 
421       for (chop = begin - c->buf; chop; chop--)
422         if (c->buf[chop] == '\n')
423           /* found some already-logged garbage to remove :-) */
424           break;
425 
426       if (!chop)
427         chop = begin - c->buf;
428 
429       if (chop) {
430         char *from, *to;
431 
432         to = c->buf;
433         from = to + chop;
434         while (from < c->bufend)
435           *to++ = *from++;
436         c->bufstart -= chop;
437         c->bufend -= chop;
438         begin -= chop;
439         end -= chop;
440         abegin -= chop;
441         aend -= chop;
442         ebegin -= chop;
443         eend -= chop;
444       }
445     }
446 
447     for (; begin < end; begin++)
448       if (begin >= ebegin && begin < eend &&
449           !strncmp(begin, c->argptr, c->arglen)) {
450         /* Got it ! */
451         timer_Stop(&c->timeout);
452         if (memchr(begin + c->arglen - 1, '\n',
453             c->bufend - begin - c->arglen + 1) == NULL) {
454           /* force it into the log */
455           end = c->bufend;
456           c->bufend = begin + c->arglen;
457           chat_UpdateLog(c, -1);
458           c->bufend = end;
459         }
460         c->bufstart = begin + c->arglen;
461         c->argptr += c->arglen;
462         c->arglen = 0;
463         break;
464       } else if (begin >= abegin && begin < aend) {
465         for (n = c->abort.num - 1; n >= 0; n--) {
466           if (begin + c->abort.string[n].len > c->bufend)
467             break;
468           if (!strncmp(begin, c->abort.string[n].data,
469                        c->abort.string[n].len)) {
470             if (memchr(begin + c->abort.string[n].len - 1, '\n',
471                 c->bufend - begin - c->abort.string[n].len + 1) == NULL) {
472               /* force it into the log */
473               end = c->bufend;
474               c->bufend = begin + c->abort.string[n].len;
475               chat_UpdateLog(c, -1);
476               c->bufend = end;
477             }
478             c->bufstart = begin + c->abort.string[n].len;
479             c->state = CHAT_FAILED;
480             return;
481           }
482         }
483       }
484   }
485 }
486 
487 static int
488 chat_Write(struct fdescriptor *d, struct bundle *bundle, const fd_set *fdset)
489 {
490   struct chat *c = descriptor2chat(d);
491   int result = 0;
492 
493   if (c->state == CHAT_SEND) {
494     int wrote;
495 
496     if (strstr(c->argv[c->arg], "\\P"))            /* Don't log the password */
497       log_Printf(LogCHAT, "Send: %s\n", c->argv[c->arg]);
498     else {
499       int sz;
500 
501       sz = c->arglen - 1;
502       while (sz >= 0 && c->argptr[sz] == '\n')
503         sz--;
504       log_Printf(LogCHAT, "Send: %.*s\n", sz + 1, c->argptr);
505     }
506 
507     if (physical_IsSync(c->physical)) {
508       /*
509        * XXX: Fix me
510        * This data should be stuffed down through the link layers
511        */
512       /* There's always room for the HDLC header */
513       c->argptr -= 2;
514       c->arglen += 2;
515       memcpy(c->argptr, "\377\003", 2);	/* Prepend HDLC header */
516     }
517 
518     wrote = physical_Write(c->physical, c->argptr, c->arglen);
519     result = wrote ? 1 : 0;
520     if (wrote == -1) {
521       if (errno != EINTR)
522         log_Printf(LogERROR, "chat_Write: %s\n", strerror(errno));
523       if (physical_IsSync(c->physical)) {
524         c->argptr += 2;
525         c->arglen -= 2;
526       }
527     } else if (wrote < 2 && physical_IsSync(c->physical)) {
528       /* Oops - didn't even write our HDLC header ! */
529       c->argptr += 2;
530       c->arglen -= 2;
531     } else {
532       c->argptr += wrote;
533       c->arglen -= wrote;
534     }
535   }
536 
537   return result;
538 }
539 
540 void
541 chat_Init(struct chat *c, struct physical *p)
542 {
543   c->desc.type = CHAT_DESCRIPTOR;
544   c->desc.UpdateSet = chat_UpdateSet;
545   c->desc.IsSet = chat_IsSet;
546   c->desc.Read = chat_Read;
547   c->desc.Write = chat_Write;
548   c->physical = p;
549   *c->script = '\0';
550   c->argc = 0;
551   c->arg = -1;
552   c->argptr = NULL;
553   c->nargptr = NULL;
554   c->bufstart = c->bufend = c->buf;
555 
556   memset(&c->pause, '\0', sizeof c->pause);
557   memset(&c->timeout, '\0', sizeof c->timeout);
558 }
559 
560 int
561 chat_Setup(struct chat *c, const char *data, const char *phone)
562 {
563   c->state = CHAT_EXPECT;
564 
565   if (data == NULL) {
566     *c->script = '\0';
567     c->argc = 0;
568   } else {
569     strncpy(c->script, data, sizeof c->script - 1);
570     c->script[sizeof c->script - 1] = '\0';
571     c->argc = MakeArgs(c->script, c->argv, VECSIZE(c->argv), PARSE_NOHASH);
572   }
573 
574   c->arg = -1;
575   c->argptr = NULL;
576   c->nargptr = NULL;
577 
578   c->TimeoutSec = 30;
579   c->TimedOut = 0;
580   c->phone = phone;
581   c->abort.num = 0;
582 
583   timer_Stop(&c->pause);
584   timer_Stop(&c->timeout);
585 
586   return c->argc >= 0;
587 }
588 
589 void
590 chat_Finish(struct chat *c)
591 {
592   timer_Stop(&c->pause);
593   timer_Stop(&c->timeout);
594   while (c->abort.num)
595     free(c->abort.string[--c->abort.num].data);
596   c->abort.num = 0;
597 }
598 
599 void
600 chat_Destroy(struct chat *c)
601 {
602   chat_Finish(c);
603 }
604 
605 /*
606  *  \c	don't add a cr
607  *  \d  Sleep a little (delay 2 seconds
608  *  \n  Line feed character
609  *  \P  Auth Key password
610  *  \p  pause 0.25 sec
611  *  \r	Carrige return character
612  *  \s  Space character
613  *  \T  Telephone number(s) (defined via `set phone')
614  *  \t  Tab character
615  *  \U  Auth User
616  */
617 static char *
618 ExpandString(struct chat *c, const char *str, char *result, int reslen, int cr)
619 {
620   int len;
621 
622   result[--reslen] = '\0';
623   while (*str && reslen > 0) {
624     switch (*str) {
625     case '\\':
626       str++;
627       switch (*str) {
628       case 'c':
629 	cr = 0;
630 	break;
631       case 'd':		/* Delay 2 seconds */
632         chat_Pause(c, 2 * SECTICKS);
633 	break;
634       case 'p':
635         chat_Pause(c, SECTICKS / 4);
636 	break;		/* Delay 0.25 seconds */
637       case 'n':
638 	*result++ = '\n';
639 	reslen--;
640 	break;
641       case 'r':
642 	*result++ = '\r';
643 	reslen--;
644 	break;
645       case 's':
646 	*result++ = ' ';
647 	reslen--;
648 	break;
649       case 't':
650 	*result++ = '\t';
651 	reslen--;
652 	break;
653       case 'P':
654 	strncpy(result, c->physical->dl->bundle->cfg.auth.key, reslen);
655         len = strlen(result);
656 	reslen -= len;
657 	result += len;
658 	break;
659       case 'T':
660         if (c->phone) {
661           strncpy(result, c->phone, reslen);
662           len = strlen(result);
663           reslen -= len;
664           result += len;
665         }
666 	break;
667       case 'U':
668 	strncpy(result, c->physical->dl->bundle->cfg.auth.name, reslen);
669         len = strlen(result);
670 	reslen -= len;
671 	result += len;
672 	break;
673       default:
674 	reslen--;
675 	*result++ = *str;
676 	break;
677       }
678       if (*str)
679 	str++;
680       break;
681     case '^':
682       str++;
683       if (*str) {
684 	*result++ = *str++ & 0x1f;
685 	reslen--;
686       }
687       break;
688     default:
689       *result++ = *str++;
690       reslen--;
691       break;
692     }
693   }
694   if (--reslen > 0) {
695     if (cr)
696       *result++ = '\r';
697   }
698   if (--reslen > 0)
699     *result++ = '\0';
700   return (result);
701 }
702 
703 static void
704 ExecStr(struct physical *physical, char *command, char *out, int olen)
705 {
706   pid_t pid;
707   int fids[2];
708   char *argv[MAXARGS], *vector[MAXARGS], *startout, *endout;
709   int stat, nb, argc, i;
710 
711   log_Printf(LogCHAT, "Exec: %s\n", command);
712   if ((argc = MakeArgs(command, vector, VECSIZE(vector),
713                        PARSE_REDUCE|PARSE_NOHASH)) <= 0) {
714     if (argc < 0)
715       log_Printf(LogWARN, "Syntax error in exec command\n");
716     *out = '\0';
717     return;
718   }
719   command_Expand(argv, argc, (char const *const *)vector,
720                  physical->dl->bundle, 0, getpid());
721 
722   if (pipe(fids) < 0) {
723     log_Printf(LogCHAT, "Unable to create pipe in ExecStr: %s\n",
724 	      strerror(errno));
725     *out = '\0';
726     return;
727   }
728   if ((pid = fork()) == 0) {
729     close(fids[0]);
730     timer_TermService();
731     if (fids[1] == STDIN_FILENO)
732       fids[1] = dup(fids[1]);
733     dup2(physical->fd, STDIN_FILENO);
734     dup2(fids[1], STDERR_FILENO);
735     dup2(STDIN_FILENO, STDOUT_FILENO);
736     close(3);
737     if (open(_PATH_TTY, O_RDWR) != 3)
738       open(_PATH_DEVNULL, O_RDWR);	/* Leave it closed if it fails... */
739     for (i = getdtablesize(); i > 3; i--)
740       fcntl(i, F_SETFD, 1);
741 #ifndef NOSUID
742     setuid(ID0realuid());
743 #endif
744     execvp(argv[0], argv);
745     fprintf(stderr, "execvp: %s: %s\n", argv[0], strerror(errno));
746     _exit(127);
747   } else {
748     char *name = strdup(vector[0]);
749 
750     close(fids[1]);
751     endout = out + olen - 1;
752     startout = out;
753     while (out < endout) {
754       nb = read(fids[0], out, 1);
755       if (nb <= 0)
756 	break;
757       out++;
758     }
759     *out = '\0';
760     close(fids[0]);
761     close(fids[1]);
762     waitpid(pid, &stat, WNOHANG);
763     if (WIFSIGNALED(stat)) {
764       log_Printf(LogWARN, "%s: signal %d\n", name, WTERMSIG(stat));
765       free(name);
766       *out = '\0';
767       return;
768     } else if (WIFEXITED(stat)) {
769       switch (WEXITSTATUS(stat)) {
770         case 0:
771           free(name);
772           break;
773         case 127:
774           log_Printf(LogWARN, "%s: %s\n", name, startout);
775           free(name);
776           *out = '\0';
777           return;
778           break;
779         default:
780           log_Printf(LogWARN, "%s: exit %d\n", name, WEXITSTATUS(stat));
781           free(name);
782           *out = '\0';
783           return;
784           break;
785       }
786     } else {
787       log_Printf(LogWARN, "%s: Unexpected exit result\n", name);
788       free(name);
789       *out = '\0';
790       return;
791     }
792   }
793 }
794