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