6e7378be8d7e21ec0d7ed23e17630ec27b6d5e22
[ppp.git] / pppd / main.c
1 /*
2  * main.c - Point-to-Point Protocol main module
3  *
4  * Copyright (c) 1984-2000 Carnegie Mellon University. All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  *
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  *
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in
15  *    the documentation and/or other materials provided with the
16  *    distribution.
17  *
18  * 3. The name "Carnegie Mellon University" must not be used to
19  *    endorse or promote products derived from this software without
20  *    prior written permission. For permission or any legal
21  *    details, please contact
22  *      Office of Technology Transfer
23  *      Carnegie Mellon University
24  *      5000 Forbes Avenue
25  *      Pittsburgh, PA  15213-3890
26  *      (412) 268-4387, fax: (412) 268-7395
27  *      tech-transfer@andrew.cmu.edu
28  *
29  * 4. Redistributions of any form whatsoever must retain the following
30  *    acknowledgment:
31  *    "This product includes software developed by Computing Services
32  *     at Carnegie Mellon University (http://www.cmu.edu/computing/)."
33  *
34  * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO
35  * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
36  * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE
37  * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
38  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
39  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
40  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
41  *
42  * Copyright (c) 1999-2004 Paul Mackerras. All rights reserved.
43  *
44  * Redistribution and use in source and binary forms, with or without
45  * modification, are permitted provided that the following conditions
46  * are met:
47  *
48  * 1. Redistributions of source code must retain the above copyright
49  *    notice, this list of conditions and the following disclaimer.
50  *
51  * 2. The name(s) of the authors of this software must not be used to
52  *    endorse or promote products derived from this software without
53  *    prior written permission.
54  *
55  * 3. Redistributions of any form whatsoever must retain the following
56  *    acknowledgment:
57  *    "This product includes software developed by Paul Mackerras
58  *     <paulus@samba.org>".
59  *
60  * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO
61  * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
62  * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
63  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
64  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
65  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
66  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
67  */
68
69 #define RCSID   "$Id: main.c,v 1.156 2008/06/23 11:47:18 paulus Exp $"
70
71 #include <stdio.h>
72 #include <ctype.h>
73 #include <stdlib.h>
74 #include <string.h>
75 #include <unistd.h>
76 #include <signal.h>
77 #include <errno.h>
78 #include <fcntl.h>
79 #include <syslog.h>
80 #include <netdb.h>
81 #include <utmp.h>
82 #include <pwd.h>
83 #include <setjmp.h>
84 #include <sys/param.h>
85 #include <sys/types.h>
86 #include <sys/wait.h>
87 #include <sys/time.h>
88 #include <sys/resource.h>
89 #include <sys/stat.h>
90 #include <sys/socket.h>
91 #include <netinet/in.h>
92 #include <arpa/inet.h>
93
94 #include "pppd.h"
95 #include "magic.h"
96 #include "fsm.h"
97 #include "lcp.h"
98 #include "ipcp.h"
99 #ifdef INET6
100 #include "ipv6cp.h"
101 #endif
102 #include "upap.h"
103 #include "chap-new.h"
104 #include "eap.h"
105 #include "ccp.h"
106 #include "ecp.h"
107 #include "pathnames.h"
108
109 #ifdef USE_TDB
110 #include "tdb.h"
111 #endif
112
113 #ifdef CBCP_SUPPORT
114 #include "cbcp.h"
115 #endif
116
117 #ifdef IPX_CHANGE
118 #include "ipxcp.h"
119 #endif /* IPX_CHANGE */
120 #ifdef AT_CHANGE
121 #include "atcp.h"
122 #endif
123
124 static const char rcsid[] = RCSID;
125
126 /* interface vars */
127 char ifname[32];                /* Interface name */
128 int ifunit;                     /* Interface unit number */
129
130 struct channel *the_channel;
131
132 char *progname;                 /* Name of this program */
133 char hostname[MAXNAMELEN];      /* Our hostname */
134 static char pidfilename[MAXPATHLEN];    /* name of pid file */
135 static char linkpidfile[MAXPATHLEN];    /* name of linkname pid file */
136 char ppp_devnam[MAXPATHLEN];    /* name of PPP tty (maybe ttypx) */
137 uid_t uid;                      /* Our real user-id */
138 struct notifier *pidchange = NULL;
139 struct notifier *phasechange = NULL;
140 struct notifier *exitnotify = NULL;
141 struct notifier *sigreceived = NULL;
142 struct notifier *fork_notifier = NULL;
143
144 int hungup;                     /* terminal has been hung up */
145 int privileged;                 /* we're running as real uid root */
146 int need_holdoff;               /* need holdoff period before restarting */
147 int detached;                   /* have detached from terminal */
148 volatile int status;            /* exit status for pppd */
149 int unsuccess;                  /* # unsuccessful connection attempts */
150 int do_callback;                /* != 0 if we should do callback next */
151 int doing_callback;             /* != 0 if we are doing callback */
152 int ppp_session_number;         /* Session number, for channels with such a
153                                    concept (eg PPPoE) */
154 int childwait_done;             /* have timed out waiting for children */
155
156 #ifdef USE_TDB
157 TDB_CONTEXT *pppdb;             /* database for storing status etc. */
158 #endif
159
160 char db_key[32];
161
162 int (*holdoff_hook) __P((void)) = NULL;
163 int (*new_phase_hook) __P((int)) = NULL;
164 void (*snoop_recv_hook) __P((unsigned char *p, int len)) = NULL;
165 void (*snoop_send_hook) __P((unsigned char *p, int len)) = NULL;
166
167 static int conn_running;        /* we have a [dis]connector running */
168 static int fd_loop;             /* fd for getting demand-dial packets */
169
170 int fd_devnull;                 /* fd for /dev/null */
171 int devfd = -1;                 /* fd of underlying device */
172 int fd_ppp = -1;                /* fd for talking PPP */
173 int phase;                      /* where the link is at */
174 int kill_link;
175 int asked_to_quit;
176 int open_ccp_flag;
177 int listen_time;
178 int got_sigusr2;
179 int got_sigterm;
180 int got_sighup;
181
182 static sigset_t signals_handled;
183 static int waiting;
184 static sigjmp_buf sigjmp;
185
186 char **script_env;              /* Env. variable values for scripts */
187 int s_env_nalloc;               /* # words avail at script_env */
188
189 u_char outpacket_buf[PPP_MRU+PPP_HDRLEN]; /* buffer for outgoing packet */
190 u_char inpacket_buf[PPP_MRU+PPP_HDRLEN]; /* buffer for incoming packet */
191
192 static int n_children;          /* # child processes still running */
193 static int got_sigchld;         /* set if we have received a SIGCHLD */
194
195 int privopen;                   /* don't lock, open device as root */
196
197 char *no_ppp_msg = "Sorry - this system lacks PPP kernel support\n";
198
199 GIDSET_TYPE groups[NGROUPS_MAX];/* groups the user is in */
200 int ngroups;                    /* How many groups valid in groups */
201
202 static struct timeval start_time;       /* Time when link was started. */
203
204 static struct pppd_stats old_link_stats;
205 struct pppd_stats link_stats;
206 unsigned link_connect_time;
207 int link_stats_valid;
208
209 int error_count;
210
211 bool bundle_eof;
212 bool bundle_terminating;
213
214 /*
215  * We maintain a list of child process pids and
216  * functions to call when they exit.
217  */
218 struct subprocess {
219     pid_t       pid;
220     char        *prog;
221     void        (*done) __P((void *));
222     void        *arg;
223     int         killable;
224     struct subprocess *next;
225 };
226
227 static struct subprocess *children;
228
229 /* Prototypes for procedures local to this file. */
230
231 static void setup_signals __P((void));
232 static void create_pidfile __P((int pid));
233 static void create_linkpidfile __P((int pid));
234 static void cleanup __P((void));
235 static void get_input __P((void));
236 static void calltimeout __P((void));
237 static struct timeval *timeleft __P((struct timeval *));
238 static void kill_my_pg __P((int));
239 static void hup __P((int));
240 static void term __P((int));
241 static void chld __P((int));
242 static void toggle_debug __P((int));
243 static void open_ccp __P((int));
244 static void bad_signal __P((int));
245 static void holdoff_end __P((void *));
246 static void forget_child __P((int pid, int status));
247 static int reap_kids __P((void));
248 static void childwait_end __P((void *));
249
250 #ifdef USE_TDB
251 static void update_db_entry __P((void));
252 static void add_db_key __P((const char *));
253 static void delete_db_key __P((const char *));
254 static void cleanup_db __P((void));
255 #endif
256
257 static void handle_events __P((void));
258 void print_link_stats __P((void));
259
260 extern  char    *ttyname __P((int));
261 extern  char    *getlogin __P((void));
262 int main __P((int, char *[]));
263
264 #ifdef ultrix
265 #undef  O_NONBLOCK
266 #define O_NONBLOCK      O_NDELAY
267 #endif
268
269 #ifdef ULTRIX
270 #define setlogmask(x)
271 #endif
272
273 /*
274  * PPP Data Link Layer "protocol" table.
275  * One entry per supported protocol.
276  * The last entry must be NULL.
277  */
278 struct protent *protocols[] = {
279     &lcp_protent,
280     &pap_protent,
281     &chap_protent,
282 #ifdef CBCP_SUPPORT
283     &cbcp_protent,
284 #endif
285     &ipcp_protent,
286 #ifdef INET6
287     &ipv6cp_protent,
288 #endif
289     &ccp_protent,
290     &ecp_protent,
291 #ifdef IPX_CHANGE
292     &ipxcp_protent,
293 #endif
294 #ifdef AT_CHANGE
295     &atcp_protent,
296 #endif
297     &eap_protent,
298     NULL
299 };
300
301 /*
302  * If PPP_DRV_NAME is not defined, use the default "ppp" as the device name.
303  */
304 #if !defined(PPP_DRV_NAME)
305 #define PPP_DRV_NAME    "ppp"
306 #endif /* !defined(PPP_DRV_NAME) */
307
308 int
309 main(argc, argv)
310     int argc;
311     char *argv[];
312 {
313     int i, t;
314     char *p;
315     struct passwd *pw;
316     struct protent *protp;
317     char numbuf[16];
318
319     link_stats_valid = 0;
320     new_phase(PHASE_INITIALIZE);
321
322     script_env = NULL;
323
324     /* Initialize syslog facilities */
325     reopen_log();
326
327     if (gethostname(hostname, MAXNAMELEN) < 0 ) {
328         option_error("Couldn't get hostname: %m");
329         exit(1);
330     }
331     hostname[MAXNAMELEN-1] = 0;
332
333     /* make sure we don't create world or group writable files. */
334     umask(umask(0777) | 022);
335
336     uid = getuid();
337     privileged = uid == 0;
338     slprintf(numbuf, sizeof(numbuf), "%d", uid);
339     script_setenv("ORIG_UID", numbuf, 0);
340
341     ngroups = getgroups(NGROUPS_MAX, groups);
342
343     /*
344      * Initialize magic number generator now so that protocols may
345      * use magic numbers in initialization.
346      */
347     magic_init();
348
349     /*
350      * Initialize each protocol.
351      */
352     for (i = 0; (protp = protocols[i]) != NULL; ++i)
353         (*protp->init)(0);
354
355     /*
356      * Initialize the default channel.
357      */
358     tty_init();
359
360     progname = *argv;
361
362     /*
363      * Parse, in order, the system options file, the user's options file,
364      * and the command line arguments.
365      */
366     if (!options_from_file(_PATH_SYSOPTIONS, !privileged, 0, 1)
367         || !options_from_user()
368         || !parse_args(argc-1, argv+1))
369         exit(EXIT_OPTION_ERROR);
370     devnam_fixed = 1;           /* can no longer change device name */
371
372     /*
373      * Work out the device name, if it hasn't already been specified,
374      * and parse the tty's options file.
375      */
376     if (the_channel->process_extra_options)
377         (*the_channel->process_extra_options)();
378
379     if (debug)
380         setlogmask(LOG_UPTO(LOG_DEBUG));
381
382     /*
383      * Check that we are running as root.
384      */
385     if (geteuid() != 0) {
386         option_error("must be root to run %s, since it is not setuid-root",
387                      argv[0]);
388         exit(EXIT_NOT_ROOT);
389     }
390
391     if (!ppp_available()) {
392         option_error("%s", no_ppp_msg);
393         exit(EXIT_NO_KERNEL_SUPPORT);
394     }
395
396     /*
397      * Check that the options given are valid and consistent.
398      */
399     check_options();
400     if (!sys_check_options())
401         exit(EXIT_OPTION_ERROR);
402     auth_check_options();
403 #ifdef HAVE_MULTILINK
404     mp_check_options();
405 #endif
406     for (i = 0; (protp = protocols[i]) != NULL; ++i)
407         if (protp->check_options != NULL)
408             (*protp->check_options)();
409     if (the_channel->check_options)
410         (*the_channel->check_options)();
411
412
413     if (dump_options || dryrun) {
414         init_pr_log(NULL, LOG_INFO);
415         print_options(pr_log, NULL);
416         end_pr_log();
417     }
418
419     if (dryrun)
420         die(0);
421
422     /* Make sure fds 0, 1, 2 are open to somewhere. */
423     fd_devnull = open(_PATH_DEVNULL, O_RDWR);
424     if (fd_devnull < 0)
425         fatal("Couldn't open %s: %m", _PATH_DEVNULL);
426     while (fd_devnull <= 2) {
427         i = dup(fd_devnull);
428         if (i < 0)
429             fatal("Critical shortage of file descriptors: dup failed: %m");
430         fd_devnull = i;
431     }
432
433     /*
434      * Initialize system-dependent stuff.
435      */
436     sys_init();
437
438 #ifdef USE_TDB
439     pppdb = tdb_open(_PATH_PPPDB, 0, 0, O_RDWR|O_CREAT, 0644);
440     if (pppdb != NULL) {
441         slprintf(db_key, sizeof(db_key), "pppd%d", getpid());
442         update_db_entry();
443     } else {
444         warn("Warning: couldn't open ppp database %s", _PATH_PPPDB);
445         if (multilink) {
446             warn("Warning: disabling multilink");
447             multilink = 0;
448         }
449     }
450 #endif
451
452     /*
453      * Detach ourselves from the terminal, if required,
454      * and identify who is running us.
455      */
456     if (!nodetach && !updetach)
457         detach();
458     p = getlogin();
459     if (p == NULL) {
460         pw = getpwuid(uid);
461         if (pw != NULL && pw->pw_name != NULL)
462             p = pw->pw_name;
463         else
464             p = "(unknown)";
465     }
466     syslog(LOG_NOTICE, "pppd %s started by %s, uid %d", VERSION, p, uid);
467     script_setenv("PPPLOGNAME", p, 0);
468
469     if (devnam[0])
470         script_setenv("DEVICE", devnam, 1);
471     slprintf(numbuf, sizeof(numbuf), "%d", getpid());
472     script_setenv("PPPD_PID", numbuf, 1);
473
474     setup_signals();
475
476     create_linkpidfile(getpid());
477
478     waiting = 0;
479
480     /*
481      * If we're doing dial-on-demand, set up the interface now.
482      */
483     if (demand) {
484         /*
485          * Open the loopback channel and set it up to be the ppp interface.
486          */
487         fd_loop = open_ppp_loopback();
488         set_ifunit(1);
489         /*
490          * Configure the interface and mark it up, etc.
491          */
492         demand_conf();
493     }
494
495     do_callback = 0;
496     for (;;) {
497
498         bundle_eof = 0;
499         bundle_terminating = 0;
500         listen_time = 0;
501         need_holdoff = 1;
502         devfd = -1;
503         status = EXIT_OK;
504         ++unsuccess;
505         doing_callback = do_callback;
506         do_callback = 0;
507
508         if (demand && !doing_callback) {
509             /*
510              * Don't do anything until we see some activity.
511              */
512             new_phase(PHASE_DORMANT);
513             demand_unblock();
514             add_fd(fd_loop);
515             for (;;) {
516                 handle_events();
517                 if (asked_to_quit)
518                     break;
519                 if (get_loop_output())
520                     break;
521             }
522             remove_fd(fd_loop);
523             if (asked_to_quit)
524                 break;
525
526             /*
527              * Now we want to bring up the link.
528              */
529             demand_block();
530             info("Starting link");
531         }
532
533         gettimeofday(&start_time, NULL);
534         script_unsetenv("CONNECT_TIME");
535         script_unsetenv("BYTES_SENT");
536         script_unsetenv("BYTES_RCVD");
537
538         lcp_open(0);            /* Start protocol */
539         start_link(0);
540         while (phase != PHASE_DEAD) {
541             handle_events();
542             get_input();
543             if (kill_link)
544                 lcp_close(0, "User request");
545             if (asked_to_quit) {
546                 bundle_terminating = 1;
547                 if (phase == PHASE_MASTER)
548                     mp_bundle_terminated();
549             }
550             if (open_ccp_flag) {
551                 if (phase == PHASE_NETWORK || phase == PHASE_RUNNING) {
552                     ccp_fsm[0].flags = OPT_RESTART; /* clears OPT_SILENT */
553                     (*ccp_protent.open)(0);
554                 }
555             }
556         }
557         /* restore FSMs to original state */
558         lcp_close(0, "");
559
560         if (!persist || asked_to_quit || (maxfail > 0 && unsuccess >= maxfail))
561             break;
562
563         if (demand)
564             demand_discard();
565         t = need_holdoff? holdoff: 0;
566         if (holdoff_hook)
567             t = (*holdoff_hook)();
568         if (t > 0) {
569             new_phase(PHASE_HOLDOFF);
570             TIMEOUT(holdoff_end, NULL, t);
571             do {
572                 handle_events();
573                 if (kill_link)
574                     new_phase(PHASE_DORMANT); /* allow signal to end holdoff */
575             } while (phase == PHASE_HOLDOFF);
576             if (!persist)
577                 break;
578         }
579     }
580
581     /* Wait for scripts to finish */
582     reap_kids();
583     if (n_children > 0) {
584         if (child_wait > 0)
585             TIMEOUT(childwait_end, NULL, child_wait);
586         if (debug) {
587             struct subprocess *chp;
588             dbglog("Waiting for %d child processes...", n_children);
589             for (chp = children; chp != NULL; chp = chp->next)
590                 dbglog("  script %s, pid %d", chp->prog, chp->pid);
591         }
592         while (n_children > 0 && !childwait_done) {
593             handle_events();
594             if (kill_link && !childwait_done)
595                 childwait_end(NULL);
596         }
597     }
598
599     die(status);
600     return 0;
601 }
602
603 /*
604  * handle_events - wait for something to happen and respond to it.
605  */
606 static void
607 handle_events()
608 {
609     struct timeval timo;
610
611     kill_link = open_ccp_flag = 0;
612     if (sigsetjmp(sigjmp, 1) == 0) {
613         sigprocmask(SIG_BLOCK, &signals_handled, NULL);
614         if (got_sighup || got_sigterm || got_sigusr2 || got_sigchld) {
615             sigprocmask(SIG_UNBLOCK, &signals_handled, NULL);
616         } else {
617             waiting = 1;
618             sigprocmask(SIG_UNBLOCK, &signals_handled, NULL);
619             wait_input(timeleft(&timo));
620         }
621     }
622     waiting = 0;
623     calltimeout();
624     if (got_sighup) {
625         info("Hangup (SIGHUP)");
626         kill_link = 1;
627         got_sighup = 0;
628         if (status != EXIT_HANGUP)
629             status = EXIT_USER_REQUEST;
630     }
631     if (got_sigterm) {
632         info("Terminating on signal %d", got_sigterm);
633         kill_link = 1;
634         asked_to_quit = 1;
635         persist = 0;
636         status = EXIT_USER_REQUEST;
637         got_sigterm = 0;
638     }
639     if (got_sigchld) {
640         got_sigchld = 0;
641         reap_kids();    /* Don't leave dead kids lying around */
642     }
643     if (got_sigusr2) {
644         open_ccp_flag = 1;
645         got_sigusr2 = 0;
646     }
647 }
648
649 /*
650  * setup_signals - initialize signal handling.
651  */
652 static void
653 setup_signals()
654 {
655     struct sigaction sa;
656
657     /*
658      * Compute mask of all interesting signals and install signal handlers
659      * for each.  Only one signal handler may be active at a time.  Therefore,
660      * all other signals should be masked when any handler is executing.
661      */
662     sigemptyset(&signals_handled);
663     sigaddset(&signals_handled, SIGHUP);
664     sigaddset(&signals_handled, SIGINT);
665     sigaddset(&signals_handled, SIGTERM);
666     sigaddset(&signals_handled, SIGCHLD);
667     sigaddset(&signals_handled, SIGUSR2);
668
669 #define SIGNAL(s, handler)      do { \
670         sa.sa_handler = handler; \
671         if (sigaction(s, &sa, NULL) < 0) \
672             fatal("Couldn't establish signal handler (%d): %m", s); \
673     } while (0)
674
675     sa.sa_mask = signals_handled;
676     sa.sa_flags = 0;
677     SIGNAL(SIGHUP, hup);                /* Hangup */
678     SIGNAL(SIGINT, term);               /* Interrupt */
679     SIGNAL(SIGTERM, term);              /* Terminate */
680     SIGNAL(SIGCHLD, chld);
681
682     SIGNAL(SIGUSR1, toggle_debug);      /* Toggle debug flag */
683     SIGNAL(SIGUSR2, open_ccp);          /* Reopen CCP */
684
685     /*
686      * Install a handler for other signals which would otherwise
687      * cause pppd to exit without cleaning up.
688      */
689     SIGNAL(SIGABRT, bad_signal);
690     SIGNAL(SIGALRM, bad_signal);
691     SIGNAL(SIGFPE, bad_signal);
692     SIGNAL(SIGILL, bad_signal);
693     SIGNAL(SIGPIPE, bad_signal);
694     SIGNAL(SIGQUIT, bad_signal);
695     SIGNAL(SIGSEGV, bad_signal);
696 #ifdef SIGBUS
697     SIGNAL(SIGBUS, bad_signal);
698 #endif
699 #ifdef SIGEMT
700     SIGNAL(SIGEMT, bad_signal);
701 #endif
702 #ifdef SIGPOLL
703     SIGNAL(SIGPOLL, bad_signal);
704 #endif
705 #ifdef SIGPROF
706     SIGNAL(SIGPROF, bad_signal);
707 #endif
708 #ifdef SIGSYS
709     SIGNAL(SIGSYS, bad_signal);
710 #endif
711 #ifdef SIGTRAP
712     SIGNAL(SIGTRAP, bad_signal);
713 #endif
714 #ifdef SIGVTALRM
715     SIGNAL(SIGVTALRM, bad_signal);
716 #endif
717 #ifdef SIGXCPU
718     SIGNAL(SIGXCPU, bad_signal);
719 #endif
720 #ifdef SIGXFSZ
721     SIGNAL(SIGXFSZ, bad_signal);
722 #endif
723
724     /*
725      * Apparently we can get a SIGPIPE when we call syslog, if
726      * syslogd has died and been restarted.  Ignoring it seems
727      * be sufficient.
728      */
729     signal(SIGPIPE, SIG_IGN);
730 }
731
732 /*
733  * set_ifunit - do things we need to do once we know which ppp
734  * unit we are using.
735  */
736 void
737 set_ifunit(iskey)
738     int iskey;
739 {
740     info("Using interface %s%d", PPP_DRV_NAME, ifunit);
741     slprintf(ifname, sizeof(ifname), "%s%d", PPP_DRV_NAME, ifunit);
742     script_setenv("IFNAME", ifname, iskey);
743     if (iskey) {
744         create_pidfile(getpid());       /* write pid to file */
745         create_linkpidfile(getpid());
746     }
747 }
748
749 /*
750  * detach - detach us from the controlling terminal.
751  */
752 void
753 detach()
754 {
755     int pid;
756     char numbuf[16];
757     int pipefd[2];
758
759     if (detached)
760         return;
761     if (pipe(pipefd) == -1)
762         pipefd[0] = pipefd[1] = -1;
763     if ((pid = fork()) < 0) {
764         error("Couldn't detach (fork failed: %m)");
765         die(1);                 /* or just return? */
766     }
767     if (pid != 0) {
768         /* parent */
769         notify(pidchange, pid);
770         /* update pid files if they have been written already */
771         if (pidfilename[0])
772             create_pidfile(pid);
773         if (linkpidfile[0])
774             create_linkpidfile(pid);
775         exit(0);                /* parent dies */
776     }
777     setsid();
778     chdir("/");
779     dup2(fd_devnull, 0);
780     dup2(fd_devnull, 1);
781     dup2(fd_devnull, 2);
782     detached = 1;
783     if (log_default)
784         log_to_fd = -1;
785     slprintf(numbuf, sizeof(numbuf), "%d", getpid());
786     script_setenv("PPPD_PID", numbuf, 1);
787
788     /* wait for parent to finish updating pid & lock files and die */
789     close(pipefd[1]);
790     complete_read(pipefd[0], numbuf, 1);
791     close(pipefd[0]);
792 }
793
794 /*
795  * reopen_log - (re)open our connection to syslog.
796  */
797 void
798 reopen_log()
799 {
800     openlog("pppd", LOG_PID | LOG_NDELAY, LOG_PPP);
801     setlogmask(LOG_UPTO(LOG_INFO));
802 }
803
804 /*
805  * Create a file containing our process ID.
806  */
807 static void
808 create_pidfile(pid)
809     int pid;
810 {
811     FILE *pidfile;
812
813     slprintf(pidfilename, sizeof(pidfilename), "%s%s.pid",
814              _PATH_VARRUN, ifname);
815     if ((pidfile = fopen(pidfilename, "w")) != NULL) {
816         fprintf(pidfile, "%d\n", pid);
817         (void) fclose(pidfile);
818     } else {
819         error("Failed to create pid file %s: %m", pidfilename);
820         pidfilename[0] = 0;
821     }
822 }
823
824 void
825 create_linkpidfile(pid)
826     int pid;
827 {
828     FILE *pidfile;
829
830     if (linkname[0] == 0)
831         return;
832     script_setenv("LINKNAME", linkname, 1);
833     slprintf(linkpidfile, sizeof(linkpidfile), "%sppp-%s.pid",
834              _PATH_VARRUN, linkname);
835     if ((pidfile = fopen(linkpidfile, "w")) != NULL) {
836         fprintf(pidfile, "%d\n", pid);
837         if (ifname[0])
838             fprintf(pidfile, "%s\n", ifname);
839         (void) fclose(pidfile);
840     } else {
841         error("Failed to create pid file %s: %m", linkpidfile);
842         linkpidfile[0] = 0;
843     }
844 }
845
846 /*
847  * remove_pidfile - remove our pid files
848  */
849 void remove_pidfiles()
850 {
851     if (pidfilename[0] != 0 && unlink(pidfilename) < 0 && errno != ENOENT)
852         warn("unable to delete pid file %s: %m", pidfilename);
853     pidfilename[0] = 0;
854     if (linkpidfile[0] != 0 && unlink(linkpidfile) < 0 && errno != ENOENT)
855         warn("unable to delete pid file %s: %m", linkpidfile);
856     linkpidfile[0] = 0;
857 }
858
859 /*
860  * holdoff_end - called via a timeout when the holdoff period ends.
861  */
862 static void
863 holdoff_end(arg)
864     void *arg;
865 {
866     new_phase(PHASE_DORMANT);
867 }
868
869 /* List of protocol names, to make our messages a little more informative. */
870 struct protocol_list {
871     u_short     proto;
872     const char  *name;
873 } protocol_list[] = {
874     { 0x21,     "IP" },
875     { 0x23,     "OSI Network Layer" },
876     { 0x25,     "Xerox NS IDP" },
877     { 0x27,     "DECnet Phase IV" },
878     { 0x29,     "Appletalk" },
879     { 0x2b,     "Novell IPX" },
880     { 0x2d,     "VJ compressed TCP/IP" },
881     { 0x2f,     "VJ uncompressed TCP/IP" },
882     { 0x31,     "Bridging PDU" },
883     { 0x33,     "Stream Protocol ST-II" },
884     { 0x35,     "Banyan Vines" },
885     { 0x39,     "AppleTalk EDDP" },
886     { 0x3b,     "AppleTalk SmartBuffered" },
887     { 0x3d,     "Multi-Link" },
888     { 0x3f,     "NETBIOS Framing" },
889     { 0x41,     "Cisco Systems" },
890     { 0x43,     "Ascom Timeplex" },
891     { 0x45,     "Fujitsu Link Backup and Load Balancing (LBLB)" },
892     { 0x47,     "DCA Remote Lan" },
893     { 0x49,     "Serial Data Transport Protocol (PPP-SDTP)" },
894     { 0x4b,     "SNA over 802.2" },
895     { 0x4d,     "SNA" },
896     { 0x4f,     "IP6 Header Compression" },
897     { 0x51,     "KNX Bridging Data" },
898     { 0x53,     "Encryption" },
899     { 0x55,     "Individual Link Encryption" },
900     { 0x57,     "IPv6" },
901     { 0x59,     "PPP Muxing" },
902     { 0x5b,     "Vendor-Specific Network Protocol" },
903     { 0x61,     "RTP IPHC Full Header" },
904     { 0x63,     "RTP IPHC Compressed TCP" },
905     { 0x65,     "RTP IPHC Compressed non-TCP" },
906     { 0x67,     "RTP IPHC Compressed UDP 8" },
907     { 0x69,     "RTP IPHC Compressed RTP 8" },
908     { 0x6f,     "Stampede Bridging" },
909     { 0x73,     "MP+" },
910     { 0xc1,     "NTCITS IPI" },
911     { 0xfb,     "single-link compression" },
912     { 0xfd,     "Compressed Datagram" },
913     { 0x0201,   "802.1d Hello Packets" },
914     { 0x0203,   "IBM Source Routing BPDU" },
915     { 0x0205,   "DEC LANBridge100 Spanning Tree" },
916     { 0x0207,   "Cisco Discovery Protocol" },
917     { 0x0209,   "Netcs Twin Routing" },
918     { 0x020b,   "STP - Scheduled Transfer Protocol" },
919     { 0x020d,   "EDP - Extreme Discovery Protocol" },
920     { 0x0211,   "Optical Supervisory Channel Protocol" },
921     { 0x0213,   "Optical Supervisory Channel Protocol" },
922     { 0x0231,   "Luxcom" },
923     { 0x0233,   "Sigma Network Systems" },
924     { 0x0235,   "Apple Client Server Protocol" },
925     { 0x0281,   "MPLS Unicast" },
926     { 0x0283,   "MPLS Multicast" },
927     { 0x0285,   "IEEE p1284.4 standard - data packets" },
928     { 0x0287,   "ETSI TETRA Network Protocol Type 1" },
929     { 0x0289,   "Multichannel Flow Treatment Protocol" },
930     { 0x2063,   "RTP IPHC Compressed TCP No Delta" },
931     { 0x2065,   "RTP IPHC Context State" },
932     { 0x2067,   "RTP IPHC Compressed UDP 16" },
933     { 0x2069,   "RTP IPHC Compressed RTP 16" },
934     { 0x4001,   "Cray Communications Control Protocol" },
935     { 0x4003,   "CDPD Mobile Network Registration Protocol" },
936     { 0x4005,   "Expand accelerator protocol" },
937     { 0x4007,   "ODSICP NCP" },
938     { 0x4009,   "DOCSIS DLL" },
939     { 0x400B,   "Cetacean Network Detection Protocol" },
940     { 0x4021,   "Stacker LZS" },
941     { 0x4023,   "RefTek Protocol" },
942     { 0x4025,   "Fibre Channel" },
943     { 0x4027,   "EMIT Protocols" },
944     { 0x405b,   "Vendor-Specific Protocol (VSP)" },
945     { 0x8021,   "Internet Protocol Control Protocol" },
946     { 0x8023,   "OSI Network Layer Control Protocol" },
947     { 0x8025,   "Xerox NS IDP Control Protocol" },
948     { 0x8027,   "DECnet Phase IV Control Protocol" },
949     { 0x8029,   "Appletalk Control Protocol" },
950     { 0x802b,   "Novell IPX Control Protocol" },
951     { 0x8031,   "Bridging NCP" },
952     { 0x8033,   "Stream Protocol Control Protocol" },
953     { 0x8035,   "Banyan Vines Control Protocol" },
954     { 0x803d,   "Multi-Link Control Protocol" },
955     { 0x803f,   "NETBIOS Framing Control Protocol" },
956     { 0x8041,   "Cisco Systems Control Protocol" },
957     { 0x8043,   "Ascom Timeplex" },
958     { 0x8045,   "Fujitsu LBLB Control Protocol" },
959     { 0x8047,   "DCA Remote Lan Network Control Protocol (RLNCP)" },
960     { 0x8049,   "Serial Data Control Protocol (PPP-SDCP)" },
961     { 0x804b,   "SNA over 802.2 Control Protocol" },
962     { 0x804d,   "SNA Control Protocol" },
963     { 0x804f,   "IP6 Header Compression Control Protocol" },
964     { 0x8051,   "KNX Bridging Control Protocol" },
965     { 0x8053,   "Encryption Control Protocol" },
966     { 0x8055,   "Individual Link Encryption Control Protocol" },
967     { 0x8057,   "IPv6 Control Protocol" },
968     { 0x8059,   "PPP Muxing Control Protocol" },
969     { 0x805b,   "Vendor-Specific Network Control Protocol (VSNCP)" },
970     { 0x806f,   "Stampede Bridging Control Protocol" },
971     { 0x8073,   "MP+ Control Protocol" },
972     { 0x80c1,   "NTCITS IPI Control Protocol" },
973     { 0x80fb,   "Single Link Compression Control Protocol" },
974     { 0x80fd,   "Compression Control Protocol" },
975     { 0x8207,   "Cisco Discovery Protocol Control" },
976     { 0x8209,   "Netcs Twin Routing" },
977     { 0x820b,   "STP - Control Protocol" },
978     { 0x820d,   "EDPCP - Extreme Discovery Protocol Ctrl Prtcl" },
979     { 0x8235,   "Apple Client Server Protocol Control" },
980     { 0x8281,   "MPLSCP" },
981     { 0x8285,   "IEEE p1284.4 standard - Protocol Control" },
982     { 0x8287,   "ETSI TETRA TNP1 Control Protocol" },
983     { 0x8289,   "Multichannel Flow Treatment Protocol" },
984     { 0xc021,   "Link Control Protocol" },
985     { 0xc023,   "Password Authentication Protocol" },
986     { 0xc025,   "Link Quality Report" },
987     { 0xc027,   "Shiva Password Authentication Protocol" },
988     { 0xc029,   "CallBack Control Protocol (CBCP)" },
989     { 0xc02b,   "BACP Bandwidth Allocation Control Protocol" },
990     { 0xc02d,   "BAP" },
991     { 0xc05b,   "Vendor-Specific Authentication Protocol (VSAP)" },
992     { 0xc081,   "Container Control Protocol" },
993     { 0xc223,   "Challenge Handshake Authentication Protocol" },
994     { 0xc225,   "RSA Authentication Protocol" },
995     { 0xc227,   "Extensible Authentication Protocol" },
996     { 0xc229,   "Mitsubishi Security Info Exch Ptcl (SIEP)" },
997     { 0xc26f,   "Stampede Bridging Authorization Protocol" },
998     { 0xc281,   "Proprietary Authentication Protocol" },
999     { 0xc283,   "Proprietary Authentication Protocol" },
1000     { 0xc481,   "Proprietary Node ID Authentication Protocol" },
1001     { 0,        NULL },
1002 };
1003
1004 /*
1005  * protocol_name - find a name for a PPP protocol.
1006  */
1007 const char *
1008 protocol_name(proto)
1009     int proto;
1010 {
1011     struct protocol_list *lp;
1012
1013     for (lp = protocol_list; lp->proto != 0; ++lp)
1014         if (proto == lp->proto)
1015             return lp->name;
1016     return NULL;
1017 }
1018
1019 /*
1020  * get_input - called when incoming data is available.
1021  */
1022 static void
1023 get_input()
1024 {
1025     int len, i;
1026     u_char *p;
1027     u_short protocol;
1028     struct protent *protp;
1029
1030     p = inpacket_buf;   /* point to beginning of packet buffer */
1031
1032     len = read_packet(inpacket_buf);
1033     if (len < 0)
1034         return;
1035
1036     if (len == 0) {
1037         if (bundle_eof && multilink_master) {
1038             notice("Last channel has disconnected");
1039             mp_bundle_terminated();
1040             return;
1041         }
1042         notice("Modem hangup");
1043         hungup = 1;
1044         status = EXIT_HANGUP;
1045         lcp_lowerdown(0);       /* serial link is no longer available */
1046         link_terminated(0);
1047         return;
1048     }
1049
1050     if (len < PPP_HDRLEN) {
1051         dbglog("received short packet:%.*B", len, p);
1052         return;
1053     }
1054
1055     dump_packet("rcvd", p, len);
1056     if (snoop_recv_hook) snoop_recv_hook(p, len);
1057
1058     p += 2;                             /* Skip address and control */
1059     GETSHORT(protocol, p);
1060     len -= PPP_HDRLEN;
1061
1062     /*
1063      * Toss all non-LCP packets unless LCP is OPEN.
1064      */
1065     if (protocol != PPP_LCP && lcp_fsm[0].state != OPENED) {
1066         dbglog("Discarded non-LCP packet when LCP not open");
1067         return;
1068     }
1069
1070     /*
1071      * Until we get past the authentication phase, toss all packets
1072      * except LCP, LQR and authentication packets.
1073      */
1074     if (phase <= PHASE_AUTHENTICATE
1075         && !(protocol == PPP_LCP || protocol == PPP_LQR
1076              || protocol == PPP_PAP || protocol == PPP_CHAP ||
1077                 protocol == PPP_EAP)) {
1078         dbglog("discarding proto 0x%x in phase %d",
1079                    protocol, phase);
1080         return;
1081     }
1082
1083     /*
1084      * Upcall the proper protocol input routine.
1085      */
1086     for (i = 0; (protp = protocols[i]) != NULL; ++i) {
1087         if (protp->protocol == protocol && protp->enabled_flag) {
1088             (*protp->input)(0, p, len);
1089             return;
1090         }
1091         if (protocol == (protp->protocol & ~0x8000) && protp->enabled_flag
1092             && protp->datainput != NULL) {
1093             (*protp->datainput)(0, p, len);
1094             return;
1095         }
1096     }
1097
1098     if (debug) {
1099         const char *pname = protocol_name(protocol);
1100         if (pname != NULL)
1101             warn("Unsupported protocol '%s' (0x%x) received", pname, protocol);
1102         else
1103             warn("Unsupported protocol 0x%x received", protocol);
1104     }
1105     lcp_sprotrej(0, p - PPP_HDRLEN, len + PPP_HDRLEN);
1106 }
1107
1108 /*
1109  * ppp_send_config - configure the transmit-side characteristics of
1110  * the ppp interface.  Returns -1, indicating an error, if the channel
1111  * send_config procedure called error() (or incremented error_count
1112  * itself), otherwise 0.
1113  */
1114 int
1115 ppp_send_config(unit, mtu, accm, pcomp, accomp)
1116     int unit, mtu;
1117     u_int32_t accm;
1118     int pcomp, accomp;
1119 {
1120         int errs;
1121
1122         if (the_channel->send_config == NULL)
1123                 return 0;
1124         errs = error_count;
1125         (*the_channel->send_config)(mtu, accm, pcomp, accomp);
1126         return (error_count != errs)? -1: 0;
1127 }
1128
1129 /*
1130  * ppp_recv_config - configure the receive-side characteristics of
1131  * the ppp interface.  Returns -1, indicating an error, if the channel
1132  * recv_config procedure called error() (or incremented error_count
1133  * itself), otherwise 0.
1134  */
1135 int
1136 ppp_recv_config(unit, mru, accm, pcomp, accomp)
1137     int unit, mru;
1138     u_int32_t accm;
1139     int pcomp, accomp;
1140 {
1141         int errs;
1142
1143         if (the_channel->recv_config == NULL)
1144                 return 0;
1145         errs = error_count;
1146         (*the_channel->recv_config)(mru, accm, pcomp, accomp);
1147         return (error_count != errs)? -1: 0;
1148 }
1149
1150 /*
1151  * new_phase - signal the start of a new phase of pppd's operation.
1152  */
1153 void
1154 new_phase(p)
1155     int p;
1156 {
1157     phase = p;
1158     if (new_phase_hook)
1159         (*new_phase_hook)(p);
1160     notify(phasechange, p);
1161 }
1162
1163 /*
1164  * die - clean up state and exit with the specified status.
1165  */
1166 void
1167 die(status)
1168     int status;
1169 {
1170     if (!doing_multilink || multilink_master)
1171         print_link_stats();
1172     cleanup();
1173     notify(exitnotify, status);
1174     syslog(LOG_INFO, "Exit.");
1175     exit(status);
1176 }
1177
1178 /*
1179  * cleanup - restore anything which needs to be restored before we exit
1180  */
1181 /* ARGSUSED */
1182 static void
1183 cleanup()
1184 {
1185     sys_cleanup();
1186
1187     if (fd_ppp >= 0)
1188         the_channel->disestablish_ppp(devfd);
1189     if (the_channel->cleanup)
1190         (*the_channel->cleanup)();
1191     remove_pidfiles();
1192
1193 #ifdef USE_TDB
1194     if (pppdb != NULL)
1195         cleanup_db();
1196 #endif
1197
1198 }
1199
1200 void
1201 print_link_stats()
1202 {
1203     /*
1204      * Print connect time and statistics.
1205      */
1206     if (link_stats_valid) {
1207        int t = (link_connect_time + 5) / 6;    /* 1/10ths of minutes */
1208        info("Connect time %d.%d minutes.", t/10, t%10);
1209        info("Sent %u bytes, received %u bytes.",
1210             link_stats.bytes_out, link_stats.bytes_in);
1211        link_stats_valid = 0;
1212     }
1213 }
1214
1215 /*
1216  * reset_link_stats - "reset" stats when link goes up.
1217  */
1218 void
1219 reset_link_stats(u)
1220     int u;
1221 {
1222     if (!get_ppp_stats(u, &old_link_stats))
1223         return;
1224     gettimeofday(&start_time, NULL);
1225 }
1226
1227 /*
1228  * update_link_stats - get stats at link termination.
1229  */
1230 void
1231 update_link_stats(u)
1232     int u;
1233 {
1234     struct timeval now;
1235     char numbuf[32];
1236
1237     if (!get_ppp_stats(u, &link_stats)
1238         || gettimeofday(&now, NULL) < 0)
1239         return;
1240     link_connect_time = now.tv_sec - start_time.tv_sec;
1241     link_stats_valid = 1;
1242
1243     link_stats.bytes_in  -= old_link_stats.bytes_in;
1244     link_stats.bytes_out -= old_link_stats.bytes_out;
1245     link_stats.pkts_in   -= old_link_stats.pkts_in;
1246     link_stats.pkts_out  -= old_link_stats.pkts_out;
1247
1248     slprintf(numbuf, sizeof(numbuf), "%u", link_connect_time);
1249     script_setenv("CONNECT_TIME", numbuf, 0);
1250     slprintf(numbuf, sizeof(numbuf), "%u", link_stats.bytes_out);
1251     script_setenv("BYTES_SENT", numbuf, 0);
1252     slprintf(numbuf, sizeof(numbuf), "%u", link_stats.bytes_in);
1253     script_setenv("BYTES_RCVD", numbuf, 0);
1254 }
1255
1256
1257 struct  callout {
1258     struct timeval      c_time;         /* time at which to call routine */
1259     void                *c_arg;         /* argument to routine */
1260     void                (*c_func) __P((void *)); /* routine */
1261     struct              callout *c_next;
1262 };
1263
1264 static struct callout *callout = NULL;  /* Callout list */
1265 static struct timeval timenow;          /* Current time */
1266
1267 /*
1268  * timeout - Schedule a timeout.
1269  */
1270 void
1271 timeout(func, arg, secs, usecs)
1272     void (*func) __P((void *));
1273     void *arg;
1274     int secs, usecs;
1275 {
1276     struct callout *newp, *p, **pp;
1277
1278     /*
1279      * Allocate timeout.
1280      */
1281     if ((newp = (struct callout *) malloc(sizeof(struct callout))) == NULL)
1282         fatal("Out of memory in timeout()!");
1283     newp->c_arg = arg;
1284     newp->c_func = func;
1285     gettimeofday(&timenow, NULL);
1286     newp->c_time.tv_sec = timenow.tv_sec + secs;
1287     newp->c_time.tv_usec = timenow.tv_usec + usecs;
1288     if (newp->c_time.tv_usec >= 1000000) {
1289         newp->c_time.tv_sec += newp->c_time.tv_usec / 1000000;
1290         newp->c_time.tv_usec %= 1000000;
1291     }
1292
1293     /*
1294      * Find correct place and link it in.
1295      */
1296     for (pp = &callout; (p = *pp); pp = &p->c_next)
1297         if (newp->c_time.tv_sec < p->c_time.tv_sec
1298             || (newp->c_time.tv_sec == p->c_time.tv_sec
1299                 && newp->c_time.tv_usec < p->c_time.tv_usec))
1300             break;
1301     newp->c_next = p;
1302     *pp = newp;
1303 }
1304
1305
1306 /*
1307  * untimeout - Unschedule a timeout.
1308  */
1309 void
1310 untimeout(func, arg)
1311     void (*func) __P((void *));
1312     void *arg;
1313 {
1314     struct callout **copp, *freep;
1315
1316     /*
1317      * Find first matching timeout and remove it from the list.
1318      */
1319     for (copp = &callout; (freep = *copp); copp = &freep->c_next)
1320         if (freep->c_func == func && freep->c_arg == arg) {
1321             *copp = freep->c_next;
1322             free((char *) freep);
1323             break;
1324         }
1325 }
1326
1327
1328 /*
1329  * calltimeout - Call any timeout routines which are now due.
1330  */
1331 static void
1332 calltimeout()
1333 {
1334     struct callout *p;
1335
1336     while (callout != NULL) {
1337         p = callout;
1338
1339         if (gettimeofday(&timenow, NULL) < 0)
1340             fatal("Failed to get time of day: %m");
1341         if (!(p->c_time.tv_sec < timenow.tv_sec
1342               || (p->c_time.tv_sec == timenow.tv_sec
1343                   && p->c_time.tv_usec <= timenow.tv_usec)))
1344             break;              /* no, it's not time yet */
1345
1346         callout = p->c_next;
1347         (*p->c_func)(p->c_arg);
1348
1349         free((char *) p);
1350     }
1351 }
1352
1353
1354 /*
1355  * timeleft - return the length of time until the next timeout is due.
1356  */
1357 static struct timeval *
1358 timeleft(tvp)
1359     struct timeval *tvp;
1360 {
1361     if (callout == NULL)
1362         return NULL;
1363
1364     gettimeofday(&timenow, NULL);
1365     tvp->tv_sec = callout->c_time.tv_sec - timenow.tv_sec;
1366     tvp->tv_usec = callout->c_time.tv_usec - timenow.tv_usec;
1367     if (tvp->tv_usec < 0) {
1368         tvp->tv_usec += 1000000;
1369         tvp->tv_sec -= 1;
1370     }
1371     if (tvp->tv_sec < 0)
1372         tvp->tv_sec = tvp->tv_usec = 0;
1373
1374     return tvp;
1375 }
1376
1377
1378 /*
1379  * kill_my_pg - send a signal to our process group, and ignore it ourselves.
1380  * We assume that sig is currently blocked.
1381  */
1382 static void
1383 kill_my_pg(sig)
1384     int sig;
1385 {
1386     struct sigaction act, oldact;
1387     struct subprocess *chp;
1388
1389     if (!detached) {
1390         /*
1391          * There might be other things in our process group that we
1392          * didn't start that would get hit if we did a kill(0), so
1393          * just send the signal individually to our children.
1394          */
1395         for (chp = children; chp != NULL; chp = chp->next)
1396             if (chp->killable)
1397                 kill(chp->pid, sig);
1398         return;
1399     }
1400
1401     /* We've done a setsid(), so we can just use a kill(0) */
1402     sigemptyset(&act.sa_mask);          /* unnecessary in fact */
1403     act.sa_handler = SIG_IGN;
1404     act.sa_flags = 0;
1405     kill(0, sig);
1406     /*
1407      * The kill() above made the signal pending for us, as well as
1408      * the rest of our process group, but we don't want it delivered
1409      * to us.  It is blocked at the moment.  Setting it to be ignored
1410      * will cause the pending signal to be discarded.  If we did the
1411      * kill() after setting the signal to be ignored, it is unspecified
1412      * (by POSIX) whether the signal is immediately discarded or left
1413      * pending, and in fact Linux would leave it pending, and so it
1414      * would be delivered after the current signal handler exits,
1415      * leading to an infinite loop.
1416      */
1417     sigaction(sig, &act, &oldact);
1418     sigaction(sig, &oldact, NULL);
1419 }
1420
1421
1422 /*
1423  * hup - Catch SIGHUP signal.
1424  *
1425  * Indicates that the physical layer has been disconnected.
1426  * We don't rely on this indication; if the user has sent this
1427  * signal, we just take the link down.
1428  */
1429 static void
1430 hup(sig)
1431     int sig;
1432 {
1433     /* can't log a message here, it can deadlock */
1434     got_sighup = 1;
1435     if (conn_running)
1436         /* Send the signal to the [dis]connector process(es) also */
1437         kill_my_pg(sig);
1438     notify(sigreceived, sig);
1439     if (waiting)
1440         siglongjmp(sigjmp, 1);
1441 }
1442
1443
1444 /*
1445  * term - Catch SIGTERM signal and SIGINT signal (^C/del).
1446  *
1447  * Indicates that we should initiate a graceful disconnect and exit.
1448  */
1449 /*ARGSUSED*/
1450 static void
1451 term(sig)
1452     int sig;
1453 {
1454     /* can't log a message here, it can deadlock */
1455     got_sigterm = sig;
1456     if (conn_running)
1457         /* Send the signal to the [dis]connector process(es) also */
1458         kill_my_pg(sig);
1459     notify(sigreceived, sig);
1460     if (waiting)
1461         siglongjmp(sigjmp, 1);
1462 }
1463
1464
1465 /*
1466  * chld - Catch SIGCHLD signal.
1467  * Sets a flag so we will call reap_kids in the mainline.
1468  */
1469 static void
1470 chld(sig)
1471     int sig;
1472 {
1473     got_sigchld = 1;
1474     if (waiting)
1475         siglongjmp(sigjmp, 1);
1476 }
1477
1478
1479 /*
1480  * toggle_debug - Catch SIGUSR1 signal.
1481  *
1482  * Toggle debug flag.
1483  */
1484 /*ARGSUSED*/
1485 static void
1486 toggle_debug(sig)
1487     int sig;
1488 {
1489     debug = !debug;
1490     if (debug) {
1491         setlogmask(LOG_UPTO(LOG_DEBUG));
1492     } else {
1493         setlogmask(LOG_UPTO(LOG_WARNING));
1494     }
1495 }
1496
1497
1498 /*
1499  * open_ccp - Catch SIGUSR2 signal.
1500  *
1501  * Try to (re)negotiate compression.
1502  */
1503 /*ARGSUSED*/
1504 static void
1505 open_ccp(sig)
1506     int sig;
1507 {
1508     got_sigusr2 = 1;
1509     if (waiting)
1510         siglongjmp(sigjmp, 1);
1511 }
1512
1513
1514 /*
1515  * bad_signal - We've caught a fatal signal.  Clean up state and exit.
1516  */
1517 static void
1518 bad_signal(sig)
1519     int sig;
1520 {
1521     static int crashed = 0;
1522
1523     if (crashed)
1524         _exit(127);
1525     crashed = 1;
1526     error("Fatal signal %d", sig);
1527     if (conn_running)
1528         kill_my_pg(SIGTERM);
1529     notify(sigreceived, sig);
1530     die(127);
1531 }
1532
1533 /*
1534  * safe_fork - Create a child process.  The child closes all the
1535  * file descriptors that we don't want to leak to a script.
1536  * The parent waits for the child to do this before returning.
1537  * This also arranges for the specified fds to be dup'd to
1538  * fds 0, 1, 2 in the child.
1539  */
1540 pid_t
1541 safe_fork(int infd, int outfd, int errfd)
1542 {
1543         pid_t pid;
1544         int fd, pipefd[2];
1545         char buf[1];
1546
1547         /* make sure fds 0, 1, 2 are occupied (probably not necessary) */
1548         while ((fd = dup(fd_devnull)) >= 0) {
1549                 if (fd > 2) {
1550                         close(fd);
1551                         break;
1552                 }
1553         }
1554
1555         if (pipe(pipefd) == -1)
1556                 pipefd[0] = pipefd[1] = -1;
1557         pid = fork();
1558         if (pid < 0) {
1559                 error("fork failed: %m");
1560                 return -1;
1561         }
1562         if (pid > 0) {
1563                 /* parent */
1564                 close(pipefd[1]);
1565                 /* this read() blocks until the close(pipefd[1]) below */
1566                 complete_read(pipefd[0], buf, 1);
1567                 close(pipefd[0]);
1568                 return pid;
1569         }
1570
1571         /* Executing in the child */
1572         sys_close();
1573 #ifdef USE_TDB
1574         tdb_close(pppdb);
1575 #endif
1576
1577         /* make sure infd, outfd and errfd won't get tromped on below */
1578         if (infd == 1 || infd == 2)
1579                 infd = dup(infd);
1580         if (outfd == 0 || outfd == 2)
1581                 outfd = dup(outfd);
1582         if (errfd == 0 || errfd == 1)
1583                 errfd = dup(errfd);
1584
1585         closelog();
1586
1587         /* dup the in, out, err fds to 0, 1, 2 */
1588         if (infd != 0)
1589                 dup2(infd, 0);
1590         if (outfd != 1)
1591                 dup2(outfd, 1);
1592         if (errfd != 2)
1593                 dup2(errfd, 2);
1594
1595         if (log_to_fd > 2)
1596                 close(log_to_fd);
1597         if (the_channel->close)
1598                 (*the_channel->close)();
1599         else
1600                 close(devfd);   /* some plugins don't have a close function */
1601         close(fd_ppp);
1602         close(fd_devnull);
1603         if (infd != 0)
1604                 close(infd);
1605         if (outfd != 1)
1606                 close(outfd);
1607         if (errfd != 2)
1608                 close(errfd);
1609
1610         notify(fork_notifier, 0);
1611         close(pipefd[0]);
1612         /* this close unblocks the read() call above in the parent */
1613         close(pipefd[1]);
1614
1615         return 0;
1616 }
1617
1618 static bool
1619 add_script_env(pos, newstring)
1620     int pos;
1621     char *newstring;
1622 {
1623     if (pos + 1 >= s_env_nalloc) {
1624         int new_n = pos + 17;
1625         char **newenv = realloc(script_env, new_n * sizeof(char *));
1626         if (newenv == NULL) {
1627             free(newstring - 1);
1628             return 0;
1629         }
1630         script_env = newenv;
1631         s_env_nalloc = new_n;
1632     }
1633     script_env[pos] = newstring;
1634     script_env[pos + 1] = NULL;
1635     return 1;
1636 }
1637
1638 static void
1639 remove_script_env(pos)
1640     int pos;
1641 {
1642     free(script_env[pos] - 1);
1643     while ((script_env[pos] = script_env[pos + 1]) != NULL)
1644         pos++;
1645 }
1646
1647 /*
1648  * update_system_environment - process the list of set/unset options
1649  * and update the system environment.
1650  */
1651 static void
1652 update_system_environment()
1653 {
1654     struct userenv *uep;
1655
1656     for (uep = userenv_list; uep != NULL; uep = uep->ue_next) {
1657         if (uep->ue_isset)
1658             setenv(uep->ue_name, uep->ue_value, 1);
1659         else
1660             unsetenv(uep->ue_name);
1661     }
1662 }
1663
1664 /*
1665  * device_script - run a program to talk to the specified fds
1666  * (e.g. to run the connector or disconnector script).
1667  * stderr gets connected to the log fd or to the _PATH_CONNERRS file.
1668  */
1669 int
1670 device_script(program, in, out, dont_wait)
1671     char *program;
1672     int in, out;
1673     int dont_wait;
1674 {
1675     int pid;
1676     int status = -1;
1677     int errfd;
1678
1679     if (log_to_fd >= 0)
1680         errfd = log_to_fd;
1681     else
1682         errfd = open(_PATH_CONNERRS, O_WRONLY | O_APPEND | O_CREAT, 0600);
1683
1684     ++conn_running;
1685     pid = safe_fork(in, out, errfd);
1686
1687     if (pid != 0 && log_to_fd < 0)
1688         close(errfd);
1689
1690     if (pid < 0) {
1691         --conn_running;
1692         error("Failed to create child process: %m");
1693         return -1;
1694     }
1695
1696     if (pid != 0) {
1697         record_child(pid, program, NULL, NULL, 1);
1698         status = 0;
1699         if (!dont_wait) {
1700             while (waitpid(pid, &status, 0) < 0) {
1701                 if (errno == EINTR)
1702                     continue;
1703                 fatal("error waiting for (dis)connection process: %m");
1704             }
1705             forget_child(pid, status);
1706             --conn_running;
1707         }
1708         return (status == 0 ? 0 : -1);
1709     }
1710
1711     /* here we are executing in the child */
1712
1713     setgid(getgid());
1714     setuid(uid);
1715     if (getuid() != uid) {
1716         fprintf(stderr, "pppd: setuid failed\n");
1717         exit(1);
1718     }
1719     update_system_environment();
1720     execl("/bin/sh", "sh", "-c", program, (char *)0);
1721     perror("pppd: could not exec /bin/sh");
1722     _exit(99);
1723     /* NOTREACHED */
1724 }
1725
1726
1727 /*
1728  * update_script_environment - process the list of set/unset options
1729  * and update the script environment.  Note that we intentionally do
1730  * not update the TDB.  These changes are layered on top right before
1731  * exec.  It is not possible to use script_setenv() or
1732  * script_unsetenv() safely after this routine is run.
1733  */
1734 static void
1735 update_script_environment()
1736 {
1737     struct userenv *uep;
1738
1739     for (uep = userenv_list; uep != NULL; uep = uep->ue_next) {
1740         int i;
1741         char *p, *newstring;
1742         int nlen = strlen(uep->ue_name);
1743
1744         for (i = 0; (p = script_env[i]) != NULL; i++) {
1745             if (strncmp(p, uep->ue_name, nlen) == 0 && p[nlen] == '=')
1746                 break;
1747         }
1748         if (uep->ue_isset) {
1749             nlen += strlen(uep->ue_value) + 2;
1750             newstring = malloc(nlen + 1);
1751             if (newstring == NULL)
1752                 continue;
1753             *newstring++ = 0;
1754             slprintf(newstring, nlen, "%s=%s", uep->ue_name, uep->ue_value);
1755             if (p != NULL)
1756                 script_env[i] = newstring;
1757             else
1758                 add_script_env(i, newstring);
1759         } else {
1760             remove_script_env(i);
1761         }
1762     }
1763 }
1764
1765 /*
1766  * run_program - execute a program with given arguments,
1767  * but don't wait for it unless wait is non-zero.
1768  * If the program can't be executed, logs an error unless
1769  * must_exist is 0 and the program file doesn't exist.
1770  * Returns -1 if it couldn't fork, 0 if the file doesn't exist
1771  * or isn't an executable plain file, or the process ID of the child.
1772  * If done != NULL, (*done)(arg) will be called later (within
1773  * reap_kids) iff the return value is > 0.
1774  */
1775 pid_t
1776 run_program(prog, args, must_exist, done, arg, wait)
1777     char *prog;
1778     char **args;
1779     int must_exist;
1780     void (*done) __P((void *));
1781     void *arg;
1782     int wait;
1783 {
1784     int pid, status;
1785     struct stat sbuf;
1786
1787     /*
1788      * First check if the file exists and is executable.
1789      * We don't use access() because that would use the
1790      * real user-id, which might not be root, and the script
1791      * might be accessible only to root.
1792      */
1793     errno = EINVAL;
1794     if (stat(prog, &sbuf) < 0 || !S_ISREG(sbuf.st_mode)
1795         || (sbuf.st_mode & (S_IXUSR|S_IXGRP|S_IXOTH)) == 0) {
1796         if (must_exist || errno != ENOENT)
1797             warn("Can't execute %s: %m", prog);
1798         return 0;
1799     }
1800
1801     pid = safe_fork(fd_devnull, fd_devnull, fd_devnull);
1802     if (pid == -1) {
1803         error("Failed to create child process for %s: %m", prog);
1804         return -1;
1805     }
1806     if (pid != 0) {
1807         if (debug)
1808             dbglog("Script %s started (pid %d)", prog, pid);
1809         record_child(pid, prog, done, arg, 0);
1810         if (wait) {
1811             while (waitpid(pid, &status, 0) < 0) {
1812                 if (errno == EINTR)
1813                     continue;
1814                 fatal("error waiting for script %s: %m", prog);
1815             }
1816             forget_child(pid, status);
1817         }
1818         return pid;
1819     }
1820
1821     /* Leave the current location */
1822     (void) setsid();    /* No controlling tty. */
1823     (void) umask (S_IRWXG|S_IRWXO);
1824     (void) chdir ("/"); /* no current directory. */
1825     setuid(0);          /* set real UID = root */
1826     setgid(getegid());
1827
1828 #ifdef BSD
1829     /* Force the priority back to zero if pppd is running higher. */
1830     if (setpriority (PRIO_PROCESS, 0, 0) < 0)
1831         warn("can't reset priority to 0: %m");
1832 #endif
1833
1834     /* run the program */
1835     update_script_environment();
1836     execve(prog, args, script_env);
1837     if (must_exist || errno != ENOENT) {
1838         /* have to reopen the log, there's nowhere else
1839            for the message to go. */
1840         reopen_log();
1841         syslog(LOG_ERR, "Can't execute %s: %m", prog);
1842         closelog();
1843     }
1844     _exit(99);
1845 }
1846
1847
1848 /*
1849  * record_child - add a child process to the list for reap_kids
1850  * to use.
1851  */
1852 void
1853 record_child(pid, prog, done, arg, killable)
1854     int pid;
1855     char *prog;
1856     void (*done) __P((void *));
1857     void *arg;
1858     int killable;
1859 {
1860     struct subprocess *chp;
1861
1862     ++n_children;
1863
1864     chp = (struct subprocess *) malloc(sizeof(struct subprocess));
1865     if (chp == NULL) {
1866         warn("losing track of %s process", prog);
1867     } else {
1868         chp->pid = pid;
1869         chp->prog = prog;
1870         chp->done = done;
1871         chp->arg = arg;
1872         chp->next = children;
1873         chp->killable = killable;
1874         children = chp;
1875     }
1876 }
1877
1878 /*
1879  * childwait_end - we got fed up waiting for the child processes to
1880  * exit, send them all a SIGTERM.
1881  */
1882 static void
1883 childwait_end(arg)
1884     void *arg;
1885 {
1886     struct subprocess *chp;
1887
1888     for (chp = children; chp != NULL; chp = chp->next) {
1889         if (debug)
1890             dbglog("sending SIGTERM to process %d", chp->pid);
1891         kill(chp->pid, SIGTERM);
1892     }
1893     childwait_done = 1;
1894 }
1895
1896 /*
1897  * forget_child - clean up after a dead child
1898  */
1899 static void
1900 forget_child(pid, status)
1901     int pid, status;
1902 {
1903     struct subprocess *chp, **prevp;
1904
1905     for (prevp = &children; (chp = *prevp) != NULL; prevp = &chp->next) {
1906         if (chp->pid == pid) {
1907             --n_children;
1908             *prevp = chp->next;
1909             break;
1910         }
1911     }
1912     if (WIFSIGNALED(status)) {
1913         warn("Child process %s (pid %d) terminated with signal %d",
1914              (chp? chp->prog: "??"), pid, WTERMSIG(status));
1915     } else if (debug)
1916         dbglog("Script %s finished (pid %d), status = 0x%x",
1917                (chp? chp->prog: "??"), pid,
1918                WIFEXITED(status) ? WEXITSTATUS(status) : status);
1919     if (chp && chp->done)
1920         (*chp->done)(chp->arg);
1921     if (chp)
1922         free(chp);
1923 }
1924
1925 /*
1926  * reap_kids - get status from any dead child processes,
1927  * and log a message for abnormal terminations.
1928  */
1929 static int
1930 reap_kids()
1931 {
1932     int pid, status;
1933
1934     if (n_children == 0)
1935         return 0;
1936     while ((pid = waitpid(-1, &status, WNOHANG)) != -1 && pid != 0) {
1937         forget_child(pid, status);
1938     }
1939     if (pid == -1) {
1940         if (errno == ECHILD)
1941             return -1;
1942         if (errno != EINTR)
1943             error("Error waiting for child process: %m");
1944     }
1945     return 0;
1946 }
1947
1948 /*
1949  * add_notifier - add a new function to be called when something happens.
1950  */
1951 void
1952 add_notifier(notif, func, arg)
1953     struct notifier **notif;
1954     notify_func func;
1955     void *arg;
1956 {
1957     struct notifier *np;
1958
1959     np = malloc(sizeof(struct notifier));
1960     if (np == 0)
1961         novm("notifier struct");
1962     np->next = *notif;
1963     np->func = func;
1964     np->arg = arg;
1965     *notif = np;
1966 }
1967
1968 /*
1969  * remove_notifier - remove a function from the list of things to
1970  * be called when something happens.
1971  */
1972 void
1973 remove_notifier(notif, func, arg)
1974     struct notifier **notif;
1975     notify_func func;
1976     void *arg;
1977 {
1978     struct notifier *np;
1979
1980     for (; (np = *notif) != 0; notif = &np->next) {
1981         if (np->func == func && np->arg == arg) {
1982             *notif = np->next;
1983             free(np);
1984             break;
1985         }
1986     }
1987 }
1988
1989 /*
1990  * notify - call a set of functions registered with add_notifier.
1991  */
1992 void
1993 notify(notif, val)
1994     struct notifier *notif;
1995     int val;
1996 {
1997     struct notifier *np;
1998
1999     while ((np = notif) != 0) {
2000         notif = np->next;
2001         (*np->func)(np->arg, val);
2002     }
2003 }
2004
2005 /*
2006  * novm - log an error message saying we ran out of memory, and die.
2007  */
2008 void
2009 novm(msg)
2010     char *msg;
2011 {
2012     fatal("Virtual memory exhausted allocating %s\n", msg);
2013 }
2014
2015 /*
2016  * script_setenv - set an environment variable value to be used
2017  * for scripts that we run (e.g. ip-up, auth-up, etc.)
2018  */
2019 void
2020 script_setenv(var, value, iskey)
2021     char *var, *value;
2022     int iskey;
2023 {
2024     size_t varl = strlen(var);
2025     size_t vl = varl + strlen(value) + 2;
2026     int i;
2027     char *p, *newstring;
2028
2029     newstring = (char *) malloc(vl+1);
2030     if (newstring == 0)
2031         return;
2032     *newstring++ = iskey;
2033     slprintf(newstring, vl, "%s=%s", var, value);
2034
2035     /* check if this variable is already set */
2036     if (script_env != 0) {
2037         for (i = 0; (p = script_env[i]) != 0; ++i) {
2038             if (strncmp(p, var, varl) == 0 && p[varl] == '=') {
2039 #ifdef USE_TDB
2040                 if (p[-1] && pppdb != NULL)
2041                     delete_db_key(p);
2042 #endif
2043                 free(p-1);
2044                 script_env[i] = newstring;
2045 #ifdef USE_TDB
2046                 if (iskey && pppdb != NULL)
2047                     add_db_key(newstring);
2048                 update_db_entry();
2049 #endif
2050                 return;
2051             }
2052         }
2053     } else {
2054         /* no space allocated for script env. ptrs. yet */
2055         i = 0;
2056         script_env = malloc(16 * sizeof(char *));
2057         if (script_env == 0) {
2058             free(newstring - 1);
2059             return;
2060         }
2061         s_env_nalloc = 16;
2062     }
2063
2064     if (!add_script_env(i, newstring))
2065         return;
2066
2067 #ifdef USE_TDB
2068     if (pppdb != NULL) {
2069         if (iskey)
2070             add_db_key(newstring);
2071         update_db_entry();
2072     }
2073 #endif
2074 }
2075
2076 /*
2077  * script_unsetenv - remove a variable from the environment
2078  * for scripts.
2079  */
2080 void
2081 script_unsetenv(var)
2082     char *var;
2083 {
2084     int vl = strlen(var);
2085     int i;
2086     char *p;
2087
2088     if (script_env == 0)
2089         return;
2090     for (i = 0; (p = script_env[i]) != 0; ++i) {
2091         if (strncmp(p, var, vl) == 0 && p[vl] == '=') {
2092 #ifdef USE_TDB
2093             if (p[-1] && pppdb != NULL)
2094                 delete_db_key(p);
2095 #endif
2096             remove_script_env(i);
2097             break;
2098         }
2099     }
2100 #ifdef USE_TDB
2101     if (pppdb != NULL)
2102         update_db_entry();
2103 #endif
2104 }
2105
2106 /*
2107  * Any arbitrary string used as a key for locking the database.
2108  * It doesn't matter what it is as long as all pppds use the same string.
2109  */
2110 #define PPPD_LOCK_KEY   "pppd lock"
2111
2112 /*
2113  * lock_db - get an exclusive lock on the TDB database.
2114  * Used to ensure atomicity of various lookup/modify operations.
2115  */
2116 void lock_db()
2117 {
2118 #ifdef USE_TDB
2119         TDB_DATA key;
2120
2121         key.dptr = PPPD_LOCK_KEY;
2122         key.dsize = strlen(key.dptr);
2123         tdb_chainlock(pppdb, key);
2124 #endif
2125 }
2126
2127 /*
2128  * unlock_db - remove the exclusive lock obtained by lock_db.
2129  */
2130 void unlock_db()
2131 {
2132 #ifdef USE_TDB
2133         TDB_DATA key;
2134
2135         key.dptr = PPPD_LOCK_KEY;
2136         key.dsize = strlen(key.dptr);
2137         tdb_chainunlock(pppdb, key);
2138 #endif
2139 }
2140
2141 #ifdef USE_TDB
2142 /*
2143  * update_db_entry - update our entry in the database.
2144  */
2145 static void
2146 update_db_entry()
2147 {
2148     TDB_DATA key, dbuf;
2149     int vlen, i;
2150     char *p, *q, *vbuf;
2151
2152     if (script_env == NULL)
2153         return;
2154     vlen = 0;
2155     for (i = 0; (p = script_env[i]) != 0; ++i)
2156         vlen += strlen(p) + 1;
2157     vbuf = malloc(vlen + 1);
2158     if (vbuf == 0)
2159         novm("database entry");
2160     q = vbuf;
2161     for (i = 0; (p = script_env[i]) != 0; ++i)
2162         q += slprintf(q, vbuf + vlen - q, "%s;", p);
2163
2164     key.dptr = db_key;
2165     key.dsize = strlen(db_key);
2166     dbuf.dptr = vbuf;
2167     dbuf.dsize = vlen;
2168     if (tdb_store(pppdb, key, dbuf, TDB_REPLACE))
2169         error("tdb_store failed: %s", tdb_errorstr(pppdb));
2170
2171     if (vbuf)
2172         free(vbuf);
2173
2174 }
2175
2176 /*
2177  * add_db_key - add a key that we can use to look up our database entry.
2178  */
2179 static void
2180 add_db_key(str)
2181     const char *str;
2182 {
2183     TDB_DATA key, dbuf;
2184
2185     key.dptr = (char *) str;
2186     key.dsize = strlen(str);
2187     dbuf.dptr = db_key;
2188     dbuf.dsize = strlen(db_key);
2189     if (tdb_store(pppdb, key, dbuf, TDB_REPLACE))
2190         error("tdb_store key failed: %s", tdb_errorstr(pppdb));
2191 }
2192
2193 /*
2194  * delete_db_key - delete a key for looking up our database entry.
2195  */
2196 static void
2197 delete_db_key(str)
2198     const char *str;
2199 {
2200     TDB_DATA key;
2201
2202     key.dptr = (char *) str;
2203     key.dsize = strlen(str);
2204     tdb_delete(pppdb, key);
2205 }
2206
2207 /*
2208  * cleanup_db - delete all the entries we put in the database.
2209  */
2210 static void
2211 cleanup_db()
2212 {
2213     TDB_DATA key;
2214     int i;
2215     char *p;
2216
2217     key.dptr = db_key;
2218     key.dsize = strlen(db_key);
2219     tdb_delete(pppdb, key);
2220     for (i = 0; (p = script_env[i]) != 0; ++i)
2221         if (p[-1])
2222             delete_db_key(p);
2223 }
2224 #endif /* USE_TDB */