usr.sbin/ppp/prompt.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$
  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 <stdarg.h>
  38 #include <stdio.h>
  39 #include <stdlib.h>
  40 #include <string.h>
  41 #include <sys/fcntl.h>
  42 #include <termios.h>
  43 #include <unistd.h>
  44
  45 #include "layer.h"
  46 #include "defs.h"
  47 #include "timer.h"
  48 #include "command.h"
  49 #include "log.h"
  50 #include "descriptor.h"
  51 #include "prompt.h"
  52 #include "fsm.h"
  53 #include "auth.h"
  54 #include "iplist.h"
  55 #include "throughput.h"
  56 #include "slcompress.h"
  57 #include "mbuf.h"
  58 #include "lqr.h"
  59 #include "hdlc.h"
  60 #include "lcp.h"
  61 #include "ncpaddr.h"
  62 #include "ip.h"
  63 #include "ipcp.h"
  64 #include "filter.h"
  65 #include "async.h"
  66 #include "ccp.h"
  67 #include "link.h"
  68 #include "physical.h"
  69 #include "mp.h"
  70 #ifndef NORADIUS
  71 #include "radius.h"
  72 #endif
  73 #include "ipv6cp.h"
  74 #include "ncp.h"
  75 #include "bundle.h"
  76 #include "chat.h"
  77 #include "chap.h"
  78 #include "cbcp.h"
  79 #include "datalink.h"
  80 #include "server.h"
  81 #include "main.h"
  82
  83 static void
  84 prompt_Display(struct prompt *p)
  85 {
  86   /* XXX: See Index2Nam() - should we only figure this out once ? */
  87   static char shostname[MAXHOSTNAMELEN];
  88   const char *pconnect, *pauth;
  89
  90   if (p->TermMode || !p->needprompt)
  91     return;
  92
  93   p->needprompt = 0;
  94
  95   if (p->nonewline)
  96     p->nonewline = 0;
  97   else
  98     fprintf(p->Term, "\n");
  99
 100   if (p->auth == LOCAL_AUTH)
 101     pauth = " ON ";
 102   else
 103     pauth = " on ";
 104
 105   if (p->bundle->ncp.ipcp.fsm.state == ST_OPENED)
 106     pconnect = "PPP";
 107   else if (bundle_Phase(p->bundle) == PHASE_NETWORK)
 108     pconnect = "PPp";
 109   else if (bundle_Phase(p->bundle) == PHASE_AUTHENTICATE)
 110     pconnect = "Ppp";
 111   else
 112     pconnect = "ppp";
 113
 114   if (*shostname == '\0') {
 115     char *dot;
 116
 117     if (gethostname(shostname, sizeof shostname) || *shostname == '\0')
 118       strcpy(shostname, "localhost");
 119     else if ((dot = strchr(shostname, '.')))
 120       *dot = '\0';
 121   }
 122
 123   fprintf(p->Term, "%s%s%s> ", pconnect, pauth, shostname);
 124   fflush(p->Term);
 125 }
 126
 127 static int
 128 prompt_UpdateSet(struct fdescriptor *d, fd_set *r, fd_set *w, fd_set *e, int *n)
 129 {
 130   struct prompt *p = descriptor2prompt(d);
 131   int sets;
 132
 133   sets = 0;
 134
 135   if (!p->active)
 136     return sets;
 137
 138   if (p->fd_in >= 0) {
 139     if (r) {
 140       FD_SET(p->fd_in, r);
 141       log_Printf(LogTIMER, "prompt %s: fdset(r) %d\n", p->src.from, p->fd_in);
 142       sets++;
 143     }
 144     if (e) {
 145       FD_SET(p->fd_in, e);
 146       log_Printf(LogTIMER, "prompt %s: fdset(e) %d\n", p->src.from, p->fd_in);
 147       sets++;
 148     }
 149     if (sets && *n < p->fd_in + 1)
 150       *n = p->fd_in + 1;
 151   }
 152
 153   prompt_Display(p);
 154
 155   return sets;
 156 }
 157
 158 static int
 159 prompt_IsSet(struct fdescriptor *d, const fd_set *fdset)
 160 {
 161   struct prompt *p = descriptor2prompt(d);
 162   return p->fd_in >= 0 && FD_ISSET(p->fd_in, fdset);
 163 }
 164
 165
 166 static void
 167 prompt_ShowHelp(struct prompt *p)
 168 {
 169   prompt_Printf(p, "The following commands are available:\n");
 170   prompt_Printf(p, " ~p\tEnter Packet mode\n");
 171   prompt_Printf(p, " ~t\tShow timers\n");
 172   prompt_Printf(p, " ~m\tShow memory map\n");
 173   prompt_Printf(p, " ~.\tTerminate program\n");
 174   prompt_Printf(p, " ~?\tThis help\n");
 175 }
 176
 177 static void
 178 prompt_Read(struct fdescriptor *d, struct bundle *bundle, const fd_set *fdset)
 179 {
 180   struct prompt *p = descriptor2prompt(d);
 181   struct prompt *op;
 182   int n;
 183   char ch;
 184   char linebuff[LINE_LEN];
 185
 186   if (p->TermMode == NULL) {
 187     n = read(p->fd_in, linebuff, sizeof linebuff - 1);
 188     if (n > 0) {
 189       if (linebuff[n-1] == '\n')
 190         linebuff[--n] = '\0';
 191       else
 192         linebuff[n] = '\0';
 193       p->nonewline = 1;         /* Maybe command_Decode does a prompt */
 194       prompt_Required(p);
 195       if (n) {
 196         if ((op = log_PromptContext) == NULL)
 197           log_PromptContext = p;
 198         if (!command_Decode(bundle, linebuff, n, p, p->src.from))
 199           prompt_Printf(p, "Syntax error\n");
 200         log_PromptContext = op;
 201       }
 202     } else if (n <= 0) {
 203       log_Printf(LogPHASE, "%s: Client connection closed.\n", p->src.from);
 204       if (!p->owner)
 205         Cleanup(EX_NORMAL);
 206       prompt_Destroy(p, 0);
 207     }
 208     return;
 209   }
 210
 211   switch (p->TermMode->state) {
 212     case DATALINK_CLOSED:
 213       prompt_Printf(p, "Link lost, terminal mode.\n");
 214       prompt_TtyCommandMode(p);
 215       p->nonewline = 0;
 216       prompt_Required(p);
 217       return;
 218
 219     case DATALINK_READY:
 220       break;
 221
 222     case DATALINK_OPEN:
 223       prompt_Printf(p, "\nPacket mode detected.\n");
 224       prompt_TtyCommandMode(p);
 225       p->nonewline = 0;
 226       /* We'll get a prompt because of our status change */
 227       /* Fall through */
 228
 229     default:
 230       /* Wait 'till we're in a state we care about */
 231       return;
 232   }
 233
 234   /*
 235    * We are in terminal mode, decode special sequences
 236    */
 237   n = read(p->fd_in, &ch, 1);
 238   log_Printf(LogDEBUG, "Got %d bytes (reading from the terminal)\n", n);
 239
 240   if (n > 0) {
 241     switch (p->readtilde) {
 242     case 0:
 243       if (ch == '~')
 244         p->readtilde = 1;
 245       else
 246         if (physical_Write(p->TermMode->physical, &ch, n) < 0) {
 247           log_Printf(LogWARN, "error writing to modem: %s\n", strerror(errno));
 248           prompt_TtyCommandMode(p);
 249         }
 250       break;
 251     case 1:
 252       switch (ch) {
 253       case '?':
 254         prompt_ShowHelp(p);
 255         break;
 256       case 'p':
 257         datalink_Up(p->TermMode, 0, 1);
 258         prompt_Printf(p, "\nPacket mode.\n");
 259         prompt_TtyCommandMode(p);
 260         break;
 261       case '.':
 262         prompt_TtyCommandMode(p);
 263         p->nonewline = 0;
 264         prompt_Required(p);
 265         break;
 266       case 't':
 267         timer_Show(0, p);
 268         break;
 269       case 'm':
 270         {
 271           struct cmdargs arg;
 272
 273           arg.cmdtab = NULL;
 274           arg.cmd = NULL;
 275           arg.argc = 0;
 276           arg.argn = 0;
 277           arg.argv = NULL;
 278           arg.bundle = bundle;
 279           arg.cx = p->TermMode;
 280           arg.prompt = p;
 281
 282           mbuf_Show(&arg);
 283         }
 284         break;
 285       default:
 286         if (physical_Write(p->TermMode->physical, &ch, n) < 0) {
 287           log_Printf(LogWARN, "error writing to modem: %s\n", strerror(errno));
 288           prompt_TtyCommandMode(p);
 289         }
 290         break;
 291       }
 292       p->readtilde = 0;
 293       break;
 294     }
 295   }
 296 }
 297
 298 static int
 299 prompt_Write(struct fdescriptor *d, struct bundle *bundle, const fd_set *fdset)
 300 {
 301   /* We never want to write here ! */
 302   log_Printf(LogALERT, "prompt_Write: Internal error: Bad call !\n");
 303   return 0;
 304 }
 305
 306 struct prompt *
 307 prompt_Create(struct server *s, struct bundle *bundle, int fd)
 308 {
 309   struct prompt *p = (struct prompt *)malloc(sizeof(struct prompt));
 310
 311   if (p != NULL) {
 312     p->desc.type = PROMPT_DESCRIPTOR;
 313     p->desc.UpdateSet = prompt_UpdateSet;
 314     p->desc.IsSet = prompt_IsSet;
 315     p->desc.Read = prompt_Read;
 316     p->desc.Write = prompt_Write;
 317
 318     if (fd == PROMPT_STD) {
 319       char *tty = ttyname(STDIN_FILENO);
 320
 321       if (!tty) {
 322         free(p);
 323         return NULL;
 324       }
 325       p->fd_in = STDIN_FILENO;
 326       p->fd_out = STDOUT_FILENO;
 327       p->Term = stdout;
 328       p->owner = NULL;
 329       p->auth = LOCAL_AUTH;
 330       p->src.type = "Controller";
 331       strncpy(p->src.from, tty, sizeof p->src.from - 1);
 332       p->src.from[sizeof p->src.from - 1] = '\0';
 333       tcgetattr(p->fd_in, &p->oldtio);  /* Save original tty mode */
 334     } else {
 335       p->fd_in = p->fd_out = fd;
 336       p->Term = fdopen(fd, "a+");
 337       p->owner = s;
 338       p->auth = *s->cfg.passwd ? LOCAL_NO_AUTH : LOCAL_AUTH;
 339       p->src.type = "unknown";
 340       *p->src.from = '\0';
 341     }
 342     p->TermMode = NULL;
 343     p->nonewline = 1;
 344     p->needprompt = 1;
 345     p->readtilde = 0;
 346     p->bundle = bundle;
 347     log_RegisterPrompt(p);
 348   }
 349
 350   return p;
 351 }
 352
 353 void
 354 prompt_Destroy(struct prompt *p, int verbose)
 355 {
 356   if (p) {
 357     if (p->Term != stdout) {
 358       fclose(p->Term);
 359       close(p->fd_in);
 360       if (p->fd_out != p->fd_in)
 361         close(p->fd_out);
 362       if (verbose)
 363         log_Printf(LogPHASE, "%s: Client connection dropped.\n", p->src.from);
 364     } else
 365       prompt_TtyOldMode(p);
 366
 367     log_UnRegisterPrompt(p);
 368     free(p);
 369   }
 370 }
 371
 372 void
 373 prompt_Printf(struct prompt *p, const char *fmt,...)
 374 {
 375   if (p && p->active) {
 376     va_list ap;
 377
 378     va_start(ap, fmt);
 379     prompt_vPrintf(p, fmt, ap);
 380     va_end(ap);
 381   }
 382 }
 383
 384 void
 385 prompt_vPrintf(struct prompt *p, const char *fmt, va_list ap)
 386 {
 387   if (p && p->active) {
 388     char nfmt[LINE_LEN];
 389     const char *pfmt;
 390
 391     if (p->TermMode) {
 392       /* Stuff '\r' in front of '\n' 'cos we're in raw mode */
 393       int len = strlen(fmt);
 394
 395       if (len && len < sizeof nfmt - 1 && fmt[len-1] == '\n' &&
 396           (len == 1 || fmt[len-2] != '\r')) {
 397         strcpy(nfmt, fmt);
 398         strcpy(nfmt + len - 1, "\r\n");
 399         pfmt = nfmt;
 400       } else
 401         pfmt = fmt;
 402     } else
 403       pfmt = fmt;
 404     vfprintf(p->Term, pfmt, ap);
 405     fflush(p->Term);
 406     p->nonewline = 1;
 407   }
 408 }
 409
 410 void
 411 prompt_TtyInit(struct prompt *p)
 412 {
 413   int stat, fd = p ? p->fd_in : STDIN_FILENO;
 414   struct termios newtio;
 415
 416   stat = fcntl(fd, F_GETFL, 0);
 417   if (stat > 0) {
 418     stat |= O_NONBLOCK;
 419     fcntl(fd, F_SETFL, stat);
 420   }
 421
 422   if (p)
 423     newtio = p->oldtio;
 424   else
 425     tcgetattr(fd, &newtio);
 426
 427   newtio.c_lflag &= ~(ECHO | ISIG | ICANON);
 428   newtio.c_iflag = 0;
 429   newtio.c_oflag &= ~OPOST;
 430   if (!p)
 431     newtio.c_cc[VINTR] = _POSIX_VDISABLE;
 432   newtio.c_cc[VMIN] = 1;
 433   newtio.c_cc[VTIME] = 0;
 434   newtio.c_cflag |= CS8;
 435   tcsetattr(fd, TCSANOW, &newtio);
 436   if (p)
 437     p->comtio = newtio;
 438 }
 439
 440 /*
 441  *  Set tty into command mode. We allow canonical input and echo processing.
 442  */
 443 void
 444 prompt_TtyCommandMode(struct prompt *p)
 445 {
 446   struct termios newtio;
 447   int stat;
 448
 449   tcgetattr(p->fd_in, &newtio);
 450   newtio.c_lflag |= (ECHO | ISIG | ICANON);
 451   newtio.c_iflag = p->oldtio.c_iflag;
 452   newtio.c_oflag |= OPOST;
 453   tcsetattr(p->fd_in, TCSADRAIN, &newtio);
 454
 455   stat = fcntl(p->fd_in, F_GETFL, 0);
 456   if (stat > 0) {
 457     stat |= O_NONBLOCK;
 458     fcntl(p->fd_in, F_SETFL, stat);
 459   }
 460
 461   p->TermMode = NULL;
 462 }
 463
 464 /*
 465  * Set tty into terminal mode which is used while we invoke term command.
 466  */
 467 void
 468 prompt_TtyTermMode(struct prompt *p, struct datalink *dl)
 469 {
 470   int stat;
 471
 472   if (p->Term == stdout)
 473     tcsetattr(p->fd_in, TCSADRAIN, &p->comtio);
 474
 475   stat = fcntl(p->fd_in, F_GETFL, 0);
 476   if (stat > 0) {
 477     stat &= ~O_NONBLOCK;
 478     fcntl(p->fd_in, F_SETFL, stat);
 479   }
 480   p->TermMode = dl;
 481 }
 482
 483 void
 484 prompt_TtyOldMode(struct prompt *p)
 485 {
 486   int stat;
 487
 488   stat = fcntl(p->fd_in, F_GETFL, 0);
 489   if (stat > 0) {
 490     stat &= ~O_NONBLOCK;
 491     fcntl(p->fd_in, F_SETFL, stat);
 492   }
 493
 494   if (p->Term == stdout)
 495     tcsetattr(p->fd_in, TCSADRAIN, &p->oldtio);
 496 }
 497
 498 pid_t
 499 prompt_pgrp(struct prompt *p)
 500 {
 501   return tcgetpgrp(p->fd_in);
 502 }
 503
 504 int
 505 PasswdCommand(struct cmdargs const *arg)
 506 {
 507   const char *pass;
 508
 509   if (!arg->prompt) {
 510     log_Printf(LogWARN, "passwd: Cannot specify without a prompt\n");
 511     return 0;
 512   }
 513
 514   if (arg->prompt->owner == NULL) {
 515     log_Printf(LogWARN, "passwd: Not required\n");
 516     return 0;
 517   }
 518
 519   if (arg->argc == arg->argn)
 520     pass = "";
 521   else if (arg->argc > arg->argn+1)
 522     return -1;
 523   else
 524     pass = arg->argv[arg->argn];
 525
 526   if (!strcmp(arg->prompt->owner->cfg.passwd, pass))
 527     arg->prompt->auth = LOCAL_AUTH;
 528   else
 529     arg->prompt->auth = LOCAL_NO_AUTH;
 530
 531   return 0;
 532 }
 533
 534 static struct pppTimer bgtimer;
 535
 536 static void
 537 prompt_TimedContinue(void *v)
 538 {
 539   prompt_Continue((struct prompt *)v);
 540 }
 541
 542 void
 543 prompt_Continue(struct prompt *p)
 544 {
 545   timer_Stop(&bgtimer);
 546   if (getpgrp() == prompt_pgrp(p)) {
 547     prompt_TtyCommandMode(p);
 548     p->nonewline = 1;
 549     prompt_Required(p);
 550     log_ActivatePrompt(p);
 551   } else if (!p->owner) {
 552     bgtimer.func = prompt_TimedContinue;
 553     bgtimer.name = "prompt bg";
 554     bgtimer.load = SECTICKS;
 555     bgtimer.arg = p;
 556     timer_Start(&bgtimer);
 557   }
 558 }
 559
 560 void
 561 prompt_Suspend(struct prompt *p)
 562 {
 563   if (getpgrp() == prompt_pgrp(p)) {
 564     prompt_TtyOldMode(p);
 565     log_DeactivatePrompt(p);
 566   }
 567 }