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