usr.sbin/ppp/chat.c

   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: src/usr.sbin/ppp/chat.c,v 1.70.2.3 2002/09/01 02:12:23 brian Exp $
  27  * $DragonFly: src/usr.sbin/ppp/chat.c,v 1.2 2003/06/17 04:30:00 dillon Exp $
  28  */
  29
  30 #include <sys/param.h>
  31 #include <netinet/in.h>
  32 #include <netinet/in_systm.h>
  33 #include <netinet/ip.h>
  34 #include <sys/socket.h>
  35 #include <sys/un.h>
  36
  37 #include <errno.h>
  38 #include <fcntl.h>
  39 #include <paths.h>
  40 #include <stdio.h>
  41 #include <stdlib.h>
  42 #include <string.h>
  43 #include <sys/wait.h>
  44 #include <termios.h>
  45 #include <unistd.h>
  46
  47 #include "layer.h"
  48 #include "mbuf.h"
  49 #include "log.h"
  50 #include "defs.h"
  51 #include "timer.h"
  52 #include "lqr.h"
  53 #include "hdlc.h"
  54 #include "throughput.h"
  55 #include "fsm.h"
  56 #include "lcp.h"
  57 #include "ccp.h"
  58 #include "link.h"
  59 #include "async.h"
  60 #include "descriptor.h"
  61 #include "physical.h"
  62 #include "chat.h"
  63 #include "mp.h"
  64 #include "auth.h"
  65 #include "chap.h"
  66 #include "slcompress.h"
  67 #include "iplist.h"
  68 #include "ncpaddr.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 __unused,
 375           const fd_set *fdset __unused)
 376 {
 377   struct chat *c = descriptor2chat(d);
 378
 379   if (c->state == CHAT_EXPECT) {
 380     ssize_t in;
 381     char *abegin, *ebegin, *begin, *aend, *eend, *end;
 382     int n;
 383
 384     /*
 385      * XXX - should this read only 1 byte to guarantee that we don't
 386      * swallow any ppp talk from the peer ?
 387      */
 388     in = BUFLEFT(c);
 389     if (in > (ssize_t)sizeof c->buf / 2)
 390       in = sizeof c->buf / 2;
 391
 392     in = physical_Read(c->physical, c->bufend, in);
 393     if (in <= 0)
 394       return;
 395
 396     /* `begin' and `end' delimit where we're going to strncmp() from */
 397     ebegin = c->bufend - c->arglen + 1;
 398     eend = ebegin + in;
 399     if (ebegin < c->bufstart)
 400       ebegin = c->bufstart;
 401
 402     if (c->abort.num) {
 403       abegin = c->bufend - c->abort.string[0].len + 1;
 404       aend = c->bufend - c->abort.string[c->abort.num-1].len + in + 1;
 405       if (abegin < c->bufstart)
 406         abegin = c->bufstart;
 407     } else {
 408       abegin = ebegin;
 409       aend = eend;
 410     }
 411     begin = abegin < ebegin ? abegin : ebegin;
 412     end = aend < eend ? eend : aend;
 413
 414     c->bufend += in;
 415
 416     chat_UpdateLog(c, in);
 417
 418     if (c->bufend > c->buf + sizeof c->buf / 2) {
 419       /* Shuffle our receive buffer back a bit */
 420       int chop;
 421
 422       for (chop = begin - c->buf; chop; chop--)
 423         if (c->buf[chop] == '\n')
 424           /* found some already-logged garbage to remove :-) */
 425           break;
 426
 427       if (!chop)
 428         chop = begin - c->buf;
 429
 430       if (chop) {
 431         char *from, *to;
 432
 433         to = c->buf;
 434         from = to + chop;
 435         while (from < c->bufend)
 436           *to++ = *from++;
 437         c->bufstart -= chop;
 438         c->bufend -= chop;
 439         begin -= chop;
 440         end -= chop;
 441         abegin -= chop;
 442         aend -= chop;
 443         ebegin -= chop;
 444         eend -= chop;
 445       }
 446     }
 447
 448     for (; begin < end; begin++)
 449       if (begin >= ebegin && begin < eend &&
 450           !strncmp(begin, c->argptr, c->arglen)) {
 451         /* Got it ! */
 452         timer_Stop(&c->timeout);
 453         if (memchr(begin + c->arglen - 1, '\n',
 454             c->bufend - begin - c->arglen + 1) == NULL) {
 455           /* force it into the log */
 456           end = c->bufend;
 457           c->bufend = begin + c->arglen;
 458           chat_UpdateLog(c, -1);
 459           c->bufend = end;
 460         }
 461         c->bufstart = begin + c->arglen;
 462         c->argptr += c->arglen;
 463         c->arglen = 0;
 464         break;
 465       } else if (begin >= abegin && begin < aend) {
 466         for (n = c->abort.num - 1; n >= 0; n--) {
 467           if (begin + c->abort.string[n].len > c->bufend)
 468             break;
 469           if (!strncmp(begin, c->abort.string[n].data,
 470                        c->abort.string[n].len)) {
 471             if (memchr(begin + c->abort.string[n].len - 1, '\n',
 472                 c->bufend - begin - c->abort.string[n].len + 1) == NULL) {
 473               /* force it into the log */
 474               end = c->bufend;
 475               c->bufend = begin + c->abort.string[n].len;
 476               chat_UpdateLog(c, -1);
 477               c->bufend = end;
 478             }
 479             c->bufstart = begin + c->abort.string[n].len;
 480             c->state = CHAT_FAILED;
 481             return;
 482           }
 483         }
 484       }
 485   }
 486 }
 487
 488 static int
 489 chat_Write(struct fdescriptor *d, struct bundle *bundle __unused,
 490            const fd_set *fdset __unused)
 491 {
 492   struct chat *c = descriptor2chat(d);
 493   int result = 0;
 494
 495   if (c->state == CHAT_SEND) {
 496     int wrote;
 497
 498     if (strstr(c->argv[c->arg], "\\P"))            /* Don't log the password */
 499       log_Printf(LogCHAT, "Send: %s\n", c->argv[c->arg]);
 500     else {
 501       int sz;
 502
 503       sz = c->arglen - 1;
 504       while (sz >= 0 && c->argptr[sz] == '\n')
 505         sz--;
 506       log_Printf(LogCHAT, "Send: %.*s\n", sz + 1, c->argptr);
 507     }
 508
 509     if (physical_IsSync(c->physical)) {
 510       /*
 511        * XXX: Fix me
 512        * This data should be stuffed down through the link layers
 513        */
 514       /* There's always room for the HDLC header */
 515       c->argptr -= 2;
 516       c->arglen += 2;
 517       memcpy(c->argptr, "\377\003", 2); /* Prepend HDLC header */
 518     }
 519
 520     wrote = physical_Write(c->physical, c->argptr, c->arglen);
 521     result = wrote > 0 ? 1 : 0;
 522     if (wrote == -1) {
 523       if (errno != EINTR) {
 524         log_Printf(LogWARN, "chat_Write: %s\n", strerror(errno));
 525         result = -1;
 526       }
 527       if (physical_IsSync(c->physical)) {
 528         c->argptr += 2;
 529         c->arglen -= 2;
 530       }
 531     } else if (wrote < 2 && physical_IsSync(c->physical)) {
 532       /* Oops - didn't even write our HDLC header ! */
 533       c->argptr += 2;
 534       c->arglen -= 2;
 535     } else {
 536       c->argptr += wrote;
 537       c->arglen -= wrote;
 538     }
 539   }
 540
 541   return result;
 542 }
 543
 544 void
 545 chat_Init(struct chat *c, struct physical *p)
 546 {
 547   c->desc.type = CHAT_DESCRIPTOR;
 548   c->desc.UpdateSet = chat_UpdateSet;
 549   c->desc.IsSet = chat_IsSet;
 550   c->desc.Read = chat_Read;
 551   c->desc.Write = chat_Write;
 552   c->physical = p;
 553   *c->script = '\0';
 554   c->argc = 0;
 555   c->arg = -1;
 556   c->argptr = NULL;
 557   c->nargptr = NULL;
 558   c->bufstart = c->bufend = c->buf;
 559
 560   memset(&c->pause, '\0', sizeof c->pause);
 561   memset(&c->timeout, '\0', sizeof c->timeout);
 562 }
 563
 564 int
 565 chat_Setup(struct chat *c, const char *data, const char *phone)
 566 {
 567   c->state = CHAT_EXPECT;
 568
 569   if (data == NULL) {
 570     *c->script = '\0';
 571     c->argc = 0;
 572   } else {
 573     strncpy(c->script, data, sizeof c->script - 1);
 574     c->script[sizeof c->script - 1] = '\0';
 575     c->argc = MakeArgs(c->script, c->argv, VECSIZE(c->argv), PARSE_NOHASH);
 576   }
 577
 578   c->arg = -1;
 579   c->argptr = NULL;
 580   c->nargptr = NULL;
 581
 582   c->TimeoutSec = 30;
 583   c->TimedOut = 0;
 584   c->phone = phone;
 585   c->abort.num = 0;
 586
 587   timer_Stop(&c->pause);
 588   timer_Stop(&c->timeout);
 589
 590   return c->argc >= 0;
 591 }
 592
 593 void
 594 chat_Finish(struct chat *c)
 595 {
 596   timer_Stop(&c->pause);
 597   timer_Stop(&c->timeout);
 598   while (c->abort.num)
 599     free(c->abort.string[--c->abort.num].data);
 600   c->abort.num = 0;
 601 }
 602
 603 void
 604 chat_Destroy(struct chat *c)
 605 {
 606   chat_Finish(c);
 607 }
 608
 609 /*
 610  *  \c  don't add a cr
 611  *  \d  Sleep a little (delay 2 seconds
 612  *  \n  Line feed character
 613  *  \P  Auth Key password
 614  *  \p  pause 0.25 sec
 615  *  \r  Carrige return character
 616  *  \s  Space character
 617  *  \T  Telephone number(s) (defined via `set phone')
 618  *  \t  Tab character
 619  *  \U  Auth User
 620  */
 621 static char *
 622 ExpandString(struct chat *c, const char *str, char *result, int reslen, int cr)
 623 {
 624   int len;
 625
 626   result[--reslen] = '\0';
 627   while (*str && reslen > 0) {
 628     switch (*str) {
 629     case '\\':
 630       str++;
 631       switch (*str) {
 632       case 'c':
 633         cr = 0;
 634         break;
 635       case 'd':         /* Delay 2 seconds */
 636         chat_Pause(c, 2 * SECTICKS);
 637         break;
 638       case 'p':
 639         chat_Pause(c, SECTICKS / 4);
 640         break;          /* Delay 0.25 seconds */
 641       case 'n':
 642         *result++ = '\n';
 643         reslen--;
 644         break;
 645       case 'r':
 646         *result++ = '\r';
 647         reslen--;
 648         break;
 649       case 's':
 650         *result++ = ' ';
 651         reslen--;
 652         break;
 653       case 't':
 654         *result++ = '\t';
 655         reslen--;
 656         break;
 657       case 'P':
 658         strncpy(result, c->physical->dl->bundle->cfg.auth.key, reslen);
 659         len = strlen(result);
 660         reslen -= len;
 661         result += len;
 662         break;
 663       case 'T':
 664         if (c->phone) {
 665           strncpy(result, c->phone, reslen);
 666           len = strlen(result);
 667           reslen -= len;
 668           result += len;
 669         }
 670         break;
 671       case 'U':
 672         strncpy(result, c->physical->dl->bundle->cfg.auth.name, reslen);
 673         len = strlen(result);
 674         reslen -= len;
 675         result += len;
 676         break;
 677       default:
 678         reslen--;
 679         *result++ = *str;
 680         break;
 681       }
 682       if (*str)
 683         str++;
 684       break;
 685     case '^':
 686       str++;
 687       if (*str) {
 688         *result++ = *str++ & 0x1f;
 689         reslen--;
 690       }
 691       break;
 692     default:
 693       *result++ = *str++;
 694       reslen--;
 695       break;
 696     }
 697   }
 698   if (--reslen > 0) {
 699     if (cr)
 700       *result++ = '\r';
 701   }
 702   if (--reslen > 0)
 703     *result++ = '\0';
 704   return (result);
 705 }
 706
 707 static void
 708 ExecStr(struct physical *physical, char *command, char *out, int olen)
 709 {
 710   pid_t pid;
 711   int fids[2];
 712   char *argv[MAXARGS], *vector[MAXARGS], *startout, *endout;
 713   int stat, nb, argc, i;
 714
 715   log_Printf(LogCHAT, "Exec: %s\n", command);
 716   if ((argc = MakeArgs(command, vector, VECSIZE(vector),
 717                        PARSE_REDUCE|PARSE_NOHASH)) <= 0) {
 718     if (argc < 0)
 719       log_Printf(LogWARN, "Syntax error in exec command\n");
 720     *out = '\0';
 721     return;
 722   }
 723
 724   if (pipe(fids) < 0) {
 725     log_Printf(LogCHAT, "Unable to create pipe in ExecStr: %s\n",
 726               strerror(errno));
 727     *out = '\0';
 728     return;
 729   }
 730   if ((pid = fork()) == 0) {
 731     command_Expand(argv, argc, (char const *const *)vector,
 732                    physical->dl->bundle, 0, getpid());
 733     close(fids[0]);
 734     timer_TermService();
 735     if (fids[1] == STDIN_FILENO)
 736       fids[1] = dup(fids[1]);
 737     dup2(physical->fd, STDIN_FILENO);
 738     dup2(fids[1], STDERR_FILENO);
 739     dup2(STDIN_FILENO, STDOUT_FILENO);
 740     close(3);
 741     if (open(_PATH_TTY, O_RDWR) != 3)
 742       open(_PATH_DEVNULL, O_RDWR);      /* Leave it closed if it fails... */
 743     for (i = getdtablesize(); i > 3; i--)
 744       fcntl(i, F_SETFD, 1);
 745 #ifndef NOSUID
 746     setuid(ID0realuid());
 747 #endif
 748     execvp(argv[0], argv);
 749     fprintf(stderr, "execvp: %s: %s\n", argv[0], strerror(errno));
 750     _exit(127);
 751   } else {
 752     char *name = strdup(vector[0]);
 753
 754     close(fids[1]);
 755     endout = out + olen - 1;
 756     startout = out;
 757     while (out < endout) {
 758       nb = read(fids[0], out, 1);
 759       if (nb <= 0)
 760         break;
 761       out++;
 762     }
 763     *out = '\0';
 764     close(fids[0]);
 765     close(fids[1]);
 766     waitpid(pid, &stat, WNOHANG);
 767     if (WIFSIGNALED(stat)) {
 768       log_Printf(LogWARN, "%s: signal %d\n", name, WTERMSIG(stat));
 769       free(name);
 770       *out = '\0';
 771       return;
 772     } else if (WIFEXITED(stat)) {
 773       switch (WEXITSTATUS(stat)) {
 774         case 0:
 775           free(name);
 776           break;
 777         case 127:
 778           log_Printf(LogWARN, "%s: %s\n", name, startout);
 779           free(name);
 780           *out = '\0';
 781           return;
 782           break;
 783         default:
 784           log_Printf(LogWARN, "%s: exit %d\n", name, WEXITSTATUS(stat));
 785           free(name);
 786           *out = '\0';
 787           return;
 788           break;
 789       }
 790     } else {
 791       log_Printf(LogWARN, "%s: Unexpected exit result\n", name);
 792       free(name);
 793       *out = '\0';
 794       return;
 795     }
 796   }
 797 }