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