prompt.c revision 81634
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: head/usr.sbin/ppp/prompt.c 81634 2001-08-14 16:05:52Z brian $ 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 83static void 84prompt_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 127static int 128prompt_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 158static int 159prompt_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 166static void 167prompt_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 177static void 178prompt_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 298static int 299prompt_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 306struct prompt * 307prompt_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 353void 354prompt_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 372void 373prompt_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 384void 385prompt_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 410void 411prompt_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 */ 443void 444prompt_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 */ 467void 468prompt_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 483void 484prompt_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 498pid_t 499prompt_pgrp(struct prompt *p) 500{ 501 return tcgetpgrp(p->fd_in); 502} 503 504int 505PasswdCommand(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 534static struct pppTimer bgtimer; 535 536static void 537prompt_TimedContinue(void *v) 538{ 539 prompt_Continue((struct prompt *)v); 540} 541 542void 543prompt_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 560void 561prompt_Suspend(struct prompt *p) 562{ 563 if (getpgrp() == prompt_pgrp(p)) { 564 prompt_TtyOldMode(p); 565 log_DeactivatePrompt(p); 566 } 567} 568