xref: /freebsd/usr.sbin/ppp/prompt.c (revision 5521ff5a4d1929056e7ffc982fac3341ca54df7c) 
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/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 
78 static void
79 prompt_Display(struct prompt *p)
80 {
81   /* XXX: See Index2Nam() - should we only figure this out once ? */
82   static char shostname[MAXHOSTNAMELEN];
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 
122 static int
123 prompt_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 
153 static int
154 prompt_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 
161 static void
162 prompt_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 
172 static void
173 prompt_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 
293 static int
294 prompt_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 
301 struct prompt *
302 prompt_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 
348 void
349 prompt_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 
367 void
368 prompt_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 
379 void
380 prompt_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 
405 void
406 prompt_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  */
438 void
439 prompt_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  */
462 void
463 prompt_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 
478 void
479 prompt_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 
493 pid_t
494 prompt_pgrp(struct prompt *p)
495 {
496   return tcgetpgrp(p->fd_in);
497 }
498 
499 int
500 PasswdCommand(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 
529 static struct pppTimer bgtimer;
530 
531 static void
532 prompt_TimedContinue(void *v)
533 {
534   prompt_Continue((struct prompt *)v);
535 }
536 
537 void
538 prompt_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 
555 void
556 prompt_Suspend(struct prompt *p)
557 {
558   if (getpgrp() == prompt_pgrp(p)) {
559     prompt_TtyOldMode(p);
560     log_DeactivatePrompt(p);
561   }
562 }
563