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))
1935 * Open a socket for doing the ioctl operations.
1937 s = socket(AF_INET, SOCK_DGRAM, 0);
1941 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1942 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1944 * If the device did not exist then attempt to create one by putting the
1945 * current tty into the PPP discipline. If this works then obtain the
1946 * flags for the device again.
1949 if (ppp_registered()) {
1950 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1951 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1955 * Ensure that the hardware address is for PPP and not something else
1958 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
1960 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
1964 * This is the PPP device. Validate the version of the driver at this
1965 * point to ensure that this program will work with the driver.
1968 char abBuffer [1024];
1970 ifr.ifr_data = abBuffer;
1971 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
1973 error("Couldn't read driver version: %m");
1975 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
1978 decode_version(abBuffer,
1980 &driver_modification,
1983 * Validate the version of the driver against the version that we used.
1985 decode_version(VERSION,
1990 /* The version numbers must match */
1991 if (driver_version != my_version)
1994 /* The modification levels must be legal */
1995 if (driver_modification < 3) {
1996 if (driver_modification >= 2) {
1997 /* we can cope with 2.2.0 and above */
2006 slprintf(route_buffer, sizeof(route_buffer),
2007 "Sorry - PPP driver version %d.%d.%d is out of date\n",
2008 driver_version, driver_modification, driver_patch);
2010 no_ppp_msg = route_buffer;
2017 /********************************************************************
2019 * Update the wtmp file with the appropriate user name and tty device.
2022 void logwtmp (const char *line, const char *name, const char *host)
2024 struct utmp ut, *utp;
2025 pid_t mypid = getpid();
2031 * Update the signon database for users.
2032 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
2034 utmpname(_PATH_UTMP);
2036 while ((utp = getutent()) && (utp->ut_pid != mypid))
2039 /* Is this call really necessary? There is another one after the 'put' */
2043 memcpy(&ut, utp, sizeof(ut));
2045 /* some gettys/telnetds don't initialize utmp... */
2046 memset(&ut, 0, sizeof(ut));
2048 if (ut.ut_id[0] == 0)
2049 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
2051 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
2052 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
2056 ut.ut_type = USER_PROCESS;
2059 /* Insert the host name if one is supplied */
2061 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
2063 /* Insert the IP address of the remote system if IP is enabled */
2064 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
2065 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
2066 sizeof(ut.ut_addr));
2068 /* CL: Makes sure that the logout works */
2069 if (*host == 0 && *name==0)
2075 * Update the wtmp file.
2078 updwtmp(_PATH_WTMP, &ut);
2080 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
2082 flock(wtmp, LOCK_EX);
2084 if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
2085 warn("error writing %s: %m", _PATH_WTMP);
2087 flock(wtmp, LOCK_UN);
2095 /********************************************************************
2097 * sifvjcomp - config tcp header compression
2100 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2102 u_int x = get_flags(ppp_dev_fd);
2105 if (ioctl (ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
2106 if (! ok_error (errno))
2107 error("ioctl(PPPIOCSMAXCID): %m(%d)", errno);
2112 x = vjcomp ? x | SC_COMP_TCP : x &~ SC_COMP_TCP;
2113 x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
2114 set_flags (ppp_dev_fd, x);
2119 /********************************************************************
2121 * sifup - Config the interface up and enable IP packets to pass.
2128 memset (&ifr, '\0', sizeof (ifr));
2129 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2130 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2131 if (! ok_error (errno))
2132 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
2136 ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
2137 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2138 if (! ok_error (errno))
2139 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2147 /********************************************************************
2149 * sifdown - Disable the indicated protocol and config the interface
2150 * down if there are no remaining protocols.
2157 if (if_is_up && --if_is_up > 0)
2160 memset (&ifr, '\0', sizeof (ifr));
2161 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2162 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2163 if (! ok_error (errno))
2164 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
2168 ifr.ifr_flags &= ~IFF_UP;
2169 ifr.ifr_flags |= IFF_POINTOPOINT;
2170 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2171 if (! ok_error (errno))
2172 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2178 /********************************************************************
2180 * sifaddr - Config the interface IP addresses and netmask.
2183 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2189 memset (&ifr, '\0', sizeof (ifr));
2190 memset (&rt, '\0', sizeof (rt));
2192 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
2193 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2194 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2196 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2198 * Set our IP address
2200 SIN_ADDR(ifr.ifr_addr) = our_adr;
2201 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2202 if (errno != EEXIST) {
2203 if (! ok_error (errno))
2204 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
2207 warn("ioctl(SIOCSIFADDR): Address already exists");
2212 * Set the gateway address
2214 SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
2215 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2216 if (! ok_error (errno))
2217 error("ioctl(SIOCSIFDSTADDR): %m(%d)", errno);
2222 * For recent kernels, force the netmask to 255.255.255.255.
2224 if (kernel_version >= KVERSION(2,1,16))
2226 if (net_mask != 0) {
2227 SIN_ADDR(ifr.ifr_netmask) = net_mask;
2228 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2229 if (! ok_error (errno))
2230 error("ioctl(SIOCSIFNETMASK): %m(%d)", errno);
2235 * Add the device route
2237 if (kernel_version < KVERSION(2,1,16)) {
2238 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2239 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2242 SIN_ADDR(rt.rt_gateway) = 0L;
2243 SIN_ADDR(rt.rt_dst) = his_adr;
2244 rt.rt_flags = RTF_UP | RTF_HOST;
2246 if (kernel_version > KVERSION(2,1,0)) {
2247 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2248 SIN_ADDR(rt.rt_genmask) = -1L;
2251 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2252 if (! ok_error (errno))
2253 error("ioctl(SIOCADDRT) device route: %m(%d)", errno);
2258 /* set ip_dynaddr in demand mode if address changes */
2259 if (demand && tune_kernel && !dynaddr_set
2260 && our_old_addr && our_old_addr != our_adr) {
2261 /* set ip_dynaddr if possible */
2265 path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
2266 if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
2267 if (write(fd, "1", 1) != 1)
2268 error("Couldn't enable dynamic IP addressing: %m");
2271 dynaddr_set = 1; /* only 1 attempt */
2278 /********************************************************************
2280 * cifaddr - Clear the interface IP addresses, and delete routes
2281 * through the interface if possible.
2284 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2288 if (kernel_version < KVERSION(2,1,16)) {
2290 * Delete the route through the device
2293 memset (&rt, '\0', sizeof (rt));
2295 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2296 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2299 SIN_ADDR(rt.rt_gateway) = 0;
2300 SIN_ADDR(rt.rt_dst) = his_adr;
2301 rt.rt_flags = RTF_UP | RTF_HOST;
2303 if (kernel_version > KVERSION(2,1,0)) {
2304 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2305 SIN_ADDR(rt.rt_genmask) = -1L;
2308 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2309 if (still_ppp() && ! ok_error (errno))
2310 error("ioctl(SIOCDELRT) device route: %m(%d)", errno);
2315 /* This way it is possible to have an IPX-only or IPv6-only interface */
2316 memset(&ifr, 0, sizeof(ifr));
2317 SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
2318 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2320 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2321 if (! ok_error (errno)) {
2322 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
2327 our_old_addr = our_adr;
2333 /********************************************************************
2335 * sif6addr - Config the interface with an IPv6 link-local address
2337 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2339 struct in6_ifreq ifr6;
2341 struct in6_rtmsg rt6;
2345 error("IPv6 socket creation failed: %m");
2348 memset(&ifr, 0, sizeof (ifr));
2349 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2350 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2351 error("sif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
2355 /* Local interface */
2356 memset(&ifr6, 0, sizeof(ifr6));
2357 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2358 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2359 ifr6.ifr6_prefixlen = 10;
2361 if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
2362 error("sif6addr: ioctl(SIOCSIFADDR): %m (%d)", errno);
2366 /* Route to remote host */
2367 memset(&rt6, 0, sizeof(rt6));
2368 IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
2369 rt6.rtmsg_flags = RTF_UP;
2370 rt6.rtmsg_dst_len = 10;
2371 rt6.rtmsg_ifindex = ifr.ifr_ifindex;
2372 rt6.rtmsg_metric = 1;
2374 if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
2375 error("sif6addr: ioctl(SIOCADDRT): %m (%d)", errno);
2383 /********************************************************************
2385 * cif6addr - Remove IPv6 address from interface
2387 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2390 struct in6_ifreq ifr6;
2394 error("IPv6 socket creation failed: %m");
2397 memset(&ifr, 0, sizeof(ifr));
2398 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2399 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2400 error("cif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
2404 memset(&ifr6, 0, sizeof(ifr6));
2405 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2406 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2407 ifr6.ifr6_prefixlen = 10;
2409 if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
2410 if (errno != EADDRNOTAVAIL) {
2411 if (! ok_error (errno))
2412 error("cif6addr: ioctl(SIOCDIFADDR): %m (%d)", errno);
2415 warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
2424 * get_pty - get a pty master/slave pair and chown the slave side
2425 * to the uid given. Assumes slave_name points to >= 16 bytes of space.
2428 get_pty(master_fdp, slave_fdp, slave_name, uid)
2434 int i, mfd, sfd = -1;
2436 struct termios tios;
2440 * Try the unix98 way first.
2442 mfd = open("/dev/ptmx", O_RDWR);
2445 if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
2446 slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
2447 chmod(pty_name, S_IRUSR | S_IWUSR);
2450 if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
2451 warn("Couldn't unlock pty slave %s: %m", pty_name);
2453 if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
2454 warn("Couldn't open pty slave %s: %m", pty_name);
2457 #endif /* TIOCGPTN */
2460 /* the old way - scan through the pty name space */
2461 for (i = 0; i < 64; ++i) {
2462 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2463 'p' + i / 16, i % 16);
2464 mfd = open(pty_name, O_RDWR, 0);
2467 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2469 fchown(sfd, uid, -1);
2470 fchmod(sfd, S_IRUSR | S_IWUSR);
2481 strlcpy(slave_name, pty_name, 16);
2484 if (tcgetattr(sfd, &tios) == 0) {
2485 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2486 tios.c_cflag |= CS8 | CREAD | CLOCAL;
2487 tios.c_iflag = IGNPAR;
2490 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2491 warn("couldn't set attributes on pty: %m");
2493 warn("couldn't get attributes on pty: %m");
2498 /********************************************************************
2500 * open_loopback - open the device we use for getting packets
2501 * in demand mode. Under Linux, we use a pty master/slave pair.
2504 open_ppp_loopback(void)
2509 if (new_style_driver) {
2510 /* allocate ourselves a ppp unit */
2511 if (make_ppp_unit() < 0)
2513 set_flags(ppp_dev_fd, SC_LOOP_TRAFFIC);
2514 set_kdebugflag(kdebugflag);
2519 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2520 fatal("No free pty for loopback");
2521 SYSDEBUG(("using %s for loopback", loop_name));
2523 set_ppp_fd(slave_fd);
2525 flags = fcntl(master_fd, F_GETFL);
2527 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2528 warn("couldn't set master loopback to nonblock: %m(%d)", errno);
2530 flags = fcntl(ppp_fd, F_GETFL);
2532 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2533 warn("couldn't set slave loopback to nonblock: %m(%d)", errno);
2535 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2536 fatal("ioctl(TIOCSETD): %m(%d)", errno);
2538 * Find out which interface we were given.
2540 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2541 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
2543 * Enable debug in the driver if requested.
2545 set_kdebugflag (kdebugflag);
2550 /********************************************************************
2552 * restore_loop - reattach the ppp unit to the loopback.
2554 * The kernel ppp driver automatically reattaches the ppp unit to
2555 * the loopback if the serial port is set to a line discipline other
2556 * than ppp, or if it detects a modem hangup. The former will happen
2557 * in disestablish_ppp if the latter hasn't already happened, so we
2558 * shouldn't need to do anything.
2560 * Just to be sure, set the real serial port to the normal discipline.
2567 if (new_style_driver) {
2568 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_LOOP_TRAFFIC);
2571 if (ppp_fd != slave_fd) {
2572 (void) ioctl(ppp_fd, TIOCSETD, &tty_disc);
2573 set_ppp_fd(slave_fd);
2577 /********************************************************************
2579 * sifnpmode - Set the mode for handling packets for a given NP.
2583 sifnpmode(u, proto, mode)
2590 npi.protocol = proto;
2592 if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2593 if (! ok_error (errno))
2594 error("ioctl(PPPIOCSNPMODE, %d, %d): %m (%d)",
2595 proto, mode, errno);
2602 /********************************************************************
2604 * sipxfaddr - Config the interface IPX networknumber
2607 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2614 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2616 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2618 if (! ok_error (errno))
2619 dbglog("socket(AF_IPX): %m (%d)", errno);
2623 memset (&ifr, '\0', sizeof (ifr));
2624 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2626 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2627 sipx->sipx_family = AF_IPX;
2628 sipx->sipx_port = 0;
2629 sipx->sipx_network = htonl (network);
2630 sipx->sipx_type = IPX_FRAME_ETHERII;
2631 sipx->sipx_action = IPX_CRTITF;
2633 * Set the IPX device
2635 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2637 if (errno != EEXIST) {
2638 if (! ok_error (errno))
2639 dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (%d)", errno);
2642 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2651 /********************************************************************
2653 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2654 * are removed and the device is no longer able to pass IPX
2658 int cipxfaddr (int unit)
2665 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2667 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2669 if (! ok_error (errno))
2670 dbglog("socket(AF_IPX): %m (%d)", errno);
2674 memset (&ifr, '\0', sizeof (ifr));
2675 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2677 sipx->sipx_type = IPX_FRAME_ETHERII;
2678 sipx->sipx_action = IPX_DLTITF;
2679 sipx->sipx_family = AF_IPX;
2681 * Set the IPX device
2683 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2684 if (! ok_error (errno))
2685 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (%d)", errno);
2695 * Use the hostname as part of the random number seed.
2704 for (p = hostname; *p != 0; ++p)
2709 /********************************************************************
2711 * sys_check_options - check the options that the user specified
2715 sys_check_options(void)
2719 * Disable the IPX protocol if the support is not present in the kernel.
2723 if (ipxcp_protent.enabled_flag) {
2724 struct stat stat_buf;
2725 if ((path = path_to_procfs("/net/ipx_interface")) == 0
2726 || lstat(path, &stat_buf) < 0) {
2727 error("IPX support is not present in the kernel\n");
2728 ipxcp_protent.enabled_flag = 0;
2732 if (demand && driver_is_old) {
2733 option_error("demand dialling is not supported by kernel driver "
2734 "version %d.%d.%d", driver_version, driver_modification,
2738 if (multilink && !new_style_driver) {
2739 warn("Warning: multilink is not supported by the kernel driver");