usr.sbin/ppp/chat.c

   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
  85 static void ExecStr(struct physical *, char *, char *, int);
  86 static char *ExpandString(struct chat *, const char *, char *, int, int);
  87
  88 static void
  89 chat_PauseTimer(void *v)
  90 {
  91   struct chat *c = (struct chat *)v;
  92   timer_Stop(&c->pause);
  93   c->pause.load = 0;
  94 }
  95
  96 static void
  97 chat_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
 107 static void
 108 chat_TimeoutTimer(void *v)
 109 {
 110   struct chat *c = (struct chat *)v;
 111   timer_Stop(&c->timeout);
 112   c->TimedOut = 1;
 113 }
 114
 115 static void
 116 chat_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
 128 static char *
 129 chat_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
 141 static int
 142 chat_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
 331 static int
 332 chat_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
 338 static void
 339 chat_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
 380 static void
 381 chat_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
 495 static int
 496 chat_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
 551 void
 552 chat_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
 571 int
 572 chat_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
 600 void
 601 chat_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
 610 void
 611 chat_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  */
 628 static char *
 629 ExpandString(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
 714 static void
 715 ExecStr(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 }