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