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