2 * main.c - Point-to-Point Protocol main module
4 * Copyright (c) 1984-2000 Carnegie Mellon University. All rights reserved.
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
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
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
25 * Pittsburgh, PA 15213-3890
26 * (412) 268-4387, fax: (412) 268-7395
27 * tech-transfer@andrew.cmu.edu
29 * 4. Redistributions of any form whatsoever must retain the following
31 * "This product includes software developed by Computing Services
32 * at Carnegie Mellon University (http://www.cmu.edu/computing/)."
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.
42 * Copyright (c) 1999-2004 Paul Mackerras. All rights reserved.
44 * Redistribution and use in source and binary forms, with or without
45 * modification, are permitted provided that the following conditions
48 * 1. Redistributions of source code must retain the above copyright
49 * notice, this list of conditions and the following disclaimer.
51 * 2. The name(s) of the authors of this software must not be used to
52 * endorse or promote products derived from this software without
53 * prior written permission.
55 * 3. Redistributions of any form whatsoever must retain the following
57 * "This product includes software developed by Paul Mackerras
58 * <paulus@samba.org>".
60 * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO
61 * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
62 * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
63 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
64 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
65 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
66 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
69 #define RCSID "$Id: main.c,v 1.156 2008/06/23 11:47:18 paulus Exp $"
84 #include <sys/param.h>
85 #include <sys/types.h>
88 #include <sys/resource.h>
90 #include <sys/socket.h>
91 #include <netinet/in.h>
92 #include <arpa/inet.h>
93 #include <sys/sysinfo.h>
104 #include "chap-new.h"
108 #include "pathnames.h"
120 #endif /* IPX_CHANGE */
125 static const char rcsid
[] = RCSID
;
128 char ifname
[32]; /* Interface name */
129 int ifunit
; /* Interface unit number */
131 struct channel
*the_channel
;
133 char *progname
; /* Name of this program */
134 char hostname
[MAXNAMELEN
]; /* Our hostname */
135 static char pidfilename
[MAXPATHLEN
]; /* name of pid file */
136 static char linkpidfile
[MAXPATHLEN
]; /* name of linkname pid file */
137 char ppp_devnam
[MAXPATHLEN
]; /* name of PPP tty (maybe ttypx) */
138 uid_t uid
; /* Our real user-id */
139 struct notifier
*pidchange
= NULL
;
140 struct notifier
*phasechange
= NULL
;
141 struct notifier
*exitnotify
= NULL
;
142 struct notifier
*sigreceived
= NULL
;
143 struct notifier
*fork_notifier
= NULL
;
145 int hungup
; /* terminal has been hung up */
146 int privileged
; /* we're running as real uid root */
147 int need_holdoff
; /* need holdoff period before restarting */
148 int detached
; /* have detached from terminal */
149 volatile int status
; /* exit status for pppd */
150 int unsuccess
; /* # unsuccessful connection attempts */
151 int do_callback
; /* != 0 if we should do callback next */
152 int doing_callback
; /* != 0 if we are doing callback */
153 int ppp_session_number
; /* Session number, for channels with such a
154 concept (eg PPPoE) */
155 int childwait_done
; /* have timed out waiting for children */
158 TDB_CONTEXT
*pppdb
; /* database for storing status etc. */
163 int (*holdoff_hook
) __P((void)) = NULL
;
164 int (*new_phase_hook
) __P((int)) = NULL
;
165 void (*snoop_recv_hook
) __P((unsigned char *p
, int len
)) = NULL
;
166 void (*snoop_send_hook
) __P((unsigned char *p
, int len
)) = NULL
;
168 static int conn_running
; /* we have a [dis]connector running */
169 static int fd_loop
; /* fd for getting demand-dial packets */
171 int fd_devnull
; /* fd for /dev/null */
172 int devfd
= -1; /* fd of underlying device */
173 int fd_ppp
= -1; /* fd for talking PPP */
174 int phase
; /* where the link is at */
183 static sigset_t signals_handled
;
185 static sigjmp_buf sigjmp
;
187 char **script_env
; /* Env. variable values for scripts */
188 int s_env_nalloc
; /* # words avail at script_env */
190 u_char outpacket_buf
[PPP_MRU
+PPP_HDRLEN
]; /* buffer for outgoing packet */
191 u_char inpacket_buf
[PPP_MRU
+PPP_HDRLEN
]; /* buffer for incoming packet */
193 static int n_children
; /* # child processes still running */
194 static int got_sigchld
; /* set if we have received a SIGCHLD */
196 int privopen
; /* don't lock, open device as root */
198 char *no_ppp_msg
= "Sorry - this system lacks PPP kernel support\n";
200 GIDSET_TYPE groups
[NGROUPS_MAX
];/* groups the user is in */
201 int ngroups
; /* How many groups valid in groups */
203 static struct timeval start_time
; /* Time when link was started. */
205 static struct pppd_stats old_link_stats
;
206 struct pppd_stats link_stats
;
207 unsigned link_connect_time
;
208 int link_stats_valid
;
213 bool bundle_terminating
;
216 * We maintain a list of child process pids and
217 * functions to call when they exit.
222 void (*done
) __P((void *));
225 struct subprocess
*next
;
228 static struct subprocess
*children
;
230 /* Prototypes for procedures local to this file. */
232 static void check_time(void);
233 static void setup_signals
__P((void));
234 static void create_pidfile
__P((int pid
));
235 static void create_linkpidfile
__P((int pid
));
236 static void cleanup
__P((void));
237 static void get_input
__P((void));
238 static void calltimeout
__P((void));
239 static struct timeval
*timeleft
__P((struct timeval
*));
240 static void kill_my_pg
__P((int));
241 static void hup
__P((int));
242 static void term
__P((int));
243 static void chld
__P((int));
244 static void toggle_debug
__P((int));
245 static void open_ccp
__P((int));
246 static void bad_signal
__P((int));
247 static void holdoff_end
__P((void *));
248 static void forget_child
__P((int pid
, int status
));
249 static int reap_kids
__P((void));
250 static void childwait_end
__P((void *));
253 static void update_db_entry
__P((void));
254 static void add_db_key
__P((const char *));
255 static void delete_db_key
__P((const char *));
256 static void cleanup_db
__P((void));
259 static void handle_events
__P((void));
260 void print_link_stats
__P((void));
262 extern char *ttyname
__P((int));
263 extern char *getlogin
__P((void));
264 int main
__P((int, char *[]));
268 #define O_NONBLOCK O_NDELAY
272 #define setlogmask(x)
276 * PPP Data Link Layer "protocol" table.
277 * One entry per supported protocol.
278 * The last entry must be NULL.
280 struct protent
*protocols
[] = {
304 * If PPP_DRV_NAME is not defined, use the default "ppp" as the device name.
306 #if !defined(PPP_DRV_NAME)
307 #define PPP_DRV_NAME "ppp"
308 #endif /* !defined(PPP_DRV_NAME) */
318 struct protent
*protp
;
321 strlcpy(path_ipup
, _PATH_IPUP
, sizeof(path_ipup
));
322 strlcpy(path_ipdown
, _PATH_IPDOWN
, sizeof(path_ipdown
));
324 strlcpy(path_ipv6up
, _PATH_IPV6UP
, sizeof(path_ipv6up
));
325 strlcpy(path_ipv6down
, _PATH_IPV6DOWN
, sizeof(path_ipv6down
));
328 link_stats_valid
= 0;
329 new_phase(PHASE_INITIALIZE
);
333 /* Initialize syslog facilities */
336 if (gethostname(hostname
, MAXNAMELEN
) < 0 ) {
337 option_error("Couldn't get hostname: %m");
340 hostname
[MAXNAMELEN
-1] = 0;
342 /* make sure we don't create world or group writable files. */
343 umask(umask(0777) | 022);
346 privileged
= uid
== 0;
347 slprintf(numbuf
, sizeof(numbuf
), "%d", uid
);
348 script_setenv("ORIG_UID", numbuf
, 0);
350 ngroups
= getgroups(NGROUPS_MAX
, groups
);
353 * Initialize magic number generator now so that protocols may
354 * use magic numbers in initialization.
359 * Initialize each protocol.
361 for (i
= 0; (protp
= protocols
[i
]) != NULL
; ++i
)
365 * Initialize the default channel.
372 * Parse, in order, the system options file, the user's options file,
373 * and the command line arguments.
375 if (!options_from_file(_PATH_SYSOPTIONS
, !privileged
, 0, 1)
376 || !options_from_user()
377 || !parse_args(argc
-1, argv
+1))
378 exit(EXIT_OPTION_ERROR
);
379 devnam_fixed
= 1; /* can no longer change device name */
382 * Work out the device name, if it hasn't already been specified,
383 * and parse the tty's options file.
385 if (the_channel
->process_extra_options
)
386 (*the_channel
->process_extra_options
)();
389 setlogmask(LOG_UPTO(LOG_DEBUG
));
392 * Check that we are running as root.
394 if (geteuid() != 0) {
395 option_error("must be root to run %s, since it is not setuid-root",
400 if (!ppp_available()) {
401 option_error("%s", no_ppp_msg
);
402 exit(EXIT_NO_KERNEL_SUPPORT
);
406 * Check that the options given are valid and consistent.
409 if (!sys_check_options())
410 exit(EXIT_OPTION_ERROR
);
411 auth_check_options();
412 #ifdef HAVE_MULTILINK
415 for (i
= 0; (protp
= protocols
[i
]) != NULL
; ++i
)
416 if (protp
->check_options
!= NULL
)
417 (*protp
->check_options
)();
418 if (the_channel
->check_options
)
419 (*the_channel
->check_options
)();
422 if (dump_options
|| dryrun
) {
423 init_pr_log(NULL
, LOG_INFO
);
424 print_options(pr_log
, NULL
);
431 /* Make sure fds 0, 1, 2 are open to somewhere. */
432 fd_devnull
= open(_PATH_DEVNULL
, O_RDWR
);
434 fatal("Couldn't open %s: %m", _PATH_DEVNULL
);
435 while (fd_devnull
<= 2) {
438 fatal("Critical shortage of file descriptors: dup failed: %m");
443 * pppd sends signals to the whole process group, so it must always
444 * create a new one or it may kill the parent process and its siblings.
450 * Initialize system-dependent stuff.
455 pppdb
= tdb_open(_PATH_PPPDB
, 0, 0, O_RDWR
|O_CREAT
, 0644);
457 slprintf(db_key
, sizeof(db_key
), "pppd%d", getpid());
460 warn("Warning: couldn't open ppp database %s", _PATH_PPPDB
);
462 warn("Warning: disabling multilink");
469 * Detach ourselves from the terminal, if required,
470 * and identify who is running us.
472 if (!nodetach
&& !updetach
)
477 if (pw
!= NULL
&& pw
->pw_name
!= NULL
)
482 syslog(LOG_NOTICE
, "pppd %s started by %s, uid %d", VERSION
, p
, uid
);
483 script_setenv("PPPLOGNAME", p
, 0);
486 script_setenv("DEVICE", devnam
, 1);
487 slprintf(numbuf
, sizeof(numbuf
), "%d", getpid());
488 script_setenv("PPPD_PID", numbuf
, 1);
492 create_linkpidfile(getpid());
497 * If we're doing dial-on-demand, set up the interface now.
501 * Open the loopback channel and set it up to be the ppp interface.
503 fd_loop
= open_ppp_loopback();
506 * Configure the interface and mark it up, etc.
515 bundle_terminating
= 0;
521 doing_callback
= do_callback
;
524 if (demand
&& !doing_callback
) {
526 * Don't do anything until we see some activity.
528 new_phase(PHASE_DORMANT
);
535 if (get_loop_output())
543 * Now we want to bring up the link.
546 info("Starting link");
550 gettimeofday(&start_time
, NULL
);
551 script_unsetenv("CONNECT_TIME");
552 script_unsetenv("BYTES_SENT");
553 script_unsetenv("BYTES_RCVD");
555 lcp_open(0); /* Start protocol */
557 while (phase
!= PHASE_DEAD
) {
561 lcp_close(0, "User request");
563 bundle_terminating
= 1;
564 if (phase
== PHASE_MASTER
)
565 mp_bundle_terminated();
568 if (phase
== PHASE_NETWORK
|| phase
== PHASE_RUNNING
) {
569 ccp_fsm
[0].flags
= OPT_RESTART
; /* clears OPT_SILENT */
570 (*ccp_protent
.open
)(0);
574 /* restore FSMs to original state */
577 if (!persist
|| asked_to_quit
|| (maxfail
> 0 && unsuccess
>= maxfail
))
582 t
= need_holdoff
? holdoff
: 0;
584 t
= (*holdoff_hook
)();
586 new_phase(PHASE_HOLDOFF
);
587 TIMEOUT(holdoff_end
, NULL
, t
);
591 new_phase(PHASE_DORMANT
); /* allow signal to end holdoff */
592 } while (phase
== PHASE_HOLDOFF
);
598 /* Wait for scripts to finish */
600 if (n_children
> 0) {
602 TIMEOUT(childwait_end
, NULL
, child_wait
);
604 struct subprocess
*chp
;
605 dbglog("Waiting for %d child processes...", n_children
);
606 for (chp
= children
; chp
!= NULL
; chp
= chp
->next
)
607 dbglog(" script %s, pid %d", chp
->prog
, chp
->pid
);
609 while (n_children
> 0 && !childwait_done
) {
611 if (kill_link
&& !childwait_done
)
621 * handle_events - wait for something to happen and respond to it.
628 kill_link
= open_ccp_flag
= 0;
629 if (sigsetjmp(sigjmp
, 1) == 0) {
630 sigprocmask(SIG_BLOCK
, &signals_handled
, NULL
);
631 if (got_sighup
|| got_sigterm
|| got_sigusr2
|| got_sigchld
) {
632 sigprocmask(SIG_UNBLOCK
, &signals_handled
, NULL
);
635 sigprocmask(SIG_UNBLOCK
, &signals_handled
, NULL
);
636 wait_input(timeleft(&timo
));
642 info("Hangup (SIGHUP)");
645 if (status
!= EXIT_HANGUP
)
646 status
= EXIT_USER_REQUEST
;
649 info("Terminating on signal %d", got_sigterm
);
653 status
= EXIT_USER_REQUEST
;
658 reap_kids(); /* Don't leave dead kids lying around */
667 * setup_signals - initialize signal handling.
675 * Compute mask of all interesting signals and install signal handlers
676 * for each. Only one signal handler may be active at a time. Therefore,
677 * all other signals should be masked when any handler is executing.
679 sigemptyset(&signals_handled
);
680 sigaddset(&signals_handled
, SIGHUP
);
681 sigaddset(&signals_handled
, SIGINT
);
682 sigaddset(&signals_handled
, SIGTERM
);
683 sigaddset(&signals_handled
, SIGCHLD
);
684 sigaddset(&signals_handled
, SIGUSR2
);
686 #define SIGNAL(s, handler) do { \
687 sa.sa_handler = handler; \
688 if (sigaction(s, &sa, NULL) < 0) \
689 fatal("Couldn't establish signal handler (%d): %m", s); \
692 sa
.sa_mask
= signals_handled
;
694 SIGNAL(SIGHUP
, hup
); /* Hangup */
695 SIGNAL(SIGINT
, term
); /* Interrupt */
696 SIGNAL(SIGTERM
, term
); /* Terminate */
697 SIGNAL(SIGCHLD
, chld
);
699 SIGNAL(SIGUSR1
, toggle_debug
); /* Toggle debug flag */
700 SIGNAL(SIGUSR2
, open_ccp
); /* Reopen CCP */
703 * Install a handler for other signals which would otherwise
704 * cause pppd to exit without cleaning up.
706 SIGNAL(SIGABRT
, bad_signal
);
707 SIGNAL(SIGALRM
, bad_signal
);
708 SIGNAL(SIGFPE
, bad_signal
);
709 SIGNAL(SIGILL
, bad_signal
);
710 SIGNAL(SIGPIPE
, bad_signal
);
711 SIGNAL(SIGQUIT
, bad_signal
);
712 SIGNAL(SIGSEGV
, bad_signal
);
714 SIGNAL(SIGBUS
, bad_signal
);
717 SIGNAL(SIGEMT
, bad_signal
);
720 SIGNAL(SIGPOLL
, bad_signal
);
723 SIGNAL(SIGPROF
, bad_signal
);
726 SIGNAL(SIGSYS
, bad_signal
);
729 SIGNAL(SIGTRAP
, bad_signal
);
732 SIGNAL(SIGVTALRM
, bad_signal
);
735 SIGNAL(SIGXCPU
, bad_signal
);
738 SIGNAL(SIGXFSZ
, bad_signal
);
742 * Apparently we can get a SIGPIPE when we call syslog, if
743 * syslogd has died and been restarted. Ignoring it seems
746 signal(SIGPIPE
, SIG_IGN
);
750 * set_ifunit - do things we need to do once we know which ppp
757 info("Using interface %s%d", PPP_DRV_NAME
, ifunit
);
758 slprintf(ifname
, sizeof(ifname
), "%s%d", PPP_DRV_NAME
, ifunit
);
759 script_setenv("IFNAME", ifname
, iskey
);
761 create_pidfile(getpid()); /* write pid to file */
762 create_linkpidfile(getpid());
767 * detach - detach us from the controlling terminal.
778 if (pipe(pipefd
) == -1)
779 pipefd
[0] = pipefd
[1] = -1;
780 if ((pid
= fork()) < 0) {
781 error("Couldn't detach (fork failed: %m)");
782 die(1); /* or just return? */
786 notify(pidchange
, pid
);
787 /* update pid files if they have been written already */
791 create_linkpidfile(pid
);
792 exit(0); /* parent dies */
800 slprintf(numbuf
, sizeof(numbuf
), "%d", getpid());
801 script_setenv("PPPD_PID", numbuf
, 1);
803 /* wait for parent to finish updating pid & lock files and die */
805 complete_read(pipefd
[0], numbuf
, 1);
810 * reopen_log - (re)open our connection to syslog.
815 openlog("pppd", LOG_PID
| LOG_NDELAY
, LOG_PPP
);
816 setlogmask(LOG_UPTO(LOG_INFO
));
820 * Create a file containing our process ID.
828 slprintf(pidfilename
, sizeof(pidfilename
), "%s%s.pid",
829 _PATH_VARRUN
, ifname
);
830 if ((pidfile
= fopen(pidfilename
, "w")) != NULL
) {
831 fprintf(pidfile
, "%d\n", pid
);
832 (void) fclose(pidfile
);
834 error("Failed to create pid file %s: %m", pidfilename
);
840 create_linkpidfile(pid
)
845 if (linkname
[0] == 0)
847 script_setenv("LINKNAME", linkname
, 1);
848 slprintf(linkpidfile
, sizeof(linkpidfile
), "%sppp-%s.pid",
849 _PATH_VARRUN
, linkname
);
850 if ((pidfile
= fopen(linkpidfile
, "w")) != NULL
) {
851 fprintf(pidfile
, "%d\n", pid
);
853 fprintf(pidfile
, "%s\n", ifname
);
854 (void) fclose(pidfile
);
856 error("Failed to create pid file %s: %m", linkpidfile
);
862 * remove_pidfile - remove our pid files
864 void remove_pidfiles()
866 if (pidfilename
[0] != 0 && unlink(pidfilename
) < 0 && errno
!= ENOENT
)
867 warn("unable to delete pid file %s: %m", pidfilename
);
869 if (linkpidfile
[0] != 0 && unlink(linkpidfile
) < 0 && errno
!= ENOENT
)
870 warn("unable to delete pid file %s: %m", linkpidfile
);
875 * holdoff_end - called via a timeout when the holdoff period ends.
881 new_phase(PHASE_DORMANT
);
884 /* List of protocol names, to make our messages a little more informative. */
885 struct protocol_list
{
888 } protocol_list
[] = {
891 { 0x23, "OSI Network Layer" },
892 { 0x25, "Xerox NS IDP" },
893 { 0x27, "DECnet Phase IV" },
895 { 0x29, "Appletalk" },
896 { 0x2b, "Novell IPX" },
897 { 0x2d, "VJ compressed TCP/IP" },
898 { 0x2f, "VJ uncompressed TCP/IP" },
899 { 0x31, "Bridging PDU" },
901 { 0x33, "Stream Protocol ST-II" },
902 { 0x35, "Banyan Vines" },
903 { 0x39, "AppleTalk EDDP" },
904 { 0x3b, "AppleTalk SmartBuffered" },
905 { 0x3d, "Multi-Link" },
906 { 0x3f, "NETBIOS Framing" },
907 { 0x41, "Cisco Systems" },
908 { 0x43, "Ascom Timeplex" },
909 { 0x45, "Fujitsu Link Backup and Load Balancing (LBLB)" },
910 { 0x47, "DCA Remote Lan" },
911 { 0x49, "Serial Data Transport Protocol (PPP-SDTP)" },
912 { 0x4b, "SNA over 802.2" },
915 { 0x4f, "IP6 Header Compression" },
917 { 0x51, "KNX Bridging Data" },
919 { 0x53, "Encryption" },
920 { 0x55, "Individual Link Encryption" },
922 { 0x59, "PPP Muxing" },
923 { 0x5b, "Vendor-Specific Network Protocol" },
924 { 0x61, "RTP IPHC Full Header" },
925 { 0x63, "RTP IPHC Compressed TCP" },
926 { 0x65, "RTP IPHC Compressed non-TCP" },
927 { 0x67, "RTP IPHC Compressed UDP 8" },
928 { 0x69, "RTP IPHC Compressed RTP 8" },
930 { 0x6f, "Stampede Bridging" },
932 { 0xc1, "NTCITS IPI" },
934 { 0xfb, "single-link compression" },
935 { 0xfd, "Compressed Datagram" },
936 { 0x0201, "802.1d Hello Packets" },
938 { 0x0203, "IBM Source Routing BPDU" },
939 { 0x0205, "DEC LANBridge100 Spanning Tree" },
940 { 0x0207, "Cisco Discovery Protocol" },
941 { 0x0209, "Netcs Twin Routing" },
942 { 0x020b, "STP - Scheduled Transfer Protocol" },
943 { 0x020d, "EDP - Extreme Discovery Protocol" },
944 { 0x0211, "Optical Supervisory Channel Protocol" },
945 { 0x0213, "Optical Supervisory Channel Protocol" },
946 { 0x0231, "Luxcom" },
947 { 0x0233, "Sigma Network Systems" },
948 { 0x0235, "Apple Client Server Protocol" },
950 { 0x0281, "MPLS Unicast" },
951 { 0x0283, "MPLS Multicast" },
953 { 0x0285, "IEEE p1284.4 standard - data packets" },
954 { 0x0287, "ETSI TETRA Network Protocol Type 1" },
956 { 0x0289, "Multichannel Flow Treatment Protocol" },
957 { 0x2063, "RTP IPHC Compressed TCP No Delta" },
958 { 0x2065, "RTP IPHC Context State" },
959 { 0x2067, "RTP IPHC Compressed UDP 16" },
960 { 0x2069, "RTP IPHC Compressed RTP 16" },
962 { 0x4001, "Cray Communications Control Protocol" },
963 { 0x4003, "CDPD Mobile Network Registration Protocol" },
964 { 0x4005, "Expand accelerator protocol" },
965 { 0x4007, "ODSICP NCP" },
966 { 0x4009, "DOCSIS DLL" },
967 { 0x400B, "Cetacean Network Detection Protocol" },
968 { 0x4021, "Stacker LZS" },
969 { 0x4023, "RefTek Protocol" },
970 { 0x4025, "Fibre Channel" },
971 { 0x4027, "EMIT Protocols" },
973 { 0x405b, "Vendor-Specific Protocol (VSP)" },
974 { 0x8021, "Internet Protocol Control Protocol" },
976 { 0x8023, "OSI Network Layer Control Protocol" },
977 { 0x8025, "Xerox NS IDP Control Protocol" },
978 { 0x8027, "DECnet Phase IV Control Protocol" },
980 { 0x8029, "Appletalk Control Protocol" },
981 { 0x802b, "Novell IPX Control Protocol" },
983 { 0x8031, "Bridging NCP" },
984 { 0x8033, "Stream Protocol Control Protocol" },
985 { 0x8035, "Banyan Vines Control Protocol" },
987 { 0x803d, "Multi-Link Control Protocol" },
989 { 0x803f, "NETBIOS Framing Control Protocol" },
990 { 0x8041, "Cisco Systems Control Protocol" },
991 { 0x8043, "Ascom Timeplex" },
992 { 0x8045, "Fujitsu LBLB Control Protocol" },
993 { 0x8047, "DCA Remote Lan Network Control Protocol (RLNCP)" },
994 { 0x8049, "Serial Data Control Protocol (PPP-SDCP)" },
995 { 0x804b, "SNA over 802.2 Control Protocol" },
996 { 0x804d, "SNA Control Protocol" },
998 { 0x804f, "IP6 Header Compression Control Protocol" },
1000 { 0x8051, "KNX Bridging Control Protocol" },
1002 { 0x8053, "Encryption Control Protocol" },
1003 { 0x8055, "Individual Link Encryption Control Protocol" },
1004 { 0x8057, "IPv6 Control Protocol" },
1005 { 0x8059, "PPP Muxing Control Protocol" },
1006 { 0x805b, "Vendor-Specific Network Control Protocol (VSNCP)" },
1008 { 0x806f, "Stampede Bridging Control Protocol" },
1009 { 0x8073, "MP+ Control Protocol" },
1010 { 0x80c1, "NTCITS IPI Control Protocol" },
1012 { 0x80fb, "Single Link Compression Control Protocol" },
1013 { 0x80fd, "Compression Control Protocol" },
1015 { 0x8207, "Cisco Discovery Protocol Control" },
1016 { 0x8209, "Netcs Twin Routing" },
1017 { 0x820b, "STP - Control Protocol" },
1018 { 0x820d, "EDPCP - Extreme Discovery Protocol Ctrl Prtcl" },
1019 { 0x8235, "Apple Client Server Protocol Control" },
1020 { 0x8281, "MPLSCP" },
1021 { 0x8285, "IEEE p1284.4 standard - Protocol Control" },
1022 { 0x8287, "ETSI TETRA TNP1 Control Protocol" },
1024 { 0x8289, "Multichannel Flow Treatment Protocol" },
1025 { 0xc021, "Link Control Protocol" },
1026 { 0xc023, "Password Authentication Protocol" },
1027 { 0xc025, "Link Quality Report" },
1029 { 0xc027, "Shiva Password Authentication Protocol" },
1030 { 0xc029, "CallBack Control Protocol (CBCP)" },
1031 { 0xc02b, "BACP Bandwidth Allocation Control Protocol" },
1034 { 0xc05b, "Vendor-Specific Authentication Protocol (VSAP)" },
1035 { 0xc081, "Container Control Protocol" },
1036 { 0xc223, "Challenge Handshake Authentication Protocol" },
1037 { 0xc225, "RSA Authentication Protocol" },
1038 { 0xc227, "Extensible Authentication Protocol" },
1040 { 0xc229, "Mitsubishi Security Info Exch Ptcl (SIEP)" },
1041 { 0xc26f, "Stampede Bridging Authorization Protocol" },
1042 { 0xc281, "Proprietary Authentication Protocol" },
1043 { 0xc283, "Proprietary Authentication Protocol" },
1044 { 0xc481, "Proprietary Node ID Authentication Protocol" },
1050 * protocol_name - find a name for a PPP protocol.
1053 protocol_name(proto
)
1056 struct protocol_list
*lp
;
1058 for (lp
= protocol_list
; lp
->proto
!= 0; ++lp
)
1059 if (proto
== lp
->proto
)
1065 * get_input - called when incoming data is available.
1073 struct protent
*protp
;
1075 p
= inpacket_buf
; /* point to beginning of packet buffer */
1077 len
= read_packet(inpacket_buf
);
1082 if (bundle_eof
&& multilink_master
) {
1083 notice("Last channel has disconnected");
1084 mp_bundle_terminated();
1087 notice("Modem hangup");
1089 status
= EXIT_HANGUP
;
1090 lcp_lowerdown(0); /* serial link is no longer available */
1095 if (len
< PPP_HDRLEN
) {
1096 dbglog("received short packet:%.*B", len
, p
);
1100 dump_packet("rcvd", p
, len
);
1101 if (snoop_recv_hook
) snoop_recv_hook(p
, len
);
1103 p
+= 2; /* Skip address and control */
1104 GETSHORT(protocol
, p
);
1108 * Toss all non-LCP packets unless LCP is OPEN.
1110 if (protocol
!= PPP_LCP
&& lcp_fsm
[0].state
!= OPENED
) {
1111 dbglog("Discarded non-LCP packet when LCP not open");
1116 * Until we get past the authentication phase, toss all packets
1117 * except LCP, LQR and authentication packets.
1119 if (phase
<= PHASE_AUTHENTICATE
1120 && !(protocol
== PPP_LCP
|| protocol
== PPP_LQR
1121 || protocol
== PPP_PAP
|| protocol
== PPP_CHAP
||
1122 protocol
== PPP_EAP
)) {
1123 dbglog("discarding proto 0x%x in phase %d",
1129 * Upcall the proper protocol input routine.
1131 for (i
= 0; (protp
= protocols
[i
]) != NULL
; ++i
) {
1132 if (protp
->protocol
== protocol
&& protp
->enabled_flag
) {
1133 (*protp
->input
)(0, p
, len
);
1136 if (protocol
== (protp
->protocol
& ~0x8000) && protp
->enabled_flag
1137 && protp
->datainput
!= NULL
) {
1138 (*protp
->datainput
)(0, p
, len
);
1144 const char *pname
= protocol_name(protocol
);
1146 warn("Unsupported protocol '%s' (0x%x) received", pname
, protocol
);
1148 warn("Unsupported protocol 0x%x received", protocol
);
1150 lcp_sprotrej(0, p
- PPP_HDRLEN
, len
+ PPP_HDRLEN
);
1154 * ppp_send_config - configure the transmit-side characteristics of
1155 * the ppp interface. Returns -1, indicating an error, if the channel
1156 * send_config procedure called error() (or incremented error_count
1157 * itself), otherwise 0.
1160 ppp_send_config(unit
, mtu
, accm
, pcomp
, accomp
)
1167 if (the_channel
->send_config
== NULL
)
1170 (*the_channel
->send_config
)(mtu
, accm
, pcomp
, accomp
);
1171 return (error_count
!= errs
)? -1: 0;
1175 * ppp_recv_config - configure the receive-side characteristics of
1176 * the ppp interface. Returns -1, indicating an error, if the channel
1177 * recv_config procedure called error() (or incremented error_count
1178 * itself), otherwise 0.
1181 ppp_recv_config(unit
, mru
, accm
, pcomp
, accomp
)
1188 if (the_channel
->recv_config
== NULL
)
1191 (*the_channel
->recv_config
)(mru
, accm
, pcomp
, accomp
);
1192 return (error_count
!= errs
)? -1: 0;
1196 * new_phase - signal the start of a new phase of pppd's operation.
1204 (*new_phase_hook
)(p
);
1205 notify(phasechange
, p
);
1209 * die - clean up state and exit with the specified status.
1215 if (!doing_multilink
|| multilink_master
)
1218 notify(exitnotify
, status
);
1219 syslog(LOG_INFO
, "Exit.");
1224 * cleanup - restore anything which needs to be restored before we exit
1233 the_channel
->disestablish_ppp(devfd
);
1234 if (the_channel
->cleanup
)
1235 (*the_channel
->cleanup
)();
1249 * Print connect time and statistics.
1251 if (link_stats_valid
) {
1252 int t
= (link_connect_time
+ 5) / 6; /* 1/10ths of minutes */
1253 info("Connect time %d.%d minutes.", t
/10, t
%10);
1254 info("Sent %u bytes, received %u bytes.",
1255 link_stats
.bytes_out
, link_stats
.bytes_in
);
1256 link_stats_valid
= 0;
1261 * reset_link_stats - "reset" stats when link goes up.
1267 if (!get_ppp_stats(u
, &old_link_stats
))
1269 gettimeofday(&start_time
, NULL
);
1273 * update_link_stats - get stats at link termination.
1276 update_link_stats(u
)
1282 if (!get_ppp_stats(u
, &link_stats
)
1283 || gettimeofday(&now
, NULL
) < 0)
1285 link_connect_time
= now
.tv_sec
- start_time
.tv_sec
;
1286 link_stats_valid
= 1;
1288 link_stats
.bytes_in
-= old_link_stats
.bytes_in
;
1289 link_stats
.bytes_out
-= old_link_stats
.bytes_out
;
1290 link_stats
.pkts_in
-= old_link_stats
.pkts_in
;
1291 link_stats
.pkts_out
-= old_link_stats
.pkts_out
;
1293 slprintf(numbuf
, sizeof(numbuf
), "%u", link_connect_time
);
1294 script_setenv("CONNECT_TIME", numbuf
, 0);
1295 slprintf(numbuf
, sizeof(numbuf
), "%u", link_stats
.bytes_out
);
1296 script_setenv("BYTES_SENT", numbuf
, 0);
1297 slprintf(numbuf
, sizeof(numbuf
), "%u", link_stats
.bytes_in
);
1298 script_setenv("BYTES_RCVD", numbuf
, 0);
1303 struct timeval c_time
; /* time at which to call routine */
1304 void *c_arg
; /* argument to routine */
1305 void (*c_func
) __P((void *)); /* routine */
1306 struct callout
*c_next
;
1309 static struct callout
*callout
= NULL
; /* Callout list */
1310 static struct timeval timenow
; /* Current time */
1311 static long uptime_diff
= 0;
1312 static int uptime_diff_set
= 0;
1314 static void check_time(void)
1324 gettimeofday(&t
, NULL
);
1326 new_diff
= t
.tv_sec
- i
.uptime
;
1328 if (!uptime_diff_set
) {
1329 uptime_diff
= new_diff
;
1330 uptime_diff_set
= 1;
1334 if ((new_diff
- 5 > uptime_diff
) || (new_diff
+ 5 < uptime_diff
)) {
1335 /* system time has changed, update counters and timeouts */
1336 info("System time change detected.");
1337 start_time
.tv_sec
+= new_diff
- uptime_diff
;
1339 for (p
= callout
; p
!= NULL
; p
= p
->c_next
)
1340 p
->c_time
.tv_sec
+= new_diff
- uptime_diff
;
1342 uptime_diff
= new_diff
;
1346 * timeout - Schedule a timeout.
1349 timeout(func
, arg
, secs
, usecs
)
1350 void (*func
) __P((void *));
1354 struct callout
*newp
, *p
, **pp
;
1359 if ((newp
= (struct callout
*) malloc(sizeof(struct callout
))) == NULL
)
1360 fatal("Out of memory in timeout()!");
1362 newp
->c_func
= func
;
1363 gettimeofday(&timenow
, NULL
);
1364 newp
->c_time
.tv_sec
= timenow
.tv_sec
+ secs
;
1365 newp
->c_time
.tv_usec
= timenow
.tv_usec
+ usecs
;
1366 if (newp
->c_time
.tv_usec
>= 1000000) {
1367 newp
->c_time
.tv_sec
+= newp
->c_time
.tv_usec
/ 1000000;
1368 newp
->c_time
.tv_usec
%= 1000000;
1372 * Find correct place and link it in.
1374 for (pp
= &callout
; (p
= *pp
); pp
= &p
->c_next
)
1375 if (newp
->c_time
.tv_sec
< p
->c_time
.tv_sec
1376 || (newp
->c_time
.tv_sec
== p
->c_time
.tv_sec
1377 && newp
->c_time
.tv_usec
< p
->c_time
.tv_usec
))
1385 * untimeout - Unschedule a timeout.
1388 untimeout(func
, arg
)
1389 void (*func
) __P((void *));
1392 struct callout
**copp
, *freep
;
1395 * Find first matching timeout and remove it from the list.
1397 for (copp
= &callout
; (freep
= *copp
); copp
= &freep
->c_next
)
1398 if (freep
->c_func
== func
&& freep
->c_arg
== arg
) {
1399 *copp
= freep
->c_next
;
1400 free((char *) freep
);
1407 * calltimeout - Call any timeout routines which are now due.
1416 while (callout
!= NULL
) {
1419 if (gettimeofday(&timenow
, NULL
) < 0)
1420 fatal("Failed to get time of day: %m");
1421 if (!(p
->c_time
.tv_sec
< timenow
.tv_sec
1422 || (p
->c_time
.tv_sec
== timenow
.tv_sec
1423 && p
->c_time
.tv_usec
<= timenow
.tv_usec
)))
1424 break; /* no, it's not time yet */
1426 callout
= p
->c_next
;
1427 (*p
->c_func
)(p
->c_arg
);
1435 * timeleft - return the length of time until the next timeout is due.
1437 static struct timeval
*
1439 struct timeval
*tvp
;
1441 if (callout
== NULL
)
1446 gettimeofday(&timenow
, NULL
);
1447 tvp
->tv_sec
= callout
->c_time
.tv_sec
- timenow
.tv_sec
;
1448 tvp
->tv_usec
= callout
->c_time
.tv_usec
- timenow
.tv_usec
;
1449 if (tvp
->tv_usec
< 0) {
1450 tvp
->tv_usec
+= 1000000;
1453 if (tvp
->tv_sec
< 0)
1454 tvp
->tv_sec
= tvp
->tv_usec
= 0;
1461 * kill_my_pg - send a signal to our process group, and ignore it ourselves.
1462 * We assume that sig is currently blocked.
1468 struct sigaction act
, oldact
;
1469 struct subprocess
*chp
;
1473 * There might be other things in our process group that we
1474 * didn't start that would get hit if we did a kill(0), so
1475 * just send the signal individually to our children.
1477 for (chp
= children
; chp
!= NULL
; chp
= chp
->next
)
1479 kill(chp
->pid
, sig
);
1483 /* We've done a setsid(), so we can just use a kill(0) */
1484 sigemptyset(&act
.sa_mask
); /* unnecessary in fact */
1485 act
.sa_handler
= SIG_IGN
;
1489 * The kill() above made the signal pending for us, as well as
1490 * the rest of our process group, but we don't want it delivered
1491 * to us. It is blocked at the moment. Setting it to be ignored
1492 * will cause the pending signal to be discarded. If we did the
1493 * kill() after setting the signal to be ignored, it is unspecified
1494 * (by POSIX) whether the signal is immediately discarded or left
1495 * pending, and in fact Linux would leave it pending, and so it
1496 * would be delivered after the current signal handler exits,
1497 * leading to an infinite loop.
1499 sigaction(sig
, &act
, &oldact
);
1500 sigaction(sig
, &oldact
, NULL
);
1505 * hup - Catch SIGHUP signal.
1507 * Indicates that the physical layer has been disconnected.
1508 * We don't rely on this indication; if the user has sent this
1509 * signal, we just take the link down.
1515 /* can't log a message here, it can deadlock */
1518 /* Send the signal to the [dis]connector process(es) also */
1520 notify(sigreceived
, sig
);
1522 siglongjmp(sigjmp
, 1);
1527 * term - Catch SIGTERM signal and SIGINT signal (^C/del).
1529 * Indicates that we should initiate a graceful disconnect and exit.
1536 /* can't log a message here, it can deadlock */
1539 /* Send the signal to the [dis]connector process(es) also */
1541 notify(sigreceived
, sig
);
1543 siglongjmp(sigjmp
, 1);
1548 * chld - Catch SIGCHLD signal.
1549 * Sets a flag so we will call reap_kids in the mainline.
1557 siglongjmp(sigjmp
, 1);
1562 * toggle_debug - Catch SIGUSR1 signal.
1564 * Toggle debug flag.
1573 setlogmask(LOG_UPTO(LOG_DEBUG
));
1575 setlogmask(LOG_UPTO(LOG_WARNING
));
1581 * open_ccp - Catch SIGUSR2 signal.
1583 * Try to (re)negotiate compression.
1592 siglongjmp(sigjmp
, 1);
1597 * bad_signal - We've caught a fatal signal. Clean up state and exit.
1603 static int crashed
= 0;
1608 error("Fatal signal %d", sig
);
1610 kill_my_pg(SIGTERM
);
1611 notify(sigreceived
, sig
);
1616 * safe_fork - Create a child process. The child closes all the
1617 * file descriptors that we don't want to leak to a script.
1618 * The parent waits for the child to do this before returning.
1619 * This also arranges for the specified fds to be dup'd to
1620 * fds 0, 1, 2 in the child.
1623 safe_fork(int infd
, int outfd
, int errfd
)
1629 /* make sure fds 0, 1, 2 are occupied (probably not necessary) */
1630 while ((fd
= dup(fd_devnull
)) >= 0) {
1637 if (pipe(pipefd
) == -1)
1638 pipefd
[0] = pipefd
[1] = -1;
1641 error("fork failed: %m");
1647 /* this read() blocks until the close(pipefd[1]) below */
1648 complete_read(pipefd
[0], buf
, 1);
1653 /* Executing in the child */
1659 /* make sure infd, outfd and errfd won't get tromped on below */
1660 if (infd
== 1 || infd
== 2)
1662 if (outfd
== 0 || outfd
== 2)
1664 if (errfd
== 0 || errfd
== 1)
1669 /* dup the in, out, err fds to 0, 1, 2 */
1679 if (the_channel
->close
)
1680 (*the_channel
->close
)();
1682 close(devfd
); /* some plugins don't have a close function */
1692 notify(fork_notifier
, 0);
1694 /* this close unblocks the read() call above in the parent */
1701 * device_script - run a program to talk to the specified fds
1702 * (e.g. to run the connector or disconnector script).
1703 * stderr gets connected to the log fd or to the _PATH_CONNERRS file.
1706 device_script(program
, in
, out
, dont_wait
)
1718 errfd
= open(_PATH_CONNERRS
, O_WRONLY
| O_APPEND
| O_CREAT
, 0644);
1721 pid
= safe_fork(in
, out
, errfd
);
1723 if (pid
!= 0 && log_to_fd
< 0)
1728 error("Failed to create child process: %m");
1733 record_child(pid
, program
, NULL
, NULL
, 1);
1736 while (waitpid(pid
, &status
, 0) < 0) {
1739 fatal("error waiting for (dis)connection process: %m");
1741 forget_child(pid
, status
);
1744 return (status
== 0 ? 0 : -1);
1747 /* here we are executing in the child */
1751 if (getuid() != uid
) {
1752 fprintf(stderr
, "pppd: setuid failed\n");
1755 execl("/bin/sh", "sh", "-c", program
, (char *)0);
1756 perror("pppd: could not exec /bin/sh");
1763 * run_program - execute a program with given arguments,
1764 * but don't wait for it unless wait is non-zero.
1765 * If the program can't be executed, logs an error unless
1766 * must_exist is 0 and the program file doesn't exist.
1767 * Returns -1 if it couldn't fork, 0 if the file doesn't exist
1768 * or isn't an executable plain file, or the process ID of the child.
1769 * If done != NULL, (*done)(arg) will be called later (within
1770 * reap_kids) iff the return value is > 0.
1773 run_program(prog
, args
, must_exist
, done
, arg
, wait
)
1777 void (*done
) __P((void *));
1785 * First check if the file exists and is executable.
1786 * We don't use access() because that would use the
1787 * real user-id, which might not be root, and the script
1788 * might be accessible only to root.
1791 if (stat(prog
, &sbuf
) < 0 || !S_ISREG(sbuf
.st_mode
)
1792 || (sbuf
.st_mode
& (S_IXUSR
|S_IXGRP
|S_IXOTH
)) == 0) {
1793 if (must_exist
|| errno
!= ENOENT
)
1794 warn("Can't execute %s: %m", prog
);
1798 pid
= safe_fork(fd_devnull
, fd_devnull
, fd_devnull
);
1800 error("Failed to create child process for %s: %m", prog
);
1805 dbglog("Script %s started (pid %d)", prog
, pid
);
1806 record_child(pid
, prog
, done
, arg
, 0);
1808 while (waitpid(pid
, &status
, 0) < 0) {
1811 fatal("error waiting for script %s: %m", prog
);
1813 forget_child(pid
, status
);
1818 /* Leave the current location */
1819 (void) setsid(); /* No controlling tty. */
1820 (void) umask (S_IRWXG
|S_IRWXO
);
1821 (void) chdir ("/"); /* no current directory. */
1822 setuid(0); /* set real UID = root */
1826 /* Force the priority back to zero if pppd is running higher. */
1827 if (setpriority (PRIO_PROCESS
, 0, 0) < 0)
1828 warn("can't reset priority to 0: %m");
1831 /* run the program */
1832 execve(prog
, args
, script_env
);
1833 if (must_exist
|| errno
!= ENOENT
) {
1834 /* have to reopen the log, there's nowhere else
1835 for the message to go. */
1837 syslog(LOG_ERR
, "Can't execute %s: %m", prog
);
1845 * record_child - add a child process to the list for reap_kids
1849 record_child(pid
, prog
, done
, arg
, killable
)
1852 void (*done
) __P((void *));
1856 struct subprocess
*chp
;
1860 chp
= (struct subprocess
*) malloc(sizeof(struct subprocess
));
1862 warn("losing track of %s process", prog
);
1868 chp
->next
= children
;
1869 chp
->killable
= killable
;
1875 * childwait_end - we got fed up waiting for the child processes to
1876 * exit, send them all a SIGTERM.
1882 struct subprocess
*chp
;
1884 for (chp
= children
; chp
!= NULL
; chp
= chp
->next
) {
1886 dbglog("sending SIGTERM to process %d", chp
->pid
);
1887 kill(chp
->pid
, SIGTERM
);
1893 * forget_child - clean up after a dead child
1896 forget_child(pid
, status
)
1899 struct subprocess
*chp
, **prevp
;
1901 for (prevp
= &children
; (chp
= *prevp
) != NULL
; prevp
= &chp
->next
) {
1902 if (chp
->pid
== pid
) {
1908 if (WIFSIGNALED(status
)) {
1909 warn("Child process %s (pid %d) terminated with signal %d",
1910 (chp
? chp
->prog
: "??"), pid
, WTERMSIG(status
));
1912 dbglog("Script %s finished (pid %d), status = 0x%x",
1913 (chp
? chp
->prog
: "??"), pid
,
1914 WIFEXITED(status
) ? WEXITSTATUS(status
) : status
);
1915 if (chp
&& chp
->done
)
1916 (*chp
->done
)(chp
->arg
);
1922 * reap_kids - get status from any dead child processes,
1923 * and log a message for abnormal terminations.
1930 if (n_children
== 0)
1932 while ((pid
= waitpid(-1, &status
, WNOHANG
)) != -1 && pid
!= 0) {
1933 forget_child(pid
, status
);
1936 if (errno
== ECHILD
)
1939 error("Error waiting for child process: %m");
1945 * add_notifier - add a new function to be called when something happens.
1948 add_notifier(notif
, func
, arg
)
1949 struct notifier
**notif
;
1953 struct notifier
*np
;
1955 np
= malloc(sizeof(struct notifier
));
1957 novm("notifier struct");
1965 * remove_notifier - remove a function from the list of things to
1966 * be called when something happens.
1969 remove_notifier(notif
, func
, arg
)
1970 struct notifier
**notif
;
1974 struct notifier
*np
;
1976 for (; (np
= *notif
) != 0; notif
= &np
->next
) {
1977 if (np
->func
== func
&& np
->arg
== arg
) {
1986 * notify - call a set of functions registered with add_notifier.
1990 struct notifier
*notif
;
1993 struct notifier
*np
;
1995 while ((np
= notif
) != 0) {
1997 (*np
->func
)(np
->arg
, val
);
2002 * novm - log an error message saying we ran out of memory, and die.
2008 fatal("Virtual memory exhausted allocating %s\n", msg
);
2012 * script_setenv - set an environment variable value to be used
2013 * for scripts that we run (e.g. ip-up, auth-up, etc.)
2016 script_setenv(var
, value
, iskey
)
2020 size_t varl
= strlen(var
);
2021 size_t vl
= varl
+ strlen(value
) + 2;
2023 char *p
, *newstring
;
2025 newstring
= (char *) malloc(vl
+1);
2028 *newstring
++ = iskey
;
2029 slprintf(newstring
, vl
, "%s=%s", var
, value
);
2031 /* check if this variable is already set */
2032 if (script_env
!= 0) {
2033 for (i
= 0; (p
= script_env
[i
]) != 0; ++i
) {
2034 if (strncmp(p
, var
, varl
) == 0 && p
[varl
] == '=') {
2036 if (p
[-1] && pppdb
!= NULL
)
2040 script_env
[i
] = newstring
;
2042 if (pppdb
!= NULL
) {
2044 add_db_key(newstring
);
2052 /* no space allocated for script env. ptrs. yet */
2054 script_env
= (char **) malloc(16 * sizeof(char *));
2055 if (script_env
== 0)
2060 /* reallocate script_env with more space if needed */
2061 if (i
+ 1 >= s_env_nalloc
) {
2063 char **newenv
= (char **) realloc((void *)script_env
,
2064 new_n
* sizeof(char *));
2067 script_env
= newenv
;
2068 s_env_nalloc
= new_n
;
2071 script_env
[i
] = newstring
;
2072 script_env
[i
+1] = 0;
2075 if (pppdb
!= NULL
) {
2077 add_db_key(newstring
);
2084 * script_unsetenv - remove a variable from the environment
2088 script_unsetenv(var
)
2091 int vl
= strlen(var
);
2095 if (script_env
== 0)
2097 for (i
= 0; (p
= script_env
[i
]) != 0; ++i
) {
2098 if (strncmp(p
, var
, vl
) == 0 && p
[vl
] == '=') {
2100 if (p
[-1] && pppdb
!= NULL
)
2104 while ((script_env
[i
] = script_env
[i
+1]) != 0)
2116 * Any arbitrary string used as a key for locking the database.
2117 * It doesn't matter what it is as long as all pppds use the same string.
2119 #define PPPD_LOCK_KEY "pppd lock"
2122 * lock_db - get an exclusive lock on the TDB database.
2123 * Used to ensure atomicity of various lookup/modify operations.
2130 key
.dptr
= PPPD_LOCK_KEY
;
2131 key
.dsize
= strlen(key
.dptr
);
2132 tdb_chainlock(pppdb
, key
);
2137 * unlock_db - remove the exclusive lock obtained by lock_db.
2144 key
.dptr
= PPPD_LOCK_KEY
;
2145 key
.dsize
= strlen(key
.dptr
);
2146 tdb_chainunlock(pppdb
, key
);
2152 * update_db_entry - update our entry in the database.
2161 if (script_env
== NULL
)
2164 for (i
= 0; (p
= script_env
[i
]) != 0; ++i
)
2165 vlen
+= strlen(p
) + 1;
2166 vbuf
= malloc(vlen
+ 1);
2168 novm("database entry");
2170 for (i
= 0; (p
= script_env
[i
]) != 0; ++i
)
2171 q
+= slprintf(q
, vbuf
+ vlen
- q
, "%s;", p
);
2174 key
.dsize
= strlen(db_key
);
2177 if (tdb_store(pppdb
, key
, dbuf
, TDB_REPLACE
))
2178 error("tdb_store failed: %s", tdb_errorstr(pppdb
));
2186 * add_db_key - add a key that we can use to look up our database entry.
2194 key
.dptr
= (char *) str
;
2195 key
.dsize
= strlen(str
);
2197 dbuf
.dsize
= strlen(db_key
);
2198 if (tdb_store(pppdb
, key
, dbuf
, TDB_REPLACE
))
2199 error("tdb_store key failed: %s", tdb_errorstr(pppdb
));
2203 * delete_db_key - delete a key for looking up our database entry.
2211 key
.dptr
= (char *) str
;
2212 key
.dsize
= strlen(str
);
2213 tdb_delete(pppdb
, key
);
2217 * cleanup_db - delete all the entries we put in the database.
2227 key
.dsize
= strlen(db_key
);
2228 tdb_delete(pppdb
, key
);
2229 for (i
= 0; (p
= script_env
[i
]) != 0; ++i
)
2233 #endif /* USE_TDB */