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 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);
186 extern u_char inpacket_buf[]; /* borrowed from main.c */
189 * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
193 #define SET_SA_FAMILY(addr, family) \
194 memset ((char *) &(addr), '\0', sizeof(addr)); \
195 addr.sa_family = (family);
198 * Determine if the PPP connection should still be present.
203 /* new_fd is the fd of a tty */
204 static void set_ppp_fd (int new_fd)
206 SYSDEBUG ((LOG_DEBUG, "setting ppp_fd to %d\n", new_fd));
208 if (!new_style_driver)
212 static int still_ppp(void)
214 if (new_style_driver)
215 return !hungup && ppp_fd >= 0;
216 if (!hungup || ppp_fd == slave_fd)
219 set_ppp_fd(slave_fd);
225 /********************************************************************
227 * Functions to read and set the flags value in the device driver
230 static int get_flags (int fd)
234 if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &flags) < 0) {
235 if ( ok_error (errno) )
238 fatal("ioctl(PPPIOCGFLAGS): %m (line %d)", __LINE__);
241 SYSDEBUG ((LOG_DEBUG, "get flags = %x\n", flags));
245 /********************************************************************/
247 static void set_flags (int fd, int flags)
249 SYSDEBUG ((LOG_DEBUG, "set flags = %x\n", flags));
251 if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &flags) < 0) {
252 if (! ok_error (errno) )
253 fatal("ioctl(PPPIOCSFLAGS, %x): %m (line %d)", flags, errno, __LINE__);
257 /********************************************************************
259 * sys_init - System-dependent initialization.
266 if (new_style_driver) {
267 ppp_dev_fd = open("/dev/ppp", O_RDWR);
269 fatal("Couldn't open /dev/ppp: %m");
270 flags = fcntl(ppp_dev_fd, F_GETFL);
272 || fcntl(ppp_dev_fd, F_SETFL, flags | O_NONBLOCK) == -1)
273 warn("Couldn't set /dev/ppp to nonblock: %m");
276 /* Get an internet socket for doing socket ioctls. */
277 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
279 fatal("Couldn't create IP socket: %m(%d)", errno);
282 sock6_fd = socket(AF_INET6, SOCK_DGRAM, 0);
284 sock6_fd = -errno; /* save errno for later */
291 /********************************************************************
293 * sys_cleanup - restore any system state we modified before exiting:
294 * mark the interface down, delete default route and/or proxy arp entry.
295 * This shouldn't call die() because it's called from die().
298 void sys_cleanup(void)
301 * Take down the device
308 * Delete any routes through the device.
310 if (default_route_gateway != 0)
311 cifdefaultroute(0, 0, default_route_gateway);
314 cifproxyarp(0, proxy_arp_addr);
317 /********************************************************************
319 * sys_close - Clean up in a child process before execing.
324 if (new_style_driver)
335 /********************************************************************
337 * set_kdebugflag - Define the debugging level for the kernel
340 static int set_kdebugflag (int requested_level)
342 if (new_style_driver && ifunit < 0)
344 if (ioctl(ppp_dev_fd, PPPIOCSDEBUG, &requested_level) < 0) {
345 if ( ! ok_error (errno) )
346 error("ioctl(PPPIOCSDEBUG): %m (line %d)", __LINE__);
349 SYSDEBUG ((LOG_INFO, "set kernel debugging level to %d",
354 /********************************************************************
356 * tty_establish_ppp - Turn the serial port into a ppp interface.
359 int tty_establish_ppp (int tty_fd)
364 * Ensure that the tty device is in exclusive mode.
366 if (ioctl(tty_fd, TIOCEXCL, 0) < 0) {
367 if ( ! ok_error ( errno ))
368 warn("Couldn't make tty exclusive: %m");
371 * Demand mode - prime the old ppp device to relinquish the unit.
373 if (!new_style_driver && looped
374 && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0) {
375 error("ioctl(transfer ppp unit): %m, line %d", __LINE__);
379 * Set the current tty to the PPP discpline
383 #define N_SYNC_PPP 14
385 ppp_disc = (new_style_driver && sync_serial)? N_SYNC_PPP: N_PPP;
386 if (ioctl(tty_fd, TIOCSETD, &ppp_disc) < 0) {
387 if ( ! ok_error (errno) ) {
388 error("Couldn't set tty to PPP discipline: %m");
393 ret_fd = generic_establish_ppp(tty_fd);
395 #define SC_RCVB (SC_RCV_B7_0 | SC_RCV_B7_1 | SC_RCV_EVNP | SC_RCV_ODDP)
396 #define SC_LOGB (SC_DEBUG | SC_LOG_INPKT | SC_LOG_OUTPKT | SC_LOG_RAWIN \
400 set_flags(ppp_fd, ((get_flags(ppp_fd) & ~(SC_RCVB | SC_LOGB))
401 | ((kdebugflag * SC_DEBUG) & SC_LOGB)));
403 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0 && !ok_error(errno))
404 warn("Couldn't reset tty to normal line discipline: %m");
410 /********************************************************************
412 * generic_establish_ppp - Turn the fd into a ppp interface.
414 int generic_establish_ppp (int fd)
418 if (new_style_driver) {
419 /* Open another instance of /dev/ppp and connect the channel to it */
422 if (ioctl(fd, PPPIOCGCHAN, &chindex) == -1) {
423 error("Couldn't get channel number: %m");
426 dbglog("using channel %d", chindex);
427 fd = open("/dev/ppp", O_RDWR);
429 error("Couldn't reopen /dev/ppp: %m");
432 if (ioctl(fd, PPPIOCATTCHAN, &chindex) < 0) {
433 error("Couldn't attach to channel %d: %m", chindex);
436 flags = fcntl(fd, F_GETFL);
437 if (flags == -1 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
438 warn("Couldn't set /dev/ppp (channel) to nonblock: %m");
443 if (!looped && !multilink) {
445 * Create a new PPP unit.
447 if (make_ppp_unit() < 0)
452 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) & ~SC_LOOP_TRAFFIC);
456 if (ioctl(fd, PPPIOCCONNECT, &ifunit) < 0) {
457 error("Couldn't attach to PPP unit %d: %m", ifunit);
464 * Old-style driver: find out which interface we were given.
467 if (ioctl(fd, PPPIOCGUNIT, &x) < 0) {
468 if (ok_error (errno))
470 fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
472 /* Check that we got the same unit again. */
473 if (looped && x != ifunit)
474 fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
478 * Fetch the initial file flags and reset blocking mode on the file.
480 initfdflags = fcntl(fd, F_GETFL);
481 if (initfdflags == -1 ||
482 fcntl(fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
483 if ( ! ok_error (errno))
484 warn("Couldn't set device to non-blocking mode: %m");
491 * Enable debug in the driver if requested.
494 set_kdebugflag (kdebugflag);
496 SYSDEBUG ((LOG_NOTICE, "Using version %d.%d.%d of PPP driver",
497 driver_version, driver_modification, driver_patch));
507 /********************************************************************
509 * tty_disestablish_ppp - Restore the serial port to normal operation.
510 * This shouldn't call die() because it's called from die().
513 void tty_disestablish_ppp(int tty_fd)
517 * Flush the tty output buffer so that the TIOCSETD doesn't hang.
519 if (tcflush(tty_fd, TCIOFLUSH) < 0)
520 warn("tcflush failed: %m");
522 * Restore the previous line discipline
524 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
525 if ( ! ok_error (errno))
526 error("ioctl(TIOCSETD, N_TTY): %m (line %d)", __LINE__);
529 if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
530 if ( ! ok_error (errno))
531 warn("ioctl(TIOCNXCL): %m (line %d)", __LINE__);
534 /* Reset non-blocking mode on fd. */
535 if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0) {
536 if ( ! ok_error (errno))
537 warn("Couldn't restore device fd flags: %m");
542 generic_disestablish_ppp(tty_fd);
545 /********************************************************************
547 * generic_disestablish_ppp - Restore device components to normal
548 * operation, and reconnect the ppp unit to the loopback if in demand
549 * mode. This shouldn't call die() because it's called from die().
551 void generic_disestablish_ppp(int dev_fd)
553 if (new_style_driver) {
557 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_LOOP_TRAFFIC);
559 } else if (ifunit >= 0 && ioctl(ppp_dev_fd, PPPIOCDETACH) < 0)
560 error("Couldn't release PPP unit: %m");
562 remove_fd(ppp_dev_fd);
564 /* old-style driver */
566 set_ppp_fd(slave_fd);
571 * make_ppp_unit - make a new ppp unit for ppp_dev_fd.
572 * Assumes new_style_driver.
574 static int make_ppp_unit()
579 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
580 if (x < 0 && req_unit >= 0 && errno == EEXIST) {
581 warn("Couldn't allocate PPP unit %d as it is already in use");
583 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
586 error("Couldn't create new ppp unit: %m");
591 * cfg_bundle - configure the existing bundle.
592 * Used in demand mode.
594 void cfg_bundle(int mrru, int mtru, int rssn, int tssn)
598 if (!new_style_driver)
601 /* set the mrru, mtu and flags */
602 if (ioctl(ppp_dev_fd, PPPIOCSMRRU, &mrru) < 0)
603 error("Couldn't set MRRU: %m");
604 flags = get_flags(ppp_dev_fd);
605 flags &= ~(SC_MP_SHORTSEQ | SC_MP_XSHORTSEQ);
606 flags |= (rssn? SC_MP_SHORTSEQ: 0) | (tssn? SC_MP_XSHORTSEQ: 0)
607 | (mrru? SC_MULTILINK: 0);
609 set_flags(ppp_dev_fd, flags);
611 /* connect up the channel */
612 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifunit) < 0)
613 fatal("Couldn't attach to PPP unit %d: %m", ifunit);
618 * make_new_bundle - create a new PPP unit (i.e. a bundle)
619 * and connect our channel to it. This should only get called
620 * if `multilink' was set at the time establish_ppp was called.
621 * In demand mode this uses our existing bundle instead of making
624 void make_new_bundle(int mrru, int mtru, int rssn, int tssn)
626 if (!new_style_driver)
629 /* make us a ppp unit */
630 if (make_ppp_unit() < 0)
633 /* set the mrru and flags */
634 cfg_bundle(mrru, mtru, rssn, tssn);
638 * bundle_attach - attach our link to a given PPP unit.
639 * We assume the unit is controlled by another pppd.
641 int bundle_attach(int ifnum)
643 if (!new_style_driver)
646 if (ioctl(ppp_dev_fd, PPPIOCATTACH, &ifnum) < 0) {
648 return 0; /* doesn't still exist */
649 fatal("Couldn't attach to interface unit %d: %m\n", ifnum);
651 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifnum) < 0)
652 fatal("Couldn't connect to interface unit %d: %m", ifnum);
653 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_MULTILINK);
659 /********************************************************************
661 * clean_check - Fetch the flags for the device and generate
662 * appropriate error messages.
664 void clean_check(void)
670 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
672 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
674 s = "all had bit 7 set to 1";
678 s = "all had bit 7 set to 0";
682 s = "all had odd parity";
686 s = "all had even parity";
691 warn("Receive serial link is not 8-bit clean:");
692 warn("Problem: %s", s);
700 * List of valid speeds.
704 int speed_int, speed_val;
787 /********************************************************************
789 * Translate from bits/second to a speed_t.
792 static int translate_speed (int bps)
794 struct speed *speedp;
797 for (speedp = speeds; speedp->speed_int; speedp++) {
798 if (bps == speedp->speed_int)
799 return speedp->speed_val;
801 warn("speed %d not supported", bps);
806 /********************************************************************
808 * Translate from a speed_t to bits/second.
811 static int baud_rate_of (int speed)
813 struct speed *speedp;
816 for (speedp = speeds; speedp->speed_int; speedp++) {
817 if (speed == speedp->speed_val)
818 return speedp->speed_int;
824 /********************************************************************
826 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
827 * at the requested speed, etc. If `local' is true, set CLOCAL
828 * regardless of whether the modem option was specified.
831 void set_up_tty(int tty_fd, int local)
837 if (tcgetattr(tty_fd, &tios) < 0) {
838 if (!ok_error(errno))
839 fatal("tcgetattr: %m (line %d)", __LINE__);
846 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
847 tios.c_cflag |= CS8 | CREAD | HUPCL;
849 tios.c_iflag = IGNBRK | IGNPAR;
853 tios.c_cc[VTIME] = 0;
856 tios.c_cflag ^= (CLOCAL | HUPCL);
860 tios.c_cflag |= CRTSCTS;
864 tios.c_iflag |= IXON | IXOFF;
865 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
866 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
870 tios.c_cflag &= ~CRTSCTS;
877 speed = translate_speed(inspeed);
879 cfsetospeed (&tios, speed);
880 cfsetispeed (&tios, speed);
883 * We can't proceed if the serial port speed is B0,
884 * since that implies that the serial port is disabled.
887 speed = cfgetospeed(&tios);
889 fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
892 if (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0)
893 if (!ok_error(errno))
894 fatal("tcsetattr: %m (line %d)", __LINE__);
896 baud_rate = baud_rate_of(speed);
900 /********************************************************************
902 * setdtr - control the DTR line on the serial port.
903 * This is called from die(), so it shouldn't call die().
906 void setdtr (int tty_fd, int on)
908 int modembits = TIOCM_DTR;
910 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
913 /********************************************************************
915 * restore_tty - restore the terminal to the saved settings.
918 void restore_tty (int tty_fd)
923 * Turn off echoing, because otherwise we can get into
924 * a loop with the tty and the modem echoing to each other.
925 * We presume we are the sole user of this tty device, so
926 * when we close it, it will revert to its defaults anyway.
929 inittermios.c_lflag &= ~(ECHO | ECHONL);
931 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
932 if (! ok_error (errno))
933 warn("tcsetattr: %m (line %d)", __LINE__);
938 /********************************************************************
940 * output - Output PPP packet.
943 void output (int unit, unsigned char *p, int len)
948 dump_packet("sent", p, len);
950 if (len < PPP_HDRLEN)
952 if (new_style_driver) {
955 proto = (p[0] << 8) + p[1];
956 if (ifunit >= 0 && !(proto >= 0xc000 || proto == PPP_CCPFRAG))
959 if (write(fd, p, len) < 0) {
960 if (errno == EWOULDBLOCK || errno == ENOBUFS
961 || errno == ENXIO || errno == EIO || errno == EINTR)
962 warn("write: warning: %m (%d)", errno);
964 error("write: %m (%d)", errno);
968 /********************************************************************
970 * wait_input - wait until there is data available,
971 * for the length of time specified by *timo (indefinite
975 void wait_input(struct timeval *timo)
982 n = select(max_in_fd + 1, &ready, NULL, &exc, timo);
983 if (n < 0 && errno != EINTR)
988 * add_fd - add an fd to the set that wait_input waits for.
998 * remove_fd - remove an fd from the set that wait_input waits for.
1000 void remove_fd(int fd)
1002 FD_CLR(fd, &in_fds);
1006 /********************************************************************
1008 * read_packet - get a PPP packet from the serial device.
1011 int read_packet (unsigned char *buf)
1015 len = PPP_MRU + PPP_HDRLEN;
1016 if (new_style_driver) {
1017 *buf++ = PPP_ALLSTATIONS;
1023 nr = read(ppp_fd, buf, len);
1024 if (nr < 0 && errno != EWOULDBLOCK && errno != EIO && errno != EINTR)
1026 if (nr < 0 && errno == ENXIO)
1029 if (nr < 0 && new_style_driver && ifunit >= 0) {
1030 /* N.B. we read ppp_fd first since LCP packets come in there. */
1031 nr = read(ppp_dev_fd, buf, len);
1032 if (nr < 0 && errno != EWOULDBLOCK && errno != EIO && errno != EINTR)
1033 error("read /dev/ppp: %m");
1034 if (nr < 0 && errno == ENXIO)
1037 return (new_style_driver && nr > 0)? nr+2: nr;
1040 /********************************************************************
1042 * get_loop_output - get outgoing packets from the ppp device,
1043 * and detect when we want to bring the real link up.
1044 * Return value is 1 if we need to bring up the link, 0 otherwise.
1047 get_loop_output(void)
1052 if (new_style_driver) {
1053 while ((n = read_packet(inpacket_buf)) > 0)
1054 if (loop_frame(inpacket_buf, n))
1059 while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
1060 if (loop_chars(inbuf, n))
1064 fatal("eof on loopback");
1066 if (errno != EWOULDBLOCK)
1067 fatal("read from loopback: %m(%d)", errno);
1073 * netif_set_mtu - set the MTU on the PPP network interface.
1076 netif_set_mtu(int unit, int mtu)
1080 SYSDEBUG ((LOG_DEBUG, "netif_set_mtu: mtu = %d\n", mtu));
1082 memset (&ifr, '\0', sizeof (ifr));
1083 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1086 if (ifunit >= 0 && ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
1087 error("ioctl(SIOCSIFMTU): %m (line %d)", __LINE__);
1090 /********************************************************************
1092 * tty_send_config - configure the transmit characteristics of
1093 * the ppp interface.
1096 void tty_send_config (int mtu,u_int32_t asyncmap,int pcomp,int accomp)
1101 * Set the asyncmap and other parameters for the ppp device
1106 SYSDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
1107 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
1108 if (!ok_error(errno))
1109 fatal("ioctl(PPPIOCSASYNCMAP): %m (line %d)", __LINE__);
1113 x = get_flags(ppp_fd);
1114 x = pcomp ? x | SC_COMP_PROT : x & ~SC_COMP_PROT;
1115 x = accomp ? x | SC_COMP_AC : x & ~SC_COMP_AC;
1116 x = sync_serial ? x | SC_SYNC : x & ~SC_SYNC;
1117 set_flags(ppp_fd, x);
1120 /********************************************************************
1122 * tty_set_xaccm - set the extended transmit ACCM for the interface.
1125 void tty_set_xaccm (ext_accm accm)
1127 SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
1128 accm[0], accm[1], accm[2], accm[3]));
1132 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
1133 if ( ! ok_error (errno))
1134 warn("ioctl(set extended ACCM): %m (line %d)", __LINE__);
1138 /********************************************************************
1140 * tty_recv_config - configure the receive-side characteristics of
1141 * the ppp interface.
1144 void tty_recv_config (int mru,u_int32_t asyncmap,int pcomp,int accomp)
1146 SYSDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
1148 * If we were called because the link has gone down then there is nothing
1149 * which may be done. Just return without incident.
1154 * Set the receiver parameters
1156 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
1157 if ( ! ok_error (errno))
1158 error("ioctl(PPPIOCSMRU): %m (line %d)", __LINE__);
1160 if (new_style_driver && ifunit >= 0
1161 && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
1162 error("Couldn't set MRU in generic PPP layer: %m");
1164 SYSDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
1165 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
1166 if (!ok_error(errno))
1167 error("ioctl(PPPIOCSRASYNCMAP): %m (line %d)", __LINE__);
1171 /********************************************************************
1173 * ccp_test - ask kernel whether a given compression method
1174 * is acceptable for use.
1177 int ccp_test (int unit, u_char *opt_ptr, int opt_len, int for_transmit)
1179 struct ppp_option_data data;
1181 memset (&data, '\0', sizeof (data));
1183 data.length = opt_len;
1184 data.transmit = for_transmit;
1186 if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1189 return (errno == ENOBUFS)? 0: -1;
1192 /********************************************************************
1194 * ccp_flags_set - inform kernel about the current state of CCP.
1197 void ccp_flags_set (int unit, int isopen, int isup)
1199 if (still_ppp() && ifunit >= 0) {
1200 int x = get_flags(ppp_dev_fd);
1201 x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
1202 x = isup? x | SC_CCP_UP : x &~ SC_CCP_UP;
1203 set_flags (ppp_dev_fd, x);
1209 * set_filters - set the active and pass filters in the kernel driver.
1211 int set_filters(struct bpf_program *pass, struct bpf_program *active)
1213 struct sock_fprog fp;
1215 fp.len = pass->bf_len;
1216 fp.filter = (struct sock_filter *) pass->bf_insns;
1217 if (ioctl(ppp_dev_fd, PPPIOCSPASS, &fp) < 0) {
1218 if (errno == ENOTTY)
1219 warn("kernel does not support PPP filtering");
1221 error("Couldn't set pass-filter in kernel: %m");
1224 fp.len = active->bf_len;
1225 fp.filter = (struct sock_filter *) active->bf_insns;
1226 if (ioctl(ppp_dev_fd, PPPIOCSACTIVE, &fp) < 0) {
1227 error("Couldn't set active-filter in kernel: %m");
1232 #endif /* PPP_FILTER */
1234 /********************************************************************
1236 * get_idle_time - return how long the link has been idle.
1239 get_idle_time(u, ip)
1241 struct ppp_idle *ip;
1243 return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
1246 /********************************************************************
1248 * get_ppp_stats - return statistics for the link.
1251 get_ppp_stats(u, stats)
1253 struct pppd_stats *stats;
1255 struct ifpppstatsreq req;
1257 memset (&req, 0, sizeof (req));
1259 req.stats_ptr = (caddr_t) &req.stats;
1260 strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
1261 if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
1262 error("Couldn't get PPP statistics: %m");
1265 stats->bytes_in = req.stats.p.ppp_ibytes;
1266 stats->bytes_out = req.stats.p.ppp_obytes;
1267 stats->pkts_in = req.stats.p.ppp_ipackets;
1268 stats->pkts_out = req.stats.p.ppp_opackets;
1272 /********************************************************************
1274 * ccp_fatal_error - returns 1 if decompression was disabled as a
1275 * result of an error detected after decompression of a packet,
1276 * 0 otherwise. This is necessary because of patent nonsense.
1279 int ccp_fatal_error (int unit)
1281 int x = get_flags(ppp_dev_fd);
1283 return x & SC_DC_FERROR;
1286 /********************************************************************
1288 * path_to_procfs - find the path to the proc file system mount point
1290 static char proc_path[MAXPATHLEN];
1291 static int proc_path_len;
1293 static char *path_to_procfs(const char *tail)
1295 struct mntent *mntent;
1298 if (proc_path_len == 0) {
1299 /* Default the mount location of /proc */
1300 strlcpy (proc_path, "/proc", sizeof(proc_path));
1302 fp = fopen(MOUNTED, "r");
1304 while ((mntent = getmntent(fp)) != NULL) {
1305 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1307 if (strcmp(mntent->mnt_type, "proc") == 0) {
1308 strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
1309 proc_path_len = strlen(proc_path);
1317 strlcpy(proc_path + proc_path_len, tail,
1318 sizeof(proc_path) - proc_path_len);
1323 * /proc/net/route parsing stuff.
1325 #define ROUTE_MAX_COLS 12
1326 FILE *route_fd = (FILE *) 0;
1327 static char route_buffer[512];
1328 static int route_dev_col, route_dest_col, route_gw_col;
1329 static int route_flags_col, route_mask_col;
1330 static int route_num_cols;
1332 static int open_route_table (void);
1333 static void close_route_table (void);
1334 static int read_route_table (struct rtentry *rt);
1336 /********************************************************************
1338 * close_route_table - close the interface to the route table
1341 static void close_route_table (void)
1343 if (route_fd != (FILE *) 0) {
1345 route_fd = (FILE *) 0;
1349 /********************************************************************
1351 * open_route_table - open the interface to the route table
1353 static char route_delims[] = " \t\n";
1355 static int open_route_table (void)
1359 close_route_table();
1361 path = path_to_procfs("/net/route");
1362 route_fd = fopen (path, "r");
1363 if (route_fd == NULL) {
1364 error("can't open routing table %s: %m", path);
1368 route_dev_col = 0; /* default to usual columns */
1371 route_flags_col = 3;
1375 /* parse header line */
1376 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1377 char *p = route_buffer, *q;
1379 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1381 if ((q = strtok(p, route_delims)) == 0)
1383 if (strcasecmp(q, "iface") == 0)
1384 route_dev_col = col;
1385 else if (strcasecmp(q, "destination") == 0)
1386 route_dest_col = col;
1387 else if (strcasecmp(q, "gateway") == 0)
1389 else if (strcasecmp(q, "flags") == 0)
1390 route_flags_col = col;
1391 else if (strcasecmp(q, "mask") == 0)
1392 route_mask_col = col;
1395 if (used && col >= route_num_cols)
1396 route_num_cols = col + 1;
1404 /********************************************************************
1406 * read_route_table - read the next entry from the route table
1409 static int read_route_table(struct rtentry *rt)
1411 char *cols[ROUTE_MAX_COLS], *p;
1414 memset (rt, '\0', sizeof (struct rtentry));
1416 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1420 for (col = 0; col < route_num_cols; ++col) {
1421 cols[col] = strtok(p, route_delims);
1422 if (cols[col] == NULL)
1423 return 0; /* didn't get enough columns */
1427 SIN_ADDR(rt->rt_dst) = strtoul(cols[route_dest_col], NULL, 16);
1428 SIN_ADDR(rt->rt_gateway) = strtoul(cols[route_gw_col], NULL, 16);
1429 SIN_ADDR(rt->rt_genmask) = strtoul(cols[route_mask_col], NULL, 16);
1431 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1432 rt->rt_dev = cols[route_dev_col];
1437 /********************************************************************
1439 * defaultroute_exists - determine if there is a default route
1442 static int defaultroute_exists (struct rtentry *rt)
1446 if (!open_route_table())
1449 while (read_route_table(rt) != 0) {
1450 if ((rt->rt_flags & RTF_UP) == 0)
1453 if (kernel_version > KVERSION(2,1,0) && SIN_ADDR(rt->rt_genmask) != 0)
1455 if (SIN_ADDR(rt->rt_dst) == 0L) {
1461 close_route_table();
1466 * have_route_to - determine if the system has any route to
1467 * a given IP address. `addr' is in network byte order.
1468 * Return value is 1 if yes, 0 if no, -1 if don't know.
1469 * For demand mode to work properly, we have to ignore routes
1470 * through our own interface.
1472 int have_route_to(u_int32_t addr)
1477 if (!open_route_table())
1478 return -1; /* don't know */
1480 while (read_route_table(&rt)) {
1481 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1483 if ((addr & SIN_ADDR(rt.rt_genmask)) == SIN_ADDR(rt.rt_dst)) {
1489 close_route_table();
1493 /********************************************************************
1495 * sifdefaultroute - assign a default route through the address given.
1498 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1502 if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0) {
1503 u_int32_t old_gateway = SIN_ADDR(rt.rt_gateway);
1505 if (old_gateway != gateway)
1506 error("not replacing existing default route to %s [%I]",
1507 rt.rt_dev, old_gateway);
1511 memset (&rt, '\0', sizeof (rt));
1512 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1513 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1515 if (kernel_version > KVERSION(2,1,0)) {
1516 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1517 SIN_ADDR(rt.rt_genmask) = 0L;
1520 SIN_ADDR(rt.rt_gateway) = gateway;
1522 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1523 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1524 if ( ! ok_error ( errno ))
1525 error("default route ioctl(SIOCADDRT): %m");
1529 default_route_gateway = gateway;
1533 /********************************************************************
1535 * cifdefaultroute - delete a default route through the address given.
1538 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1542 default_route_gateway = 0;
1544 memset (&rt, '\0', sizeof (rt));
1545 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1546 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1548 if (kernel_version > KVERSION(2,1,0)) {
1549 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1550 SIN_ADDR(rt.rt_genmask) = 0L;
1553 SIN_ADDR(rt.rt_gateway) = gateway;
1555 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1556 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1558 if ( ! ok_error ( errno ))
1559 error("default route ioctl(SIOCDELRT): %m");
1567 /********************************************************************
1569 * sifproxyarp - Make a proxy ARP entry for the peer.
1572 int sifproxyarp (int unit, u_int32_t his_adr)
1574 struct arpreq arpreq;
1577 if (has_proxy_arp == 0) {
1578 memset (&arpreq, '\0', sizeof(arpreq));
1580 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1581 SIN_ADDR(arpreq.arp_pa) = his_adr;
1582 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1584 * Get the hardware address of an interface on the same subnet
1585 * as our local address.
1587 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
1588 sizeof(proxy_arp_dev))) {
1589 error("Cannot determine ethernet address for proxy ARP");
1592 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1594 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
1595 if ( ! ok_error ( errno ))
1596 error("ioctl(SIOCSARP): %m");
1599 proxy_arp_addr = his_adr;
1603 forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
1604 if (forw_path != 0) {
1605 int fd = open(forw_path, O_WRONLY);
1607 if (write(fd, "1", 1) != 1)
1608 error("Couldn't enable IP forwarding: %m");
1618 /********************************************************************
1620 * cifproxyarp - Delete the proxy ARP entry for the peer.
1623 int cifproxyarp (int unit, u_int32_t his_adr)
1625 struct arpreq arpreq;
1627 if (has_proxy_arp) {
1629 memset (&arpreq, '\0', sizeof(arpreq));
1630 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1631 SIN_ADDR(arpreq.arp_pa) = his_adr;
1632 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1633 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1635 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
1636 if ( ! ok_error ( errno ))
1637 warn("ioctl(SIOCDARP): %m");
1644 /********************************************************************
1646 * get_ether_addr - get the hardware address of an interface on the
1647 * the same subnet as ipaddr.
1650 static int get_ether_addr (u_int32_t ipaddr,
1651 struct sockaddr *hwaddr,
1652 char *name, int namelen)
1654 struct ifreq *ifr, *ifend;
1655 u_int32_t ina, mask;
1657 struct ifreq ifreq, bestifreq;
1659 struct ifreq ifs[MAX_IFS];
1661 u_int32_t bestmask=0;
1662 int found_interface = 0;
1664 ifc.ifc_len = sizeof(ifs);
1666 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1667 if ( ! ok_error ( errno ))
1668 error("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
1672 SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1673 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1675 * Scan through looking for an interface with an Internet
1676 * address on the same subnet as `ipaddr'.
1678 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1679 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1680 if (ifr->ifr_addr.sa_family == AF_INET) {
1681 ina = SIN_ADDR(ifr->ifr_addr);
1682 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1683 SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1686 * Check that the interface is up, and not point-to-point
1689 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1692 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1695 * Get its netmask and check that it's on the right subnet.
1697 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1700 mask = SIN_ADDR(ifreq.ifr_addr);
1701 SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1702 ip_ntoa(ina), ntohl(mask)));
1704 if (((ipaddr ^ ina) & mask) != 0)
1705 continue; /* no match */
1707 if (mask >= bestmask) {
1708 /* Compare using >= instead of > -- it is possible for
1709 an interface to have a netmask of 0.0.0.0 */
1710 found_interface = 1;
1717 if (!found_interface) return 0;
1719 strlcpy(name, bestifreq.ifr_name, namelen);
1721 /* trim off the :1 in eth0:1 */
1722 aliasp = strchr(name, ':');
1726 info("found interface %s for proxy arp", name);
1728 * Now get the hardware address.
1730 memset (&bestifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1731 if (ioctl (sock_fd, SIOCGIFHWADDR, &bestifreq) < 0) {
1732 error("SIOCGIFHWADDR(%s): %m", bestifreq.ifr_name);
1737 &bestifreq.ifr_hwaddr,
1738 sizeof (struct sockaddr));
1740 SYSDEBUG ((LOG_DEBUG,
1741 "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1742 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1743 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1744 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1745 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1746 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1747 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1748 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1749 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1754 * get_if_hwaddr - get the hardware address for the specified
1755 * network interface device.
1758 get_if_hwaddr(u_char *addr, char *name)
1763 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
1766 memset(&ifreq.ifr_hwaddr, 0, sizeof(struct sockaddr));
1767 strlcpy(ifreq.ifr_name, name, sizeof(ifreq.ifr_name));
1768 ret = ioctl(sock_fd, SIOCGIFHWADDR, &ifreq);
1771 memcpy(addr, ifreq.ifr_hwaddr.sa_data, 6);
1776 * get_first_ethernet - return the name of the first ethernet-style
1777 * interface on this system.
1780 get_first_ethernet()
1785 /********************************************************************
1787 * Return user specified netmask, modified by any mask we might determine
1788 * for address `addr' (in network byte order).
1789 * Here we scan through the system's list of interfaces, looking for
1790 * any non-point-to-point interfaces which might appear to be on the same
1791 * network as `addr'. If we find any, we OR in their netmask to the
1792 * user-specified netmask.
1795 u_int32_t GetMask (u_int32_t addr)
1797 u_int32_t mask, nmask, ina;
1798 struct ifreq *ifr, *ifend, ifreq;
1800 struct ifreq ifs[MAX_IFS];
1804 if (IN_CLASSA(addr)) /* determine network mask for address class */
1805 nmask = IN_CLASSA_NET;
1806 else if (IN_CLASSB(addr))
1807 nmask = IN_CLASSB_NET;
1809 nmask = IN_CLASSC_NET;
1811 /* class D nets are disallowed by bad_ip_adrs */
1812 mask = netmask | htonl(nmask);
1814 * Scan through the system's network interfaces.
1816 ifc.ifc_len = sizeof(ifs);
1818 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1819 if ( ! ok_error ( errno ))
1820 warn("ioctl(SIOCGIFCONF): %m (line %d)", __LINE__);
1824 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1825 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1827 * Check the interface's internet address.
1829 if (ifr->ifr_addr.sa_family != AF_INET)
1831 ina = SIN_ADDR(ifr->ifr_addr);
1832 if (((ntohl(ina) ^ addr) & nmask) != 0)
1835 * Check that the interface is up, and not point-to-point nor loopback.
1837 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1838 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1841 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1844 * Get its netmask and OR it into our mask.
1846 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1848 mask |= SIN_ADDR(ifreq.ifr_addr);
1854 /********************************************************************
1856 * Internal routine to decode the version.modification.patch level
1859 static void decode_version (char *buf, int *version,
1860 int *modification, int *patch)
1864 *version = (int) strtoul (buf, &endp, 10);
1868 if (endp != buf && *endp == '.') {
1870 *modification = (int) strtoul (buf, &endp, 10);
1871 if (endp != buf && *endp == '.') {
1873 *patch = (int) strtoul (buf, &buf, 10);
1878 /********************************************************************
1880 * Procedure to determine if the PPP line discipline is registered.
1884 ppp_registered(void)
1892 * We used to open the serial device and set it to the ppp line
1893 * discipline here, in order to create a ppp unit. But that is
1894 * not a good idea - the user might have specified a device that
1895 * they can't open (permission, or maybe it doesn't really exist).
1896 * So we grab a pty master/slave pair and use that.
1898 if (!get_pty(&mfd, &local_fd, slave, 0)) {
1899 no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
1904 * Try to put the device into the PPP discipline.
1906 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
1907 error("ioctl(TIOCSETD(PPP)): %m (line %d)", __LINE__);
1916 /********************************************************************
1918 * ppp_available - check whether the system has any ppp interfaces
1919 * (in fact we check whether we can do an ioctl on ppp0).
1922 int ppp_available(void)
1927 int my_version, my_modification, my_patch;
1928 int osmaj, osmin, ospatch;
1931 "This system lacks kernel support for PPP. This could be because\n"
1932 "the PPP kernel module could not be loaded, or because PPP was not\n"
1933 "included in the kernel configuration. If PPP was included as a\n"
1934 "module, try `/sbin/modprobe -v ppp'. If that fails, check that\n"
1935 "ppp.o exists in /lib/modules/`uname -r`/net.\n"
1936 "See README.linux file in the ppp distribution for more details.\n";
1938 /* get the kernel version now, since we are called before sys_init */
1940 osmaj = osmin = ospatch = 0;
1941 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
1942 kernel_version = KVERSION(osmaj, osmin, ospatch);
1944 fd = open("/dev/ppp", O_RDWR);
1946 if (fd < 0 && errno == ENOENT) {
1947 /* try making it and see if that helps. */
1948 if (mknod("/dev/ppp", S_IFCHR | S_IRUSR | S_IWUSR,
1949 makedev(108, 0)) >= 0) {
1950 fd = open("/dev/ppp", O_RDWR);
1952 info("Created /dev/ppp device node");
1954 unlink("/dev/ppp"); /* didn't work, undo the mknod */
1955 } else if (errno == EEXIST) {
1956 fd = open("/dev/ppp", O_RDWR);
1961 new_style_driver = 1;
1963 /* XXX should get from driver */
1965 driver_modification = 4;
1970 if (kernel_version >= KVERSION(2,3,13)) {
1971 if (errno == ENOENT)
1973 "pppd is unable to open the /dev/ppp device.\n"
1974 "You need to create the /dev/ppp device node by\n"
1975 "executing the following command as root:\n"
1976 " mknod /dev/ppp c 108 0\n";
1981 * Open a socket for doing the ioctl operations.
1983 s = socket(AF_INET, SOCK_DGRAM, 0);
1987 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1988 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1990 * If the device did not exist then attempt to create one by putting the
1991 * current tty into the PPP discipline. If this works then obtain the
1992 * flags for the device again.
1995 if (ppp_registered()) {
1996 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1997 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
2001 * Ensure that the hardware address is for PPP and not something else
2004 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
2006 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
2010 * This is the PPP device. Validate the version of the driver at this
2011 * point to ensure that this program will work with the driver.
2014 char abBuffer [1024];
2016 ifr.ifr_data = abBuffer;
2017 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
2019 error("Couldn't read driver version: %m");
2021 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
2024 decode_version(abBuffer,
2026 &driver_modification,
2029 * Validate the version of the driver against the version that we used.
2031 decode_version(VERSION,
2036 /* The version numbers must match */
2037 if (driver_version != my_version)
2040 /* The modification levels must be legal */
2041 if (driver_modification < 3) {
2042 if (driver_modification >= 2) {
2043 /* we can cope with 2.2.0 and above */
2052 slprintf(route_buffer, sizeof(route_buffer),
2053 "Sorry - PPP driver version %d.%d.%d is out of date\n",
2054 driver_version, driver_modification, driver_patch);
2056 no_ppp_msg = route_buffer;
2063 /********************************************************************
2065 * Update the wtmp file with the appropriate user name and tty device.
2068 void logwtmp (const char *line, const char *name, const char *host)
2070 struct utmp ut, *utp;
2071 pid_t mypid = getpid();
2077 * Update the signon database for users.
2078 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
2080 utmpname(_PATH_UTMP);
2082 while ((utp = getutent()) && (utp->ut_pid != mypid))
2086 memcpy(&ut, utp, sizeof(ut));
2088 /* some gettys/telnetds don't initialize utmp... */
2089 memset(&ut, 0, sizeof(ut));
2091 if (ut.ut_id[0] == 0)
2092 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
2094 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
2095 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
2099 ut.ut_type = USER_PROCESS;
2102 /* Insert the host name if one is supplied */
2104 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
2106 /* Insert the IP address of the remote system if IP is enabled */
2107 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
2108 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
2109 sizeof(ut.ut_addr));
2111 /* CL: Makes sure that the logout works */
2112 if (*host == 0 && *name==0)
2118 * Update the wtmp file.
2121 updwtmp(_PATH_WTMP, &ut);
2123 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
2125 flock(wtmp, LOCK_EX);
2127 if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
2128 warn("error writing %s: %m", _PATH_WTMP);
2130 flock(wtmp, LOCK_UN);
2138 /********************************************************************
2140 * sifvjcomp - config tcp header compression
2143 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2145 u_int x = get_flags(ppp_dev_fd);
2148 if (ioctl (ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
2149 if (! ok_error (errno))
2150 error("ioctl(PPPIOCSMAXCID): %m (line %d)", __LINE__);
2155 x = vjcomp ? x | SC_COMP_TCP : x &~ SC_COMP_TCP;
2156 x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
2157 set_flags (ppp_dev_fd, x);
2162 /********************************************************************
2164 * sifup - Config the interface up and enable IP packets to pass.
2171 memset (&ifr, '\0', sizeof (ifr));
2172 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2173 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2174 if (! ok_error (errno))
2175 error("ioctl (SIOCGIFFLAGS): %m (line %d)", __LINE__);
2179 ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
2180 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2181 if (! ok_error (errno))
2182 error("ioctl(SIOCSIFFLAGS): %m (line %d)", __LINE__);
2190 /********************************************************************
2192 * sifdown - Disable the indicated protocol and config the interface
2193 * down if there are no remaining protocols.
2200 if (if_is_up && --if_is_up > 0)
2203 memset (&ifr, '\0', sizeof (ifr));
2204 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2205 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2206 if (! ok_error (errno))
2207 error("ioctl (SIOCGIFFLAGS): %m (line %d)", __LINE__);
2211 ifr.ifr_flags &= ~IFF_UP;
2212 ifr.ifr_flags |= IFF_POINTOPOINT;
2213 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2214 if (! ok_error (errno))
2215 error("ioctl(SIOCSIFFLAGS): %m (line %d)", __LINE__);
2221 /********************************************************************
2223 * sifaddr - Config the interface IP addresses and netmask.
2226 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2232 memset (&ifr, '\0', sizeof (ifr));
2233 memset (&rt, '\0', sizeof (rt));
2235 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
2236 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2237 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2239 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2241 * Set our IP address
2243 SIN_ADDR(ifr.ifr_addr) = our_adr;
2244 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2245 if (errno != EEXIST) {
2246 if (! ok_error (errno))
2247 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2250 warn("ioctl(SIOCSIFADDR): Address already exists");
2255 * Set the gateway address
2257 SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
2258 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2259 if (! ok_error (errno))
2260 error("ioctl(SIOCSIFDSTADDR): %m (line %d)", __LINE__);
2265 * For recent kernels, force the netmask to 255.255.255.255.
2267 if (kernel_version >= KVERSION(2,1,16))
2269 if (net_mask != 0) {
2270 SIN_ADDR(ifr.ifr_netmask) = net_mask;
2271 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2272 if (! ok_error (errno))
2273 error("ioctl(SIOCSIFNETMASK): %m (line %d)", __LINE__);
2278 * Add the device route
2280 if (kernel_version < KVERSION(2,1,16)) {
2281 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2282 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2285 SIN_ADDR(rt.rt_gateway) = 0L;
2286 SIN_ADDR(rt.rt_dst) = his_adr;
2287 rt.rt_flags = RTF_UP | RTF_HOST;
2289 if (kernel_version > KVERSION(2,1,0)) {
2290 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2291 SIN_ADDR(rt.rt_genmask) = -1L;
2294 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2295 if (! ok_error (errno))
2296 error("ioctl(SIOCADDRT) device route: %m (line %d)", __LINE__);
2301 /* set ip_dynaddr in demand mode if address changes */
2302 if (demand && tune_kernel && !dynaddr_set
2303 && our_old_addr && our_old_addr != our_adr) {
2304 /* set ip_dynaddr if possible */
2308 path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
2309 if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
2310 if (write(fd, "1", 1) != 1)
2311 error("Couldn't enable dynamic IP addressing: %m");
2314 dynaddr_set = 1; /* only 1 attempt */
2321 /********************************************************************
2323 * cifaddr - Clear the interface IP addresses, and delete routes
2324 * through the interface if possible.
2327 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2331 if (kernel_version < KVERSION(2,1,16)) {
2333 * Delete the route through the device
2336 memset (&rt, '\0', sizeof (rt));
2338 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2339 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2342 SIN_ADDR(rt.rt_gateway) = 0;
2343 SIN_ADDR(rt.rt_dst) = his_adr;
2344 rt.rt_flags = RTF_UP | RTF_HOST;
2346 if (kernel_version > KVERSION(2,1,0)) {
2347 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2348 SIN_ADDR(rt.rt_genmask) = -1L;
2351 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2352 if (still_ppp() && ! ok_error (errno))
2353 error("ioctl(SIOCDELRT) device route: %m (line %d)", __LINE__);
2358 /* This way it is possible to have an IPX-only or IPv6-only interface */
2359 memset(&ifr, 0, sizeof(ifr));
2360 SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
2361 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2363 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2364 if (! ok_error (errno)) {
2365 error("ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2370 our_old_addr = our_adr;
2376 /********************************************************************
2378 * sif6addr - Config the interface with an IPv6 link-local address
2380 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2382 struct in6_ifreq ifr6;
2384 struct in6_rtmsg rt6;
2388 error("IPv6 socket creation failed: %m");
2391 memset(&ifr, 0, sizeof (ifr));
2392 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2393 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2394 error("sif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
2398 /* Local interface */
2399 memset(&ifr6, 0, sizeof(ifr6));
2400 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2401 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2402 ifr6.ifr6_prefixlen = 10;
2404 if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
2405 error("sif6addr: ioctl(SIOCSIFADDR): %m (line %d)", __LINE__);
2409 /* Route to remote host */
2410 memset(&rt6, 0, sizeof(rt6));
2411 IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
2412 rt6.rtmsg_flags = RTF_UP;
2413 rt6.rtmsg_dst_len = 10;
2414 rt6.rtmsg_ifindex = ifr.ifr_ifindex;
2415 rt6.rtmsg_metric = 1;
2417 if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
2418 error("sif6addr: ioctl(SIOCADDRT): %m (line %d)", __LINE__);
2426 /********************************************************************
2428 * cif6addr - Remove IPv6 address from interface
2430 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2433 struct in6_ifreq ifr6;
2437 error("IPv6 socket creation failed: %m");
2440 memset(&ifr, 0, sizeof(ifr));
2441 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2442 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2443 error("cif6addr: ioctl(SIOCGIFINDEX): %m (line %d)", __LINE__);
2447 memset(&ifr6, 0, sizeof(ifr6));
2448 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2449 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2450 ifr6.ifr6_prefixlen = 10;
2452 if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
2453 if (errno != EADDRNOTAVAIL) {
2454 if (! ok_error (errno))
2455 error("cif6addr: ioctl(SIOCDIFADDR): %m (line %d)", __LINE__);
2458 warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
2467 * get_pty - get a pty master/slave pair and chown the slave side
2468 * to the uid given. Assumes slave_name points to >= 16 bytes of space.
2471 get_pty(master_fdp, slave_fdp, slave_name, uid)
2477 int i, mfd, sfd = -1;
2479 struct termios tios;
2483 * Try the unix98 way first.
2485 mfd = open("/dev/ptmx", O_RDWR);
2488 if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
2489 slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
2490 chmod(pty_name, S_IRUSR | S_IWUSR);
2493 if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
2494 warn("Couldn't unlock pty slave %s: %m", pty_name);
2496 if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
2497 warn("Couldn't open pty slave %s: %m", pty_name);
2500 #endif /* TIOCGPTN */
2503 /* the old way - scan through the pty name space */
2504 for (i = 0; i < 64; ++i) {
2505 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2506 'p' + i / 16, i % 16);
2507 mfd = open(pty_name, O_RDWR, 0);
2510 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2512 fchown(sfd, uid, -1);
2513 fchmod(sfd, S_IRUSR | S_IWUSR);
2524 strlcpy(slave_name, pty_name, 16);
2527 if (tcgetattr(sfd, &tios) == 0) {
2528 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2529 tios.c_cflag |= CS8 | CREAD | CLOCAL;
2530 tios.c_iflag = IGNPAR;
2533 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2534 warn("couldn't set attributes on pty: %m");
2536 warn("couldn't get attributes on pty: %m");
2541 /********************************************************************
2543 * open_loopback - open the device we use for getting packets
2544 * in demand mode. Under Linux, we use a pty master/slave pair.
2547 open_ppp_loopback(void)
2552 if (new_style_driver) {
2553 /* allocate ourselves a ppp unit */
2554 if (make_ppp_unit() < 0)
2556 set_flags(ppp_dev_fd, SC_LOOP_TRAFFIC);
2557 set_kdebugflag(kdebugflag);
2562 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2563 fatal("No free pty for loopback");
2564 SYSDEBUG(("using %s for loopback", loop_name));
2566 set_ppp_fd(slave_fd);
2568 flags = fcntl(master_fd, F_GETFL);
2570 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2571 warn("couldn't set master loopback to nonblock: %m");
2573 flags = fcntl(ppp_fd, F_GETFL);
2575 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2576 warn("couldn't set slave loopback to nonblock: %m");
2578 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2579 fatal("ioctl(TIOCSETD): %m (line %d)", __LINE__);
2581 * Find out which interface we were given.
2583 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2584 fatal("ioctl(PPPIOCGUNIT): %m (line %d)", __LINE__);
2586 * Enable debug in the driver if requested.
2588 set_kdebugflag (kdebugflag);
2593 /********************************************************************
2595 * sifnpmode - Set the mode for handling packets for a given NP.
2599 sifnpmode(u, proto, mode)
2606 npi.protocol = proto;
2608 if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2609 if (! ok_error (errno))
2610 error("ioctl(PPPIOCSNPMODE, %d, %d): %m", proto, mode);
2617 /********************************************************************
2619 * sipxfaddr - Config the interface IPX networknumber
2622 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2629 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2631 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2633 if (! ok_error (errno))
2634 dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
2638 memset (&ifr, '\0', sizeof (ifr));
2639 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2641 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2642 sipx->sipx_family = AF_IPX;
2643 sipx->sipx_port = 0;
2644 sipx->sipx_network = htonl (network);
2645 sipx->sipx_type = IPX_FRAME_ETHERII;
2646 sipx->sipx_action = IPX_CRTITF;
2648 * Set the IPX device
2650 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2652 if (errno != EEXIST) {
2653 if (! ok_error (errno))
2654 dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (line %d)", __LINE__);
2657 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2666 /********************************************************************
2668 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2669 * are removed and the device is no longer able to pass IPX
2673 int cipxfaddr (int unit)
2680 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2682 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2684 if (! ok_error (errno))
2685 dbglog("socket(AF_IPX): %m (line %d)", __LINE__);
2689 memset (&ifr, '\0', sizeof (ifr));
2690 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2692 sipx->sipx_type = IPX_FRAME_ETHERII;
2693 sipx->sipx_action = IPX_DLTITF;
2694 sipx->sipx_family = AF_IPX;
2696 * Set the IPX device
2698 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2699 if (! ok_error (errno))
2700 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (line %d)", __LINE__);
2710 * Use the hostname as part of the random number seed.
2719 for (p = hostname; *p != 0; ++p)
2724 /********************************************************************
2726 * sys_check_options - check the options that the user specified
2730 sys_check_options(void)
2734 * Disable the IPX protocol if the support is not present in the kernel.
2738 if (ipxcp_protent.enabled_flag) {
2739 struct stat stat_buf;
2740 if ((path = path_to_procfs("/net/ipx_interface")) == 0
2741 || lstat(path, &stat_buf) < 0) {
2742 error("IPX support is not present in the kernel\n");
2743 ipxcp_protent.enabled_flag = 0;
2747 if (demand && driver_is_old) {
2748 option_error("demand dialling is not supported by kernel driver "
2749 "version %d.%d.%d", driver_version, driver_modification,
2753 if (multilink && !new_style_driver) {
2754 warn("Warning: multilink is not supported by the kernel driver");