2 * sys-linux.c - System-dependent procedures for setting up
3 * PPP interfaces on Linux systems
5 * Copyright (c) 1989 Carnegie Mellon University.
8 * Redistribution and use in source and binary forms are permitted
9 * provided that the above copyright notice and this paragraph are
10 * duplicated in all such forms and that any documentation,
11 * advertising materials, and other materials related to such
12 * distribution and use acknowledge that the software was developed
13 * by Carnegie Mellon University. The name of the
14 * University may not be used to endorse or promote products derived
15 * from this software without specific prior written permission.
16 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
18 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
21 #include <sys/ioctl.h>
22 #include <sys/types.h>
23 #include <sys/socket.h>
25 #include <sys/errno.h>
28 #include <sys/utsname.h>
29 #include <sys/sysmacros.h>
45 /* This is in netdevice.h. However, this compile will fail miserably if
46 you attempt to include netdevice.h because it has so many references
47 to __memcpy functions which it should not attempt to do. So, since I
48 really don't use it, but it must be defined, define it now. */
51 #define MAX_ADDR_LEN 7
55 #include <asm/types.h> /* glibc 2 conflicts with linux/types.h */
57 #include <net/if_arp.h>
58 #include <net/route.h>
59 #include <netinet/if_ether.h>
61 #include <linux/types.h>
63 #include <linux/if_arp.h>
64 #include <linux/route.h>
65 #include <linux/if_ether.h>
67 #include <netinet/in.h>
68 #include <arpa/inet.h>
70 #include <linux/ppp_defs.h>
71 #include <linux/if_ppp.h>
79 #if __GLIBC__ >= 2 && \
80 !(defined(__powerpc__) && __GLIBC__ == 2 && __GLIBC_MINOR__ == 0)
81 #include <netipx/ipx.h>
83 #include <linux/ipx.h>
85 #endif /* IPX_CHANGE */
89 #include <linux/filter.h>
90 #endif /* PPP_FILTER */
93 #include <sys/locks.h>
99 * This is in linux/include/net/ipv6.h.
103 struct in6_addr ifr6_addr;
104 __u32 ifr6_prefixlen;
105 unsigned int ifr6_ifindex;
109 #define IN6_LLADDR_FROM_EUI64(sin6, eui64) do { \
110 memset(&sin6.s6_addr, 0, sizeof(struct in6_addr)); \
111 sin6.s6_addr16[0] = htons(0xfe80); \
112 eui64_copy(eui64, sin6.s6_addr32[2]); \
117 /* We can get an EIO error on an ioctl if the modem has hung up */
118 #define ok_error(num) ((num)==EIO)
120 static int tty_disc = N_TTY; /* The TTY discipline */
121 static int ppp_disc = N_PPP; /* The PPP discpline */
122 static int initfdflags = -1; /* Initial file descriptor flags for fd */
123 static int ppp_fd = -1; /* fd which is set to PPP discipline */
124 static int sock_fd = -1; /* socket for doing interface ioctls */
125 static int slave_fd = -1;
126 static int master_fd = -1;
128 static int sock6_fd = -1;
130 static int ppp_dev_fd = -1; /* fd for /dev/ppp (new style driver) */
131 static int chindex; /* channel index (new style driver) */
133 static fd_set in_fds; /* set of fds that wait_input waits for */
134 static int max_in_fd; /* highest fd set in in_fds */
136 static int has_proxy_arp = 0;
137 static int driver_version = 0;
138 static int driver_modification = 0;
139 static int driver_patch = 0;
140 static int driver_is_old = 0;
141 static int restore_term = 0; /* 1 => we've munged the terminal */
142 static struct termios inittermios; /* Initial TTY termios */
144 static int new_style_driver = 0;
146 static char loop_name[20];
147 static unsigned char inbuf[512]; /* buffer for chars read from loopback */
149 static int if_is_up; /* Interface has been marked up */
150 static u_int32_t default_route_gateway; /* Gateway for default route added */
151 static u_int32_t proxy_arp_addr; /* Addr for proxy arp entry added */
152 static char proxy_arp_dev[16]; /* Device for proxy arp entry */
153 static u_int32_t our_old_addr; /* for detecting address changes */
154 static int dynaddr_set; /* 1 if ip_dynaddr set */
155 static int looped; /* 1 if using loop */
156 static int link_mtu; /* mtu for the link (not bundle) */
158 static struct utsname utsname; /* for the kernel version */
159 static int kernel_version;
160 #define KVERSION(j,n,p) ((j)*1000000 + (n)*1000 + (p))
164 #define FLAGS_GOOD (IFF_UP | IFF_BROADCAST)
165 #define FLAGS_MASK (IFF_UP | IFF_BROADCAST | \
166 IFF_POINTOPOINT | IFF_LOOPBACK | IFF_NOARP)
168 #define SIN_ADDR(x) (((struct sockaddr_in *) (&(x)))->sin_addr.s_addr)
170 /* Prototypes for procedures local to this file. */
171 static int get_flags (int fd);
172 static void set_flags (int fd, int flags);
173 static int translate_speed (int bps);
174 static int baud_rate_of (int speed);
175 static void close_route_table (void);
176 static int open_route_table (void);
177 static int read_route_table (struct rtentry *rt);
178 static int defaultroute_exists (struct rtentry *rt);
179 static int get_ether_addr (u_int32_t ipaddr, struct sockaddr *hwaddr,
180 char *name, int namelen);
181 static void decode_version (char *buf, int *version, int *mod, int *patch);
182 static int set_kdebugflag(int level);
183 static int ppp_registered(void);
184 static int make_ppp_unit(void);
185 static void restore_loop(void); /* Transfer ppp unit back to loopback */
187 extern u_char inpacket_buf[]; /* borrowed from main.c */
190 * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
194 #define SET_SA_FAMILY(addr, family) \
195 memset ((char *) &(addr), '\0', sizeof(addr)); \
196 addr.sa_family = (family);
199 * Determine if the PPP connection should still be present.
204 /* new_fd is the fd of a tty */
205 static void set_ppp_fd (int new_fd)
207 SYSDEBUG ((LOG_DEBUG, "setting ppp_fd to %d\n", new_fd));
209 if (!new_style_driver)
213 static int still_ppp(void)
215 if (new_style_driver)
216 return !hungup && ppp_fd >= 0;
217 if (!hungup || ppp_fd == slave_fd)
220 set_ppp_fd(slave_fd);
226 /********************************************************************
228 * Functions to read and set the flags value in the device driver
231 static int get_flags (int fd)
235 if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &flags) < 0) {
236 if ( ok_error (errno) )
239 fatal("ioctl(PPPIOCGFLAGS): %m");
242 SYSDEBUG ((LOG_DEBUG, "get flags = %x\n", flags));
246 /********************************************************************/
248 static void set_flags (int fd, int flags)
250 SYSDEBUG ((LOG_DEBUG, "set flags = %x\n", flags));
252 if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &flags) < 0) {
253 if (! ok_error (errno) )
254 fatal("ioctl(PPPIOCSFLAGS, %x): %m", flags, errno);
258 /********************************************************************
260 * sys_init - System-dependent initialization.
267 if (new_style_driver) {
268 ppp_dev_fd = open("/dev/ppp", O_RDWR);
270 fatal("Couldn't open /dev/ppp: %m");
271 flags = fcntl(ppp_dev_fd, F_GETFL);
273 || fcntl(ppp_dev_fd, F_SETFL, flags | O_NONBLOCK) == -1)
274 warn("Couldn't set /dev/ppp to nonblock: %m");
277 /* Get an internet socket for doing socket ioctls. */
278 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
280 fatal("Couldn't create IP socket: %m(%d)", errno);
283 sock6_fd = socket(AF_INET6, SOCK_DGRAM, 0);
285 sock6_fd = -errno; /* save errno for later */
292 /********************************************************************
294 * sys_cleanup - restore any system state we modified before exiting:
295 * mark the interface down, delete default route and/or proxy arp entry.
296 * This shouldn't call die() because it's called from die().
299 void sys_cleanup(void)
302 * Take down the device
309 * Delete any routes through the device.
311 if (default_route_gateway != 0)
312 cifdefaultroute(0, 0, default_route_gateway);
315 cifproxyarp(0, proxy_arp_addr);
318 /********************************************************************
320 * sys_close - Clean up in a child process before execing.
325 if (new_style_driver)
336 /********************************************************************
338 * set_kdebugflag - Define the debugging level for the kernel
341 static int set_kdebugflag (int requested_level)
343 if (new_style_driver && ifunit < 0)
345 if (ioctl(ppp_dev_fd, PPPIOCSDEBUG, &requested_level) < 0) {
346 if ( ! ok_error (errno) )
347 error("ioctl(PPPIOCSDEBUG): %m");
350 SYSDEBUG ((LOG_INFO, "set kernel debugging level to %d",
355 /********************************************************************
357 * tty_establish_ppp - Turn the serial port into a ppp interface.
360 int tty_establish_ppp (int tty_fd)
366 * Ensure that the tty device is in exclusive mode.
368 if (ioctl(tty_fd, TIOCEXCL, 0) < 0) {
369 if ( ! ok_error ( errno ))
370 warn("Couldn't make tty exclusive: %m");
373 * Demand mode - prime the old ppp device to relinquish the unit.
375 if (!new_style_driver && looped
376 && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0) {
377 error("ioctl(transfer ppp unit): %m");
381 * Set the current tty to the PPP discpline
385 #define N_SYNC_PPP 14
387 ppp_disc = (new_style_driver && sync_serial)? N_SYNC_PPP: N_PPP;
388 if (ioctl(tty_fd, TIOCSETD, &ppp_disc) < 0) {
389 if ( ! ok_error (errno) ) {
390 error("Couldn't set tty to PPP discipline: %m");
395 if (new_style_driver) {
396 /* Open another instance of /dev/ppp and connect the channel to it */
399 if (ioctl(tty_fd, PPPIOCGCHAN, &chindex) == -1) {
400 error("Couldn't get channel number: %m");
403 dbglog("using channel %d", chindex);
404 fd = open("/dev/ppp", O_RDWR);
406 error("Couldn't reopen /dev/ppp: %m");
409 if (ioctl(fd, PPPIOCATTCHAN, &chindex) < 0) {
410 error("Couldn't attach to channel %d: %m", chindex);
413 flags = fcntl(fd, F_GETFL);
414 if (flags == -1 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
415 warn("Couldn't set /dev/ppp (channel) to nonblock: %m");
420 if (!looped && !multilink) {
422 * Create a new PPP unit.
424 if (make_ppp_unit() < 0)
429 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) & ~SC_LOOP_TRAFFIC);
433 if (ioctl(fd, PPPIOCCONNECT, &ifunit) < 0) {
434 error("Couldn't attach to PPP unit %d: %m", ifunit);
441 * Old-style driver: find out which interface we were given.
444 if (ioctl(tty_fd, PPPIOCGUNIT, &x) < 0) {
445 if (ok_error (errno))
447 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
449 /* Check that we got the same unit again. */
450 if (looped && x != ifunit)
451 fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
455 * Fetch the initial file flags and reset blocking mode on the file.
457 initfdflags = fcntl(tty_fd, F_GETFL);
458 if (initfdflags == -1 ||
459 fcntl(tty_fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
460 if ( ! ok_error (errno))
461 warn("Couldn't set device to non-blocking mode: %m");
468 * Enable debug in the driver if requested.
471 set_kdebugflag (kdebugflag);
473 #define SC_RCVB (SC_RCV_B7_0 | SC_RCV_B7_1 | SC_RCV_EVNP | SC_RCV_ODDP)
474 #define SC_LOGB (SC_DEBUG | SC_LOG_INPKT | SC_LOG_OUTPKT | SC_LOG_RAWIN \
477 set_flags(ppp_fd, ((get_flags(ppp_fd) & ~(SC_RCVB | SC_LOGB))
478 | ((kdebugflag * SC_DEBUG) & SC_LOGB)));
480 SYSDEBUG ((LOG_NOTICE, "Using version %d.%d.%d of PPP driver",
481 driver_version, driver_modification, driver_patch));
488 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0 && !ok_error(errno))
489 warn("Couldn't reset tty to normal line discipline: %m");
493 /********************************************************************
495 * tty_disestablish_ppp - Restore the serial port to normal operation,
496 * and reconnect the ppp unit to the loopback if in demand mode.
497 * This shouldn't call die() because it's called from die().
500 void tty_disestablish_ppp(int tty_fd)
506 * Flush the tty output buffer so that the TIOCSETD doesn't hang.
508 if (tcflush(tty_fd, TCIOFLUSH) < 0)
509 warn("tcflush failed: %m");
511 * Restore the previous line discipline
513 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
514 if ( ! ok_error (errno))
515 error("ioctl(TIOCSETD, N_TTY): %m");
518 if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
519 if ( ! ok_error (errno))
520 warn("ioctl(TIOCNXCL): %m(%d)", errno);
523 /* Reset non-blocking mode on fd. */
524 if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0) {
525 if ( ! ok_error (errno))
526 warn("Couldn't restore device fd flags: %m");
531 if (new_style_driver) {
534 if (!looped && ifunit >= 0 && ioctl(ppp_dev_fd, PPPIOCDETACH) < 0)
535 error("Couldn't release PPP unit: %m");
537 remove_fd(ppp_dev_fd);
542 * make_ppp_unit - make a new ppp unit for ppp_dev_fd.
543 * Assumes new_style_driver.
545 static int make_ppp_unit()
550 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
551 if (x < 0 && req_unit >= 0 && errno == EEXIST) {
552 warn("Couldn't allocate PPP unit %d as it is already in use");
554 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
557 error("Couldn't create new ppp unit: %m");
562 * cfg_bundle - configure the existing bundle.
563 * Used in demand mode.
565 void cfg_bundle(int mrru, int mtru, int rssn, int tssn)
569 if (!new_style_driver)
572 /* set the mrru, mtu and flags */
573 if (ioctl(ppp_dev_fd, PPPIOCSMRRU, &mrru) < 0)
574 error("Couldn't set MRRU: %m");
575 flags = get_flags(ppp_dev_fd);
576 flags &= ~(SC_MP_SHORTSEQ | SC_MP_XSHORTSEQ);
577 flags |= (rssn? SC_MP_SHORTSEQ: 0) | (tssn? SC_MP_XSHORTSEQ: 0)
578 | (mrru? SC_MULTILINK: 0);
580 set_flags(ppp_dev_fd, flags);
582 /* connect up the channel */
583 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifunit) < 0)
584 fatal("Couldn't attach to PPP unit %d: %m", ifunit);
589 * make_new_bundle - create a new PPP unit (i.e. a bundle)
590 * and connect our channel to it. This should only get called
591 * if `multilink' was set at the time establish_ppp was called.
592 * In demand mode this uses our existing bundle instead of making
595 void make_new_bundle(int mrru, int mtru, int rssn, int tssn)
597 if (!new_style_driver)
600 /* make us a ppp unit */
601 if (make_ppp_unit() < 0)
604 /* set the mrru and flags */
605 cfg_bundle(mrru, mtru, rssn, tssn);
609 * bundle_attach - attach our link to a given PPP unit.
610 * We assume the unit is controlled by another pppd.
612 int bundle_attach(int ifnum)
614 if (!new_style_driver)
617 if (ioctl(ppp_dev_fd, PPPIOCATTACH, &ifnum) < 0) {
619 return 0; /* doesn't still exist */
620 fatal("Couldn't attach to interface unit %d: %m\n", ifnum);
622 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifnum) < 0)
623 fatal("Couldn't connect to interface unit %d: %m", ifnum);
624 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_MULTILINK);
630 /********************************************************************
632 * clean_check - Fetch the flags for the device and generate
633 * appropriate error messages.
635 void clean_check(void)
641 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
643 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
645 s = "all had bit 7 set to 1";
649 s = "all had bit 7 set to 0";
653 s = "all had odd parity";
657 s = "all had even parity";
662 warn("Receive serial link is not 8-bit clean:");
663 warn("Problem: %s", s);
671 * List of valid speeds.
675 int speed_int, speed_val;
758 /********************************************************************
760 * Translate from bits/second to a speed_t.
763 static int translate_speed (int bps)
765 struct speed *speedp;
768 for (speedp = speeds; speedp->speed_int; speedp++) {
769 if (bps == speedp->speed_int)
770 return speedp->speed_val;
772 warn("speed %d not supported", bps);
777 /********************************************************************
779 * Translate from a speed_t to bits/second.
782 static int baud_rate_of (int speed)
784 struct speed *speedp;
787 for (speedp = speeds; speedp->speed_int; speedp++) {
788 if (speed == speedp->speed_val)
789 return speedp->speed_int;
795 /********************************************************************
797 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
798 * at the requested speed, etc. If `local' is true, set CLOCAL
799 * regardless of whether the modem option was specified.
802 void set_up_tty(int tty_fd, int local)
808 if (tcgetattr(tty_fd, &tios) < 0) {
809 if (!ok_error(errno))
810 fatal("tcgetattr: %m(%d)", errno);
817 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
818 tios.c_cflag |= CS8 | CREAD | HUPCL;
820 tios.c_iflag = IGNBRK | IGNPAR;
824 tios.c_cc[VTIME] = 0;
827 tios.c_cflag ^= (CLOCAL | HUPCL);
831 tios.c_cflag |= CRTSCTS;
835 tios.c_iflag |= IXON | IXOFF;
836 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
837 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
841 tios.c_cflag &= ~CRTSCTS;
848 speed = translate_speed(inspeed);
850 cfsetospeed (&tios, speed);
851 cfsetispeed (&tios, speed);
854 * We can't proceed if the serial port speed is B0,
855 * since that implies that the serial port is disabled.
858 speed = cfgetospeed(&tios);
860 fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
863 if (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0)
864 if (!ok_error(errno))
865 fatal("tcsetattr: %m");
867 baud_rate = baud_rate_of(speed);
871 /********************************************************************
873 * setdtr - control the DTR line on the serial port.
874 * This is called from die(), so it shouldn't call die().
877 void setdtr (int tty_fd, int on)
879 int modembits = TIOCM_DTR;
881 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
884 /********************************************************************
886 * restore_tty - restore the terminal to the saved settings.
889 void restore_tty (int tty_fd)
894 * Turn off echoing, because otherwise we can get into
895 * a loop with the tty and the modem echoing to each other.
896 * We presume we are the sole user of this tty device, so
897 * when we close it, it will revert to its defaults anyway.
900 inittermios.c_lflag &= ~(ECHO | ECHONL);
902 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
903 if (! ok_error (errno))
904 warn("tcsetattr: %m");
909 /********************************************************************
911 * output - Output PPP packet.
914 void output (int unit, unsigned char *p, int len)
920 dbglog("sent %P", p, len);
922 if (len < PPP_HDRLEN)
924 if (new_style_driver) {
927 proto = (p[0] << 8) + p[1];
928 if (ifunit >= 0 && !(proto >= 0xc000 || proto == PPP_CCPFRAG))
931 if (write(fd, p, len) < 0) {
932 if (errno == EWOULDBLOCK || errno == ENOBUFS
933 || errno == ENXIO || errno == EIO || errno == EINTR)
934 warn("write: warning: %m (%d)", errno);
936 error("write: %m (%d)", errno);
940 /********************************************************************
942 * wait_input - wait until there is data available,
943 * for the length of time specified by *timo (indefinite
947 void wait_input(struct timeval *timo)
954 n = select(max_in_fd + 1, &ready, NULL, &exc, timo);
955 if (n < 0 && errno != EINTR)
956 fatal("select: %m(%d)", errno);
960 * add_fd - add an fd to the set that wait_input waits for.
970 * remove_fd - remove an fd from the set that wait_input waits for.
972 void remove_fd(int fd)
978 /********************************************************************
980 * read_packet - get a PPP packet from the serial device.
983 int read_packet (unsigned char *buf)
987 len = PPP_MRU + PPP_HDRLEN;
988 if (new_style_driver) {
989 *buf++ = PPP_ALLSTATIONS;
995 nr = read(ppp_fd, buf, len);
996 if (nr < 0 && errno != EWOULDBLOCK && errno != EIO && errno != EINTR)
998 if (nr < 0 && errno == ENXIO)
1001 if (nr < 0 && new_style_driver && ifunit >= 0) {
1002 /* N.B. we read ppp_fd first since LCP packets come in there. */
1003 nr = read(ppp_dev_fd, buf, len);
1004 if (nr < 0 && errno != EWOULDBLOCK && errno != EIO && errno != EINTR)
1005 error("read /dev/ppp: %m");
1006 if (nr < 0 && errno == ENXIO)
1009 return (new_style_driver && nr > 0)? nr+2: nr;
1012 /********************************************************************
1014 * get_loop_output - get outgoing packets from the ppp device,
1015 * and detect when we want to bring the real link up.
1016 * Return value is 1 if we need to bring up the link, 0 otherwise.
1019 get_loop_output(void)
1024 if (new_style_driver) {
1025 while ((n = read_packet(inpacket_buf)) > 0)
1026 if (loop_frame(inpacket_buf, n))
1031 while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
1032 if (loop_chars(inbuf, n))
1036 fatal("eof on loopback");
1038 if (errno != EWOULDBLOCK)
1039 fatal("read from loopback: %m(%d)", errno);
1045 * netif_set_mtu - set the MTU on the PPP network interface.
1048 netif_set_mtu(int unit, int mtu)
1052 SYSDEBUG ((LOG_DEBUG, "netif_set_mtu: mtu = %d\n", mtu));
1054 memset (&ifr, '\0', sizeof (ifr));
1055 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1058 if (ifunit >= 0 && ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
1059 fatal("ioctl(SIOCSIFMTU): %m");
1062 /********************************************************************
1064 * tty_send_config - configure the transmit characteristics of
1065 * the ppp interface.
1068 void tty_send_config (int mtu,u_int32_t asyncmap,int pcomp,int accomp)
1073 * Set the asyncmap and other parameters for the ppp device
1078 SYSDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
1079 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
1080 if (!ok_error(errno))
1081 fatal("ioctl(PPPIOCSASYNCMAP): %m(%d)", errno);
1085 x = get_flags(ppp_fd);
1086 x = pcomp ? x | SC_COMP_PROT : x & ~SC_COMP_PROT;
1087 x = accomp ? x | SC_COMP_AC : x & ~SC_COMP_AC;
1088 x = sync_serial ? x | SC_SYNC : x & ~SC_SYNC;
1089 set_flags(ppp_fd, x);
1092 /********************************************************************
1094 * tty_set_xaccm - set the extended transmit ACCM for the interface.
1097 void tty_set_xaccm (ext_accm accm)
1099 SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
1100 accm[0], accm[1], accm[2], accm[3]));
1104 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
1105 if ( ! ok_error (errno))
1106 warn("ioctl(set extended ACCM): %m(%d)", errno);
1110 /********************************************************************
1112 * tty_recv_config - configure the receive-side characteristics of
1113 * the ppp interface.
1116 void tty_recv_config (int mru,u_int32_t asyncmap,int pcomp,int accomp)
1118 SYSDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
1120 * If we were called because the link has gone down then there is nothing
1121 * which may be done. Just return without incident.
1126 * Set the receiver parameters
1128 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
1129 if ( ! ok_error (errno))
1130 error("ioctl(PPPIOCSMRU): %m(%d)", errno);
1132 if (new_style_driver && ifunit >= 0
1133 && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
1134 error("Couldn't set MRU in generic PPP layer: %m");
1136 SYSDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
1137 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
1138 if (!ok_error(errno))
1139 error("ioctl(PPPIOCSRASYNCMAP): %m(%d)", errno);
1143 /********************************************************************
1145 * ccp_test - ask kernel whether a given compression method
1146 * is acceptable for use.
1149 int ccp_test (int unit, u_char *opt_ptr, int opt_len, int for_transmit)
1151 struct ppp_option_data data;
1153 memset (&data, '\0', sizeof (data));
1155 data.length = opt_len;
1156 data.transmit = for_transmit;
1158 if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1161 return (errno == ENOBUFS)? 0: -1;
1164 /********************************************************************
1166 * ccp_flags_set - inform kernel about the current state of CCP.
1169 void ccp_flags_set (int unit, int isopen, int isup)
1172 int x = get_flags(ppp_dev_fd);
1173 x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
1174 x = isup? x | SC_CCP_UP : x &~ SC_CCP_UP;
1175 set_flags (ppp_dev_fd, x);
1181 * set_filters - set the active and pass filters in the kernel driver.
1183 int set_filters(struct bpf_program *pass, struct bpf_program *active)
1185 struct sock_fprog fp;
1187 fp.len = pass->bf_len;
1188 fp.filter = (struct sock_filter *) pass->bf_insns;
1189 if (ioctl(ppp_dev_fd, PPPIOCSPASS, &fp) < 0) {
1190 if (errno == ENOTTY)
1191 warn("kernel does not support PPP filtering");
1193 error("Couldn't set pass-filter in kernel: %m");
1196 fp.len = active->bf_len;
1197 fp.filter = (struct sock_filter *) active->bf_insns;
1198 if (ioctl(ppp_dev_fd, PPPIOCSACTIVE, &fp) < 0) {
1199 error("Couldn't set active-filter in kernel: %m");
1204 #endif /* PPP_FILTER */
1206 /********************************************************************
1208 * get_idle_time - return how long the link has been idle.
1211 get_idle_time(u, ip)
1213 struct ppp_idle *ip;
1215 return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
1218 /********************************************************************
1220 * get_ppp_stats - return statistics for the link.
1223 get_ppp_stats(u, stats)
1225 struct pppd_stats *stats;
1227 struct ifpppstatsreq req;
1229 memset (&req, 0, sizeof (req));
1231 req.stats_ptr = (caddr_t) &req.stats;
1232 strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
1233 if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
1234 error("Couldn't get PPP statistics: %m");
1237 stats->bytes_in = req.stats.p.ppp_ibytes;
1238 stats->bytes_out = req.stats.p.ppp_obytes;
1242 /********************************************************************
1244 * ccp_fatal_error - returns 1 if decompression was disabled as a
1245 * result of an error detected after decompression of a packet,
1246 * 0 otherwise. This is necessary because of patent nonsense.
1249 int ccp_fatal_error (int unit)
1251 int x = get_flags(ppp_dev_fd);
1253 return x & SC_DC_FERROR;
1256 /********************************************************************
1258 * path_to_procfs - find the path to the proc file system mount point
1260 static char proc_path[MAXPATHLEN];
1261 static int proc_path_len;
1263 static char *path_to_procfs(const char *tail)
1265 struct mntent *mntent;
1268 if (proc_path_len == 0) {
1269 /* Default the mount location of /proc */
1270 strlcpy (proc_path, "/proc", sizeof(proc_path));
1272 fp = fopen(MOUNTED, "r");
1274 while ((mntent = getmntent(fp)) != NULL) {
1275 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1277 if (strcmp(mntent->mnt_type, "proc") == 0) {
1278 strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
1279 proc_path_len = strlen(proc_path);
1287 strlcpy(proc_path + proc_path_len, tail,
1288 sizeof(proc_path) - proc_path_len);
1293 * /proc/net/route parsing stuff.
1295 #define ROUTE_MAX_COLS 12
1296 FILE *route_fd = (FILE *) 0;
1297 static char route_buffer[512];
1298 static int route_dev_col, route_dest_col, route_gw_col;
1299 static int route_flags_col, route_mask_col;
1300 static int route_num_cols;
1302 static int open_route_table (void);
1303 static void close_route_table (void);
1304 static int read_route_table (struct rtentry *rt);
1306 /********************************************************************
1308 * close_route_table - close the interface to the route table
1311 static void close_route_table (void)
1313 if (route_fd != (FILE *) 0) {
1315 route_fd = (FILE *) 0;
1319 /********************************************************************
1321 * open_route_table - open the interface to the route table
1323 static char route_delims[] = " \t\n";
1325 static int open_route_table (void)
1329 close_route_table();
1331 path = path_to_procfs("/net/route");
1332 route_fd = fopen (path, "r");
1333 if (route_fd == NULL) {
1334 error("can't open routing table %s: %m", path);
1338 route_dev_col = 0; /* default to usual columns */
1341 route_flags_col = 3;
1345 /* parse header line */
1346 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1347 char *p = route_buffer, *q;
1349 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1351 if ((q = strtok(p, route_delims)) == 0)
1353 if (strcasecmp(q, "iface") == 0)
1354 route_dev_col = col;
1355 else if (strcasecmp(q, "destination") == 0)
1356 route_dest_col = col;
1357 else if (strcasecmp(q, "gateway") == 0)
1359 else if (strcasecmp(q, "flags") == 0)
1360 route_flags_col = col;
1361 else if (strcasecmp(q, "mask") == 0)
1362 route_mask_col = col;
1365 if (used && col >= route_num_cols)
1366 route_num_cols = col + 1;
1374 /********************************************************************
1376 * read_route_table - read the next entry from the route table
1379 static int read_route_table(struct rtentry *rt)
1381 char *cols[ROUTE_MAX_COLS], *p;
1384 memset (rt, '\0', sizeof (struct rtentry));
1386 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1390 for (col = 0; col < route_num_cols; ++col) {
1391 cols[col] = strtok(p, route_delims);
1392 if (cols[col] == NULL)
1393 return 0; /* didn't get enough columns */
1397 SIN_ADDR(rt->rt_dst) = strtoul(cols[route_dest_col], NULL, 16);
1398 SIN_ADDR(rt->rt_gateway) = strtoul(cols[route_gw_col], NULL, 16);
1399 SIN_ADDR(rt->rt_genmask) = strtoul(cols[route_mask_col], NULL, 16);
1401 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1402 rt->rt_dev = cols[route_dev_col];
1407 /********************************************************************
1409 * defaultroute_exists - determine if there is a default route
1412 static int defaultroute_exists (struct rtentry *rt)
1416 if (!open_route_table())
1419 while (read_route_table(rt) != 0) {
1420 if ((rt->rt_flags & RTF_UP) == 0)
1423 if (kernel_version > KVERSION(2,1,0) && SIN_ADDR(rt->rt_genmask) != 0)
1425 if (SIN_ADDR(rt->rt_dst) == 0L) {
1431 close_route_table();
1436 * have_route_to - determine if the system has any route to
1437 * a given IP address. `addr' is in network byte order.
1438 * Return value is 1 if yes, 0 if no, -1 if don't know.
1439 * For demand mode to work properly, we have to ignore routes
1440 * through our own interface.
1442 int have_route_to(u_int32_t addr)
1447 if (!open_route_table())
1448 return -1; /* don't know */
1450 while (read_route_table(&rt)) {
1451 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1453 if ((addr & SIN_ADDR(rt.rt_genmask)) == SIN_ADDR(rt.rt_dst)) {
1459 close_route_table();
1463 /********************************************************************
1465 * sifdefaultroute - assign a default route through the address given.
1468 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1472 if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0) {
1473 u_int32_t old_gateway = SIN_ADDR(rt.rt_gateway);
1475 if (old_gateway != gateway)
1476 error("not replacing existing default route to %s [%I]",
1477 rt.rt_dev, old_gateway);
1481 memset (&rt, '\0', sizeof (rt));
1482 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1483 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1485 if (kernel_version > KVERSION(2,1,0)) {
1486 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1487 SIN_ADDR(rt.rt_genmask) = 0L;
1490 SIN_ADDR(rt.rt_gateway) = gateway;
1492 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1493 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1494 if ( ! ok_error ( errno ))
1495 error("default route ioctl(SIOCADDRT): %m(%d)", errno);
1499 default_route_gateway = gateway;
1503 /********************************************************************
1505 * cifdefaultroute - delete a default route through the address given.
1508 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1512 default_route_gateway = 0;
1514 memset (&rt, '\0', sizeof (rt));
1515 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1516 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1518 if (kernel_version > KVERSION(2,1,0)) {
1519 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1520 SIN_ADDR(rt.rt_genmask) = 0L;
1523 SIN_ADDR(rt.rt_gateway) = gateway;
1525 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1526 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1528 if ( ! ok_error ( errno ))
1529 error("default route ioctl(SIOCDELRT): %m (%d)", errno);
1537 /********************************************************************
1539 * sifproxyarp - Make a proxy ARP entry for the peer.
1542 int sifproxyarp (int unit, u_int32_t his_adr)
1544 struct arpreq arpreq;
1547 if (has_proxy_arp == 0) {
1548 memset (&arpreq, '\0', sizeof(arpreq));
1550 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1551 SIN_ADDR(arpreq.arp_pa) = his_adr;
1552 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1554 * Get the hardware address of an interface on the same subnet
1555 * as our local address.
1557 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
1558 sizeof(proxy_arp_dev))) {
1559 error("Cannot determine ethernet address for proxy ARP");
1562 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1564 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
1565 if ( ! ok_error ( errno ))
1566 error("ioctl(SIOCSARP): %m(%d)", errno);
1569 proxy_arp_addr = his_adr;
1573 forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
1574 if (forw_path != 0) {
1575 int fd = open(forw_path, O_WRONLY);
1577 if (write(fd, "1", 1) != 1)
1578 error("Couldn't enable IP forwarding: %m");
1588 /********************************************************************
1590 * cifproxyarp - Delete the proxy ARP entry for the peer.
1593 int cifproxyarp (int unit, u_int32_t his_adr)
1595 struct arpreq arpreq;
1597 if (has_proxy_arp) {
1599 memset (&arpreq, '\0', sizeof(arpreq));
1600 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1601 SIN_ADDR(arpreq.arp_pa) = his_adr;
1602 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1603 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1605 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
1606 if ( ! ok_error ( errno ))
1607 warn("ioctl(SIOCDARP): %m(%d)", errno);
1614 /********************************************************************
1616 * get_ether_addr - get the hardware address of an interface on the
1617 * the same subnet as ipaddr.
1620 static int get_ether_addr (u_int32_t ipaddr,
1621 struct sockaddr *hwaddr,
1622 char *name, int namelen)
1624 struct ifreq *ifr, *ifend;
1625 u_int32_t ina, mask;
1629 struct ifreq ifs[MAX_IFS];
1631 ifc.ifc_len = sizeof(ifs);
1633 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1634 if ( ! ok_error ( errno ))
1635 error("ioctl(SIOCGIFCONF): %m(%d)", errno);
1639 SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1640 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1642 * Scan through looking for an interface with an Internet
1643 * address on the same subnet as `ipaddr'.
1645 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1646 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1647 if (ifr->ifr_addr.sa_family == AF_INET) {
1648 ina = SIN_ADDR(ifr->ifr_addr);
1649 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1650 SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1653 * Check that the interface is up, and not point-to-point
1656 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1659 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1662 * Get its netmask and check that it's on the right subnet.
1664 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1667 mask = SIN_ADDR(ifreq.ifr_addr);
1668 SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1669 ip_ntoa(ina), ntohl(mask)));
1671 if (((ipaddr ^ ina) & mask) != 0)
1680 strlcpy(name, ifreq.ifr_name, namelen);
1682 /* trim off the :1 in eth0:1 */
1683 aliasp = strchr(name, ':');
1687 info("found interface %s for proxy arp", name);
1689 * Now get the hardware address.
1691 memset (&ifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1692 if (ioctl (sock_fd, SIOCGIFHWADDR, &ifreq) < 0) {
1693 error("SIOCGIFHWADDR(%s): %m(%d)", ifreq.ifr_name, errno);
1699 sizeof (struct sockaddr));
1701 SYSDEBUG ((LOG_DEBUG,
1702 "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1703 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1704 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1705 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1706 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1707 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1708 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1709 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1710 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1715 * get_if_hwaddr - get the hardware address for the specified
1716 * network interface device.
1719 get_if_hwaddr(u_char *addr, char *name)
1724 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
1727 memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
1728 strlcpy(ifreq.ifr_name, name, sizeof(ifreq.ifr_name));
1729 ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
1732 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
1737 * get_first_ethernet - return the name of the first ethernet-style
1738 * interface on this system.
1741 get_first_ethernet()
1746 /********************************************************************
1748 * Return user specified netmask, modified by any mask we might determine
1749 * for address `addr' (in network byte order).
1750 * Here we scan through the system's list of interfaces, looking for
1751 * any non-point-to-point interfaces which might appear to be on the same
1752 * network as `addr'. If we find any, we OR in their netmask to the
1753 * user-specified netmask.
1756 u_int32_t GetMask (u_int32_t addr)
1758 u_int32_t mask, nmask, ina;
1759 struct ifreq *ifr, *ifend, ifreq;
1761 struct ifreq ifs[MAX_IFS];
1765 if (IN_CLASSA(addr)) /* determine network mask for address class */
1766 nmask = IN_CLASSA_NET;
1767 else if (IN_CLASSB(addr))
1768 nmask = IN_CLASSB_NET;
1770 nmask = IN_CLASSC_NET;
1772 /* class D nets are disallowed by bad_ip_adrs */
1773 mask = netmask | htonl(nmask);
1775 * Scan through the system's network interfaces.
1777 ifc.ifc_len = sizeof(ifs);
1779 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1780 if ( ! ok_error ( errno ))
1781 warn("ioctl(SIOCGIFCONF): %m(%d)", errno);
1785 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1786 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1788 * Check the interface's internet address.
1790 if (ifr->ifr_addr.sa_family != AF_INET)
1792 ina = SIN_ADDR(ifr->ifr_addr);
1793 if (((ntohl(ina) ^ addr) & nmask) != 0)
1796 * Check that the interface is up, and not point-to-point nor loopback.
1798 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1799 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1802 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1805 * Get its netmask and OR it into our mask.
1807 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1809 mask |= SIN_ADDR(ifreq.ifr_addr);
1815 /********************************************************************
1817 * Internal routine to decode the version.modification.patch level
1820 static void decode_version (char *buf, int *version,
1821 int *modification, int *patch)
1825 *version = (int) strtoul (buf, &endp, 10);
1829 if (endp != buf && *endp == '.') {
1831 *modification = (int) strtoul (buf, &endp, 10);
1832 if (endp != buf && *endp == '.') {
1834 *patch = (int) strtoul (buf, &buf, 10);
1839 /********************************************************************
1841 * Procedure to determine if the PPP line discipline is registered.
1845 ppp_registered(void)
1853 * We used to open the serial device and set it to the ppp line
1854 * discipline here, in order to create a ppp unit. But that is
1855 * not a good idea - the user might have specified a device that
1856 * they can't open (permission, or maybe it doesn't really exist).
1857 * So we grab a pty master/slave pair and use that.
1859 if (!get_pty(&mfd, &local_fd, slave, 0)) {
1860 no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
1865 * Try to put the device into the PPP discipline.
1867 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
1868 error("ioctl(TIOCSETD(PPP)): %m(%d)", errno);
1877 /********************************************************************
1879 * ppp_available - check whether the system has any ppp interfaces
1880 * (in fact we check whether we can do an ioctl on ppp0).
1883 int ppp_available(void)
1888 int my_version, my_modification, my_patch;
1889 int osmaj, osmin, ospatch;
1892 "This system lacks kernel support for PPP. This could be because\n"
1893 "the PPP kernel module could not be loaded, or because PPP was not\n"
1894 "included in the kernel configuration. If PPP was included as a\n"
1895 "module, try `/sbin/modprobe -v ppp'. If that fails, check that\n"
1896 "ppp.o exists in /lib/modules/`uname -r`/net.\n"
1897 "See README.linux file in the ppp distribution for more details.\n";
1899 /* get the kernel version now, since we are called before sys_init */
1901 osmaj = osmin = ospatch = 0;
1902 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
1903 kernel_version = KVERSION(osmaj, osmin, ospatch);
1905 fd = open("/dev/ppp", O_RDWR);
1907 if (fd < 0 && errno == ENOENT) {
1908 /* try making it and see if that helps. */
1909 if (mknod("/dev/ppp", S_IFCHR | S_IRUSR | S_IWUSR,
1910 makedev(108, 0)) >= 0) {
1911 fd = open("/dev/ppp", O_RDWR);
1913 info("Created /dev/ppp device node");
1915 unlink("/dev/ppp"); /* didn't work, undo the mknod */
1916 } else if (errno == EEXIST) {
1917 fd = open("/dev/ppp", O_RDWR);
1922 new_style_driver = 1;
1924 /* XXX should get from driver */
1926 driver_modification = 4;
1931 if (kernel_version >= KVERSION(2,3,13)) {
1932 if (errno == ENOENT)
1934 "pppd is unable to open the /dev/ppp device.\n"
1935 "You need to create the /dev/ppp device node by\n"
1936 "executing the following command as root:\n"
1937 " mknod /dev/ppp c 108 0\n";
1942 * Open a socket for doing the ioctl operations.
1944 s = socket(AF_INET, SOCK_DGRAM, 0);
1948 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1949 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1951 * If the device did not exist then attempt to create one by putting the
1952 * current tty into the PPP discipline. If this works then obtain the
1953 * flags for the device again.
1956 if (ppp_registered()) {
1957 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1958 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1962 * Ensure that the hardware address is for PPP and not something else
1965 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
1967 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
1971 * This is the PPP device. Validate the version of the driver at this
1972 * point to ensure that this program will work with the driver.
1975 char abBuffer [1024];
1977 ifr.ifr_data = abBuffer;
1978 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
1980 error("Couldn't read driver version: %m");
1982 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
1985 decode_version(abBuffer,
1987 &driver_modification,
1990 * Validate the version of the driver against the version that we used.
1992 decode_version(VERSION,
1997 /* The version numbers must match */
1998 if (driver_version != my_version)
2001 /* The modification levels must be legal */
2002 if (driver_modification < 3) {
2003 if (driver_modification >= 2) {
2004 /* we can cope with 2.2.0 and above */
2013 slprintf(route_buffer, sizeof(route_buffer),
2014 "Sorry - PPP driver version %d.%d.%d is out of date\n",
2015 driver_version, driver_modification, driver_patch);
2017 no_ppp_msg = route_buffer;
2024 /********************************************************************
2026 * Update the wtmp file with the appropriate user name and tty device.
2029 void logwtmp (const char *line, const char *name, const char *host)
2031 struct utmp ut, *utp;
2032 pid_t mypid = getpid();
2038 * Update the signon database for users.
2039 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
2041 utmpname(_PATH_UTMP);
2043 while ((utp = getutent()) && (utp->ut_pid != mypid))
2046 /* Is this call really necessary? There is another one after the 'put' */
2050 memcpy(&ut, utp, sizeof(ut));
2052 /* some gettys/telnetds don't initialize utmp... */
2053 memset(&ut, 0, sizeof(ut));
2055 if (ut.ut_id[0] == 0)
2056 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
2058 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
2059 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
2063 ut.ut_type = USER_PROCESS;
2066 /* Insert the host name if one is supplied */
2068 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
2070 /* Insert the IP address of the remote system if IP is enabled */
2071 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
2072 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
2073 sizeof(ut.ut_addr));
2075 /* CL: Makes sure that the logout works */
2076 if (*host == 0 && *name==0)
2082 * Update the wtmp file.
2085 updwtmp(_PATH_WTMP, &ut);
2087 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
2089 flock(wtmp, LOCK_EX);
2091 if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
2092 warn("error writing %s: %m", _PATH_WTMP);
2094 flock(wtmp, LOCK_UN);
2102 /********************************************************************
2104 * sifvjcomp - config tcp header compression
2107 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2109 u_int x = get_flags(ppp_dev_fd);
2112 if (ioctl (ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
2113 if (! ok_error (errno))
2114 error("ioctl(PPPIOCSMAXCID): %m(%d)", errno);
2119 x = vjcomp ? x | SC_COMP_TCP : x &~ SC_COMP_TCP;
2120 x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
2121 set_flags (ppp_dev_fd, x);
2126 /********************************************************************
2128 * sifup - Config the interface up and enable IP packets to pass.
2135 memset (&ifr, '\0', sizeof (ifr));
2136 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2137 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2138 if (! ok_error (errno))
2139 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
2143 ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
2144 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2145 if (! ok_error (errno))
2146 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2154 /********************************************************************
2156 * sifdown - Disable the indicated protocol and config the interface
2157 * down if there are no remaining protocols.
2164 if (if_is_up && --if_is_up > 0)
2167 memset (&ifr, '\0', sizeof (ifr));
2168 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2169 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2170 if (! ok_error (errno))
2171 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
2175 ifr.ifr_flags &= ~IFF_UP;
2176 ifr.ifr_flags |= IFF_POINTOPOINT;
2177 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2178 if (! ok_error (errno))
2179 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2185 /********************************************************************
2187 * sifaddr - Config the interface IP addresses and netmask.
2190 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2196 memset (&ifr, '\0', sizeof (ifr));
2197 memset (&rt, '\0', sizeof (rt));
2199 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
2200 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2201 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2203 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2205 * Set our IP address
2207 SIN_ADDR(ifr.ifr_addr) = our_adr;
2208 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2209 if (errno != EEXIST) {
2210 if (! ok_error (errno))
2211 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
2214 warn("ioctl(SIOCSIFADDR): Address already exists");
2219 * Set the gateway address
2221 SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
2222 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2223 if (! ok_error (errno))
2224 error("ioctl(SIOCSIFDSTADDR): %m(%d)", errno);
2229 * For recent kernels, force the netmask to 255.255.255.255.
2231 if (kernel_version >= KVERSION(2,1,16))
2233 if (net_mask != 0) {
2234 SIN_ADDR(ifr.ifr_netmask) = net_mask;
2235 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2236 if (! ok_error (errno))
2237 error("ioctl(SIOCSIFNETMASK): %m(%d)", errno);
2242 * Add the device route
2244 if (kernel_version < KVERSION(2,1,16)) {
2245 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2246 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2249 SIN_ADDR(rt.rt_gateway) = 0L;
2250 SIN_ADDR(rt.rt_dst) = his_adr;
2251 rt.rt_flags = RTF_UP | RTF_HOST;
2253 if (kernel_version > KVERSION(2,1,0)) {
2254 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2255 SIN_ADDR(rt.rt_genmask) = -1L;
2258 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2259 if (! ok_error (errno))
2260 error("ioctl(SIOCADDRT) device route: %m(%d)", errno);
2265 /* set ip_dynaddr in demand mode if address changes */
2266 if (demand && tune_kernel && !dynaddr_set
2267 && our_old_addr && our_old_addr != our_adr) {
2268 /* set ip_dynaddr if possible */
2272 path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
2273 if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
2274 if (write(fd, "1", 1) != 1)
2275 error("Couldn't enable dynamic IP addressing: %m");
2278 dynaddr_set = 1; /* only 1 attempt */
2285 /********************************************************************
2287 * cifaddr - Clear the interface IP addresses, and delete routes
2288 * through the interface if possible.
2291 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2295 if (kernel_version < KVERSION(2,1,16)) {
2297 * Delete the route through the device
2300 memset (&rt, '\0', sizeof (rt));
2302 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2303 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2306 SIN_ADDR(rt.rt_gateway) = 0;
2307 SIN_ADDR(rt.rt_dst) = his_adr;
2308 rt.rt_flags = RTF_UP | RTF_HOST;
2310 if (kernel_version > KVERSION(2,1,0)) {
2311 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2312 SIN_ADDR(rt.rt_genmask) = -1L;
2315 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2316 if (still_ppp() && ! ok_error (errno))
2317 error("ioctl(SIOCDELRT) device route: %m(%d)", errno);
2322 /* This way it is possible to have an IPX-only or IPv6-only interface */
2323 memset(&ifr, 0, sizeof(ifr));
2324 SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
2325 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2327 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2328 if (! ok_error (errno)) {
2329 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
2334 our_old_addr = our_adr;
2340 /********************************************************************
2342 * sif6addr - Config the interface with an IPv6 link-local address
2344 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2346 struct in6_ifreq ifr6;
2348 struct in6_rtmsg rt6;
2352 error("IPv6 socket creation failed: %m");
2355 memset(&ifr, 0, sizeof (ifr));
2356 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2357 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2358 error("sif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
2362 /* Local interface */
2363 memset(&ifr6, 0, sizeof(ifr6));
2364 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2365 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2366 ifr6.ifr6_prefixlen = 10;
2368 if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
2369 error("sif6addr: ioctl(SIOCSIFADDR): %m (%d)", errno);
2373 /* Route to remote host */
2374 memset(&rt6, 0, sizeof(rt6));
2375 IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
2376 rt6.rtmsg_flags = RTF_UP;
2377 rt6.rtmsg_dst_len = 10;
2378 rt6.rtmsg_ifindex = ifr.ifr_ifindex;
2379 rt6.rtmsg_metric = 1;
2381 if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
2382 error("sif6addr: ioctl(SIOCADDRT): %m (%d)", errno);
2390 /********************************************************************
2392 * cif6addr - Remove IPv6 address from interface
2394 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2397 struct in6_ifreq ifr6;
2401 error("IPv6 socket creation failed: %m");
2404 memset(&ifr, 0, sizeof(ifr));
2405 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2406 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2407 error("cif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
2411 memset(&ifr6, 0, sizeof(ifr6));
2412 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2413 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2414 ifr6.ifr6_prefixlen = 10;
2416 if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
2417 if (errno != EADDRNOTAVAIL) {
2418 if (! ok_error (errno))
2419 error("cif6addr: ioctl(SIOCDIFADDR): %m (%d)", errno);
2422 warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
2431 * get_pty - get a pty master/slave pair and chown the slave side
2432 * to the uid given. Assumes slave_name points to >= 16 bytes of space.
2435 get_pty(master_fdp, slave_fdp, slave_name, uid)
2441 int i, mfd, sfd = -1;
2443 struct termios tios;
2447 * Try the unix98 way first.
2449 mfd = open("/dev/ptmx", O_RDWR);
2452 if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
2453 slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
2454 chmod(pty_name, S_IRUSR | S_IWUSR);
2457 if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
2458 warn("Couldn't unlock pty slave %s: %m", pty_name);
2460 if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
2461 warn("Couldn't open pty slave %s: %m", pty_name);
2464 #endif /* TIOCGPTN */
2467 /* the old way - scan through the pty name space */
2468 for (i = 0; i < 64; ++i) {
2469 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2470 'p' + i / 16, i % 16);
2471 mfd = open(pty_name, O_RDWR, 0);
2474 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2476 fchown(sfd, uid, -1);
2477 fchmod(sfd, S_IRUSR | S_IWUSR);
2488 strlcpy(slave_name, pty_name, 16);
2491 if (tcgetattr(sfd, &tios) == 0) {
2492 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2493 tios.c_cflag |= CS8 | CREAD | CLOCAL;
2494 tios.c_iflag = IGNPAR;
2497 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2498 warn("couldn't set attributes on pty: %m");
2500 warn("couldn't get attributes on pty: %m");
2505 /********************************************************************
2507 * open_loopback - open the device we use for getting packets
2508 * in demand mode. Under Linux, we use a pty master/slave pair.
2511 open_ppp_loopback(void)
2516 if (new_style_driver) {
2517 /* allocate ourselves a ppp unit */
2518 if (make_ppp_unit() < 0)
2520 set_flags(ppp_dev_fd, SC_LOOP_TRAFFIC);
2521 set_kdebugflag(kdebugflag);
2526 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2527 fatal("No free pty for loopback");
2528 SYSDEBUG(("using %s for loopback", loop_name));
2530 set_ppp_fd(slave_fd);
2532 flags = fcntl(master_fd, F_GETFL);
2534 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2535 warn("couldn't set master loopback to nonblock: %m(%d)", errno);
2537 flags = fcntl(ppp_fd, F_GETFL);
2539 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2540 warn("couldn't set slave loopback to nonblock: %m(%d)", errno);
2542 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2543 fatal("ioctl(TIOCSETD): %m(%d)", errno);
2545 * Find out which interface we were given.
2547 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2548 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
2550 * Enable debug in the driver if requested.
2552 set_kdebugflag (kdebugflag);
2557 /********************************************************************
2559 * restore_loop - reattach the ppp unit to the loopback.
2561 * The kernel ppp driver automatically reattaches the ppp unit to
2562 * the loopback if the serial port is set to a line discipline other
2563 * than ppp, or if it detects a modem hangup. The former will happen
2564 * in disestablish_ppp if the latter hasn't already happened, so we
2565 * shouldn't need to do anything.
2567 * Just to be sure, set the real serial port to the normal discipline.
2574 if (new_style_driver) {
2575 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_LOOP_TRAFFIC);
2578 if (ppp_fd != slave_fd) {
2579 (void) ioctl(ppp_fd, TIOCSETD, &tty_disc);
2580 set_ppp_fd(slave_fd);
2584 /********************************************************************
2586 * sifnpmode - Set the mode for handling packets for a given NP.
2590 sifnpmode(u, proto, mode)
2597 npi.protocol = proto;
2599 if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2600 if (! ok_error (errno))
2601 error("ioctl(PPPIOCSNPMODE, %d, %d): %m (%d)",
2602 proto, mode, errno);
2609 /********************************************************************
2611 * sipxfaddr - Config the interface IPX networknumber
2614 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2621 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2623 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2625 if (! ok_error (errno))
2626 dbglog("socket(AF_IPX): %m (%d)", errno);
2630 memset (&ifr, '\0', sizeof (ifr));
2631 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2633 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2634 sipx->sipx_family = AF_IPX;
2635 sipx->sipx_port = 0;
2636 sipx->sipx_network = htonl (network);
2637 sipx->sipx_type = IPX_FRAME_ETHERII;
2638 sipx->sipx_action = IPX_CRTITF;
2640 * Set the IPX device
2642 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2644 if (errno != EEXIST) {
2645 if (! ok_error (errno))
2646 dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (%d)", errno);
2649 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2658 /********************************************************************
2660 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2661 * are removed and the device is no longer able to pass IPX
2665 int cipxfaddr (int unit)
2672 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2674 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2676 if (! ok_error (errno))
2677 dbglog("socket(AF_IPX): %m (%d)", errno);
2681 memset (&ifr, '\0', sizeof (ifr));
2682 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2684 sipx->sipx_type = IPX_FRAME_ETHERII;
2685 sipx->sipx_action = IPX_DLTITF;
2686 sipx->sipx_family = AF_IPX;
2688 * Set the IPX device
2690 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2691 if (! ok_error (errno))
2692 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (%d)", errno);
2702 * Use the hostname as part of the random number seed.
2711 for (p = hostname; *p != 0; ++p)
2716 /********************************************************************
2718 * sys_check_options - check the options that the user specified
2722 sys_check_options(void)
2726 * Disable the IPX protocol if the support is not present in the kernel.
2730 if (ipxcp_protent.enabled_flag) {
2731 struct stat stat_buf;
2732 if ((path = path_to_procfs("/net/ipx_interface")) == 0
2733 || lstat(path, &stat_buf) < 0) {
2734 error("IPX support is not present in the kernel\n");
2735 ipxcp_protent.enabled_flag = 0;
2739 if (demand && driver_is_old) {
2740 option_error("demand dialling is not supported by kernel driver "
2741 "version %d.%d.%d", driver_version, driver_modification,
2745 if (multilink && !new_style_driver) {
2746 warn("Warning: multilink is not supported by the kernel driver");