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>
76 #include "patchlevel.h"
80 #if __GLIBC__ >= 2 && \
81 !(defined(__powerpc__) && __GLIBC__ == 2 && __GLIBC_MINOR__ == 0)
82 #include <netipx/ipx.h>
84 #include <linux/ipx.h>
86 #endif /* IPX_CHANGE */
89 #include <sys/locks.h>
95 * This is in linux/include/net/ipv6.h.
99 struct in6_addr ifr6_addr;
100 __u32 ifr6_prefixlen;
101 unsigned int ifr6_ifindex;
105 #define IN6_LLADDR_FROM_EUI64(sin6, eui64) do { \
106 memset(&sin6.s6_addr, 0, sizeof(struct in6_addr)); \
107 sin6.s6_addr16[0] = htons(0xfe80); \
108 eui64_copy(eui64, sin6.s6_addr32[2]); \
113 /* We can get an EIO error on an ioctl if the modem has hung up */
114 #define ok_error(num) ((num)==EIO)
116 static int tty_disc = N_TTY; /* The TTY discipline */
117 static int ppp_disc = N_PPP; /* The PPP discpline */
118 static int initfdflags = -1; /* Initial file descriptor flags for fd */
119 static int ppp_fd = -1; /* fd which is set to PPP discipline */
120 static int sock_fd = -1; /* socket for doing interface ioctls */
121 static int slave_fd = -1;
122 static int master_fd = -1;
124 static int sock6_fd = -1;
126 static int ppp_dev_fd = -1; /* fd for /dev/ppp (new style driver) */
127 static int chindex; /* channel index (new style driver) */
129 static fd_set in_fds; /* set of fds that wait_input waits for */
130 static int max_in_fd; /* highest fd set in in_fds */
132 static int has_proxy_arp = 0;
133 static int driver_version = 0;
134 static int driver_modification = 0;
135 static int driver_patch = 0;
136 static int driver_is_old = 0;
137 static int restore_term = 0; /* 1 => we've munged the terminal */
138 static struct termios inittermios; /* Initial TTY termios */
140 static int new_style_driver = 0;
142 static char loop_name[20];
143 static unsigned char inbuf[512]; /* buffer for chars read from loopback */
145 static int if_is_up; /* Interface has been marked up */
146 static u_int32_t default_route_gateway; /* Gateway for default route added */
147 static u_int32_t proxy_arp_addr; /* Addr for proxy arp entry added */
148 static char proxy_arp_dev[16]; /* Device for proxy arp entry */
149 static u_int32_t our_old_addr; /* for detecting address changes */
150 static int dynaddr_set; /* 1 if ip_dynaddr set */
151 static int looped; /* 1 if using loop */
153 static struct utsname utsname; /* for the kernel version */
154 static int kernel_version;
155 #define KVERSION(j,n,p) ((j)*1000000 + (n)*1000 + (p))
159 #define FLAGS_GOOD (IFF_UP | IFF_BROADCAST)
160 #define FLAGS_MASK (IFF_UP | IFF_BROADCAST | \
161 IFF_POINTOPOINT | IFF_LOOPBACK | IFF_NOARP)
163 #define SIN_ADDR(x) (((struct sockaddr_in *) (&(x)))->sin_addr.s_addr)
165 /* Prototypes for procedures local to this file. */
166 static int get_flags (int fd);
167 static void set_flags (int fd, int flags);
168 static int translate_speed (int bps);
169 static int baud_rate_of (int speed);
170 static void close_route_table (void);
171 static int open_route_table (void);
172 static int read_route_table (struct rtentry *rt);
173 static int defaultroute_exists (struct rtentry *rt);
174 static int get_ether_addr (u_int32_t ipaddr, struct sockaddr *hwaddr,
175 char *name, int namelen);
176 static void decode_version (char *buf, int *version, int *mod, int *patch);
177 static int set_kdebugflag(int level);
178 static int ppp_registered(void);
180 extern u_char inpacket_buf[]; /* borrowed from main.c */
183 * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
187 #define SET_SA_FAMILY(addr, family) \
188 memset ((char *) &(addr), '\0', sizeof(addr)); \
189 addr.sa_family = (family);
192 * Determine if the PPP connection should still be present.
197 /* new_fd is the fd of a tty */
198 static void set_ppp_fd (int new_fd)
200 SYSDEBUG ((LOG_DEBUG, "setting ppp_fd to %d\n", new_fd));
202 if (!new_style_driver)
206 static int still_ppp(void)
208 if (new_style_driver)
209 return !hungup && ppp_fd >= 0;
210 if (!hungup || ppp_fd == slave_fd)
213 set_ppp_fd(slave_fd);
219 /********************************************************************
221 * Functions to read and set the flags value in the device driver
224 static int get_flags (int fd)
228 if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &flags) < 0) {
229 if ( ok_error (errno) )
232 fatal("ioctl(PPPIOCGFLAGS): %m");
235 SYSDEBUG ((LOG_DEBUG, "get flags = %x\n", flags));
239 /********************************************************************/
241 static void set_flags (int fd, int flags)
243 SYSDEBUG ((LOG_DEBUG, "set flags = %x\n", flags));
245 if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &flags) < 0) {
246 if (! ok_error (errno) )
247 fatal("ioctl(PPPIOCSFLAGS, %x): %m", flags, errno);
251 /********************************************************************
253 * sys_init - System-dependent initialization.
260 openlog("pppd", LOG_PID | LOG_NDELAY, LOG_PPP);
261 setlogmask(LOG_UPTO(LOG_INFO));
263 setlogmask(LOG_UPTO(LOG_DEBUG));
265 if (new_style_driver) {
266 ppp_dev_fd = open("/dev/ppp", O_RDWR);
268 fatal("Couldn't open /dev/ppp: %m");
269 flags = fcntl(ppp_dev_fd, F_GETFL);
271 || fcntl(ppp_dev_fd, F_SETFL, flags | O_NONBLOCK) == -1)
272 warn("Couldn't set /dev/ppp to nonblock: %m");
275 /* Get an internet socket for doing socket ioctls. */
276 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
278 fatal("Couldn't create IP socket: %m(%d)", errno);
281 sock6_fd = socket(AF_INET6, SOCK_DGRAM, 0);
283 fatal("Couldn't create IPv6 socket: %m(%d)", errno);
290 /********************************************************************
292 * sys_cleanup - restore any system state we modified before exiting:
293 * mark the interface down, delete default route and/or proxy arp entry.
294 * This shouldn't call die() because it's called from die().
297 void sys_cleanup(void)
300 * Take down the device
307 * Delete any routes through the device.
309 if (default_route_gateway != 0)
310 cifdefaultroute(0, 0, default_route_gateway);
313 cifproxyarp(0, proxy_arp_addr);
316 /********************************************************************
318 * sys_close - Clean up in a child process before execing.
323 if (new_style_driver)
334 /********************************************************************
336 * set_kdebugflag - Define the debugging level for the kernel
339 static int set_kdebugflag (int requested_level)
341 if (new_style_driver && ifunit < 0)
343 if (ioctl(ppp_dev_fd, PPPIOCSDEBUG, &requested_level) < 0) {
344 if ( ! ok_error (errno) )
345 error("ioctl(PPPIOCSDEBUG): %m");
348 SYSDEBUG ((LOG_INFO, "set kernel debugging level to %d",
353 /********************************************************************
355 * establish_ppp - Turn the serial port into a ppp interface.
358 int 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");
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 if (new_style_driver) {
394 /* Open another instance of /dev/ppp and connect the channel to it */
397 if (ioctl(tty_fd, PPPIOCGCHAN, &chindex) == -1) {
398 error("Couldn't get channel number: %m");
401 dbglog("using channel %d", chindex);
402 fd = open("/dev/ppp", O_RDWR);
404 error("Couldn't reopen /dev/ppp: %m");
407 if (ioctl(fd, PPPIOCATTCHAN, &chindex) < 0) {
408 error("Couldn't attach to channel %d: %m", chindex);
411 flags = fcntl(fd, F_GETFL);
412 if (flags == -1 || fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
413 warn("Couldn't set /dev/ppp (channel) to nonblock: %m");
417 if (!looped && !multilink) {
419 * Create a new PPP unit.
422 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
423 if (x < 0 && req_unit >= 0 && errno == EEXIST) {
424 warn("Couldn't allocate PPP unit %d as it is already in use");
426 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
429 error("Couldn't create new ppp unit: %m");
435 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) & ~SC_LOOP_TRAFFIC);
439 if (ioctl(fd, PPPIOCCONNECT, &ifunit) < 0) {
440 error("Couldn't attach to PPP unit %d: %m", ifunit);
447 * Old-style driver: find out which interface we were given.
450 if (ioctl(tty_fd, PPPIOCGUNIT, &x) < 0) {
451 if ( ! ok_error (errno))
452 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
454 /* Check that we got the same unit again. */
455 if (looped && x != ifunit)
456 fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
460 * Fetch the initial file flags and reset blocking mode on the file.
462 initfdflags = fcntl(tty_fd, F_GETFL);
463 if (initfdflags == -1 ||
464 fcntl(tty_fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
465 if ( ! ok_error (errno))
466 warn("Couldn't set device to non-blocking mode: %m");
473 * Enable debug in the driver if requested.
476 set_kdebugflag (kdebugflag);
478 set_flags(ppp_fd, get_flags(ppp_fd) & ~(SC_RCV_B7_0 | SC_RCV_B7_1 |
479 SC_RCV_EVNP | SC_RCV_ODDP));
481 SYSDEBUG ((LOG_NOTICE, "Using version %d.%d.%d of PPP driver",
482 driver_version, driver_modification, driver_patch));
489 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0 && !ok_error(errno))
490 warn("Couldn't reset tty to normal line discipline: %m");
494 /********************************************************************
496 * disestablish_ppp - Restore the serial port to normal operation.
497 * This shouldn't call die() because it's called from die().
500 void disestablish_ppp(int tty_fd)
504 * Flush the tty output buffer so that the TIOCSETD doesn't hang.
506 if (tcflush(tty_fd, TCIOFLUSH) < 0)
507 warn("tcflush failed: %m");
509 * Restore the previous line discipline
511 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
512 if ( ! ok_error (errno))
513 error("ioctl(TIOCSETD, N_TTY): %m");
516 if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
517 if ( ! ok_error (errno))
518 warn("ioctl(TIOCNXCL): %m(%d)", errno);
521 /* Reset non-blocking mode on fd. */
522 if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0) {
523 if ( ! ok_error (errno))
524 warn("Couldn't restore device fd flags: %m");
529 if (new_style_driver) {
532 if (!looped && ioctl(ppp_dev_fd, PPPIOCDETACH) < 0)
533 error("Couldn't release PPP unit: %m");
535 remove_fd(ppp_dev_fd);
540 * bundle_attach - attach our link to a given PPP unit.
542 int bundle_attach(int ifnum)
546 if (!new_style_driver)
549 if (ioctl(ppp_dev_fd, PPPIOCATTACH, &ifnum) < 0) {
550 error("Couldn't attach to interface unit %d: %m\n", ifnum);
553 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_MULTILINK);
554 if (ioctl(ppp_dev_fd, PPPIOCSMRRU, &mrru) < 0)
555 error("Couldn't set interface MRRU: %m");
557 if (ioctl(ppp_fd, PPPIOCCONNECT, &ifnum) < 0) {
558 error("Couldn't connect to interface unit %d: %m", ifnum);
562 dbglog("bundle_attach succeeded");
566 /********************************************************************
568 * clean_check - Fetch the flags for the device and generate
569 * appropriate error messages.
571 void clean_check(void)
577 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
579 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
581 s = "all had bit 7 set to 1";
585 s = "all had bit 7 set to 0";
589 s = "all had odd parity";
593 s = "all had even parity";
598 warn("Receive serial link is not 8-bit clean:");
599 warn("Problem: %s", s);
607 * List of valid speeds.
611 int speed_int, speed_val;
688 /********************************************************************
690 * Translate from bits/second to a speed_t.
693 static int translate_speed (int bps)
695 struct speed *speedp;
698 for (speedp = speeds; speedp->speed_int; speedp++) {
699 if (bps == speedp->speed_int)
700 return speedp->speed_val;
702 warn("speed %d not supported", bps);
707 /********************************************************************
709 * Translate from a speed_t to bits/second.
712 static int baud_rate_of (int speed)
714 struct speed *speedp;
717 for (speedp = speeds; speedp->speed_int; speedp++) {
718 if (speed == speedp->speed_val)
719 return speedp->speed_int;
725 /********************************************************************
727 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
728 * at the requested speed, etc. If `local' is true, set CLOCAL
729 * regardless of whether the modem option was specified.
732 void set_up_tty(int tty_fd, int local)
738 if (tcgetattr(tty_fd, &tios) < 0) {
739 if (!ok_error(errno))
740 fatal("tcgetattr: %m(%d)", errno);
747 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
748 tios.c_cflag |= CS8 | CREAD | HUPCL;
750 tios.c_iflag = IGNBRK | IGNPAR;
754 tios.c_cc[VTIME] = 0;
757 tios.c_cflag ^= (CLOCAL | HUPCL);
761 tios.c_cflag |= CRTSCTS;
765 tios.c_iflag |= IXON | IXOFF;
766 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
767 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
771 tios.c_cflag &= ~CRTSCTS;
778 speed = translate_speed(inspeed);
780 cfsetospeed (&tios, speed);
781 cfsetispeed (&tios, speed);
784 * We can't proceed if the serial port speed is B0,
785 * since that implies that the serial port is disabled.
788 speed = cfgetospeed(&tios);
790 fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
793 if (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0)
794 if (!ok_error(errno))
795 fatal("tcsetattr: %m");
797 baud_rate = baud_rate_of(speed);
801 /********************************************************************
803 * setdtr - control the DTR line on the serial port.
804 * This is called from die(), so it shouldn't call die().
807 void setdtr (int tty_fd, int on)
809 int modembits = TIOCM_DTR;
811 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
814 /********************************************************************
816 * restore_tty - restore the terminal to the saved settings.
819 void restore_tty (int tty_fd)
824 * Turn off echoing, because otherwise we can get into
825 * a loop with the tty and the modem echoing to each other.
826 * We presume we are the sole user of this tty device, so
827 * when we close it, it will revert to its defaults anyway.
830 inittermios.c_lflag &= ~(ECHO | ECHONL);
832 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
833 if (! ok_error (errno))
834 warn("tcsetattr: %m");
839 /********************************************************************
841 * output - Output PPP packet.
844 void output (int unit, unsigned char *p, int len)
850 dbglog("sent %P", p, len);
852 if (len < PPP_HDRLEN)
854 if (new_style_driver) {
857 proto = (p[0] << 8) + p[1];
858 if (!multilink && proto != PPP_LCP)
861 if (write(fd, p, len) < 0) {
862 if (errno == EWOULDBLOCK || errno == ENOBUFS
863 || errno == ENXIO || errno == EIO || errno == EINTR)
864 warn("write: warning: %m (%d)", errno);
866 error("write: %m (%d)", errno);
870 /********************************************************************
872 * wait_input - wait until there is data available,
873 * for the length of time specified by *timo (indefinite
877 void wait_input(struct timeval *timo)
884 n = select(max_in_fd + 1, &ready, NULL, &exc, timo);
885 if (n < 0 && errno != EINTR)
886 fatal("select: %m(%d)", errno);
890 * add_fd - add an fd to the set that wait_input waits for.
900 * remove_fd - remove an fd from the set that wait_input waits for.
902 void remove_fd(int fd)
908 /********************************************************************
910 * read_packet - get a PPP packet from the serial device.
913 int read_packet (unsigned char *buf)
917 len = PPP_MRU + PPP_HDRLEN;
918 if (new_style_driver) {
919 *buf++ = PPP_ALLSTATIONS;
925 nr = read(ppp_fd, buf, len);
926 if (nr < 0 && errno != EWOULDBLOCK && errno != EIO)
929 if (nr < 0 && new_style_driver && !multilink) {
930 /* N.B. we read ppp_fd first since LCP packets come in there. */
931 nr = read(ppp_dev_fd, buf, len);
932 if (nr < 0 && errno != EWOULDBLOCK && errno != EIO)
933 error("read /dev/ppp: %m");
935 return (new_style_driver && nr > 0)? nr+2: nr;
938 /********************************************************************
940 * get_loop_output - get outgoing packets from the ppp device,
941 * and detect when we want to bring the real link up.
942 * Return value is 1 if we need to bring up the link, 0 otherwise.
945 get_loop_output(void)
950 if (new_style_driver) {
951 while ((n = read_packet(inpacket_buf)) > 0)
952 if (loop_frame(inpacket_buf, n))
957 while ((n = read(master_fd, inbuf, sizeof(inbuf))) > 0)
958 if (loop_chars(inbuf, n))
962 fatal("eof on loopback");
964 if (errno != EWOULDBLOCK)
965 fatal("read from loopback: %m(%d)", errno);
970 /********************************************************************
972 * ppp_send_config - configure the transmit characteristics of
976 void ppp_send_config (int unit,int mtu,u_int32_t asyncmap,int pcomp,int accomp)
981 SYSDEBUG ((LOG_DEBUG, "send_config: mtu = %d\n", mtu));
983 * Set the MTU and other parameters for the ppp device
985 memset (&ifr, '\0', sizeof (ifr));
986 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
989 if (ifunit >= 0 && ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
990 fatal("ioctl(SIOCSIFMTU): %m(%d)", errno);
994 SYSDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
995 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
996 if (!ok_error(errno))
997 fatal("ioctl(PPPIOCSASYNCMAP): %m(%d)", errno);
1001 x = get_flags(ppp_fd);
1002 x = pcomp ? x | SC_COMP_PROT : x & ~SC_COMP_PROT;
1003 x = accomp ? x | SC_COMP_AC : x & ~SC_COMP_AC;
1004 x = sync_serial ? x | SC_SYNC : x & ~SC_SYNC;
1005 set_flags(ppp_fd, x);
1008 /********************************************************************
1010 * ppp_set_xaccm - set the extended transmit ACCM for the interface.
1013 void ppp_set_xaccm (int unit, ext_accm accm)
1015 SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
1016 accm[0], accm[1], accm[2], accm[3]));
1020 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
1021 if ( ! ok_error (errno))
1022 warn("ioctl(set extended ACCM): %m(%d)", errno);
1026 /********************************************************************
1028 * ppp_recv_config - configure the receive-side characteristics of
1029 * the ppp interface.
1032 void ppp_recv_config (int unit,int mru,u_int32_t asyncmap,int pcomp,int accomp)
1034 SYSDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
1036 * If we were called because the link has gone down then there is nothing
1037 * which may be done. Just return without incident.
1042 * Set the receiver parameters
1044 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
1045 if ( ! ok_error (errno))
1046 error("ioctl(PPPIOCSMRU): %m(%d)", errno);
1048 if (new_style_driver && ifunit >= 0
1049 && ioctl(ppp_dev_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
1050 error("Couldn't set MRU in generic PPP layer: %m");
1052 SYSDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
1053 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
1054 if (!ok_error(errno))
1055 error("ioctl(PPPIOCSRASYNCMAP): %m(%d)", errno);
1059 /********************************************************************
1061 * ccp_test - ask kernel whether a given compression method
1062 * is acceptable for use.
1065 int ccp_test (int unit, u_char *opt_ptr, int opt_len, int for_transmit)
1067 struct ppp_option_data data;
1069 memset (&data, '\0', sizeof (data));
1071 data.length = opt_len;
1072 data.transmit = for_transmit;
1074 if (ioctl(ppp_dev_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1077 return (errno == ENOBUFS)? 0: -1;
1080 /********************************************************************
1082 * ccp_flags_set - inform kernel about the current state of CCP.
1085 void ccp_flags_set (int unit, int isopen, int isup)
1088 int x = get_flags(ppp_dev_fd);
1089 x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
1090 x = isup? x | SC_CCP_UP : x &~ SC_CCP_UP;
1091 set_flags (ppp_dev_fd, x);
1095 /********************************************************************
1097 * get_idle_time - return how long the link has been idle.
1100 get_idle_time(u, ip)
1102 struct ppp_idle *ip;
1104 return ioctl(ppp_dev_fd, PPPIOCGIDLE, ip) >= 0;
1107 /********************************************************************
1109 * get_ppp_stats - return statistics for the link.
1112 get_ppp_stats(u, stats)
1114 struct pppd_stats *stats;
1116 struct ifpppstatsreq req;
1118 memset (&req, 0, sizeof (req));
1120 req.stats_ptr = (caddr_t) &req.stats;
1121 strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
1122 if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
1123 error("Couldn't get PPP statistics: %m");
1126 stats->bytes_in = req.stats.p.ppp_ibytes;
1127 stats->bytes_out = req.stats.p.ppp_obytes;
1131 /********************************************************************
1133 * ccp_fatal_error - returns 1 if decompression was disabled as a
1134 * result of an error detected after decompression of a packet,
1135 * 0 otherwise. This is necessary because of patent nonsense.
1138 int ccp_fatal_error (int unit)
1140 int x = get_flags(ppp_dev_fd);
1142 return x & SC_DC_FERROR;
1145 /********************************************************************
1147 * path_to_procfs - find the path to the proc file system mount point
1149 static char proc_path[MAXPATHLEN];
1150 static int proc_path_len;
1152 static char *path_to_procfs(const char *tail)
1154 struct mntent *mntent;
1157 if (proc_path_len == 0) {
1158 /* Default the mount location of /proc */
1159 strlcpy (proc_path, "/proc", sizeof(proc_path));
1161 fp = fopen(MOUNTED, "r");
1163 while ((mntent = getmntent(fp)) != NULL) {
1164 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1166 if (strcmp(mntent->mnt_type, "proc") == 0) {
1167 strlcpy(proc_path, mntent->mnt_dir, sizeof(proc_path));
1168 proc_path_len = strlen(proc_path);
1176 strlcpy(proc_path + proc_path_len, tail,
1177 sizeof(proc_path) - proc_path_len);
1182 * /proc/net/route parsing stuff.
1184 #define ROUTE_MAX_COLS 12
1185 FILE *route_fd = (FILE *) 0;
1186 static char route_buffer[512];
1187 static int route_dev_col, route_dest_col, route_gw_col;
1188 static int route_flags_col, route_mask_col;
1189 static int route_num_cols;
1191 static int open_route_table (void);
1192 static void close_route_table (void);
1193 static int read_route_table (struct rtentry *rt);
1195 /********************************************************************
1197 * close_route_table - close the interface to the route table
1200 static void close_route_table (void)
1202 if (route_fd != (FILE *) 0) {
1204 route_fd = (FILE *) 0;
1208 /********************************************************************
1210 * open_route_table - open the interface to the route table
1212 static char route_delims[] = " \t\n";
1214 static int open_route_table (void)
1218 close_route_table();
1220 path = path_to_procfs("/net/route");
1221 route_fd = fopen (path, "r");
1222 if (route_fd == NULL) {
1223 error("can't open routing table %s: %m", path);
1227 route_dev_col = 0; /* default to usual columns */
1230 route_flags_col = 3;
1234 /* parse header line */
1235 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1236 char *p = route_buffer, *q;
1238 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1240 if ((q = strtok(p, route_delims)) == 0)
1242 if (strcasecmp(q, "iface") == 0)
1243 route_dev_col = col;
1244 else if (strcasecmp(q, "destination") == 0)
1245 route_dest_col = col;
1246 else if (strcasecmp(q, "gateway") == 0)
1248 else if (strcasecmp(q, "flags") == 0)
1249 route_flags_col = col;
1250 else if (strcasecmp(q, "mask") == 0)
1251 route_mask_col = col;
1254 if (used && col >= route_num_cols)
1255 route_num_cols = col + 1;
1263 /********************************************************************
1265 * read_route_table - read the next entry from the route table
1268 static int read_route_table(struct rtentry *rt)
1270 char *cols[ROUTE_MAX_COLS], *p;
1273 memset (rt, '\0', sizeof (struct rtentry));
1275 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1279 for (col = 0; col < route_num_cols; ++col) {
1280 cols[col] = strtok(p, route_delims);
1281 if (cols[col] == NULL)
1282 return 0; /* didn't get enough columns */
1286 SIN_ADDR(rt->rt_dst) = strtoul(cols[route_dest_col], NULL, 16);
1287 SIN_ADDR(rt->rt_gateway) = strtoul(cols[route_gw_col], NULL, 16);
1288 SIN_ADDR(rt->rt_genmask) = strtoul(cols[route_mask_col], NULL, 16);
1290 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1291 rt->rt_dev = cols[route_dev_col];
1296 /********************************************************************
1298 * defaultroute_exists - determine if there is a default route
1301 static int defaultroute_exists (struct rtentry *rt)
1305 if (!open_route_table())
1308 while (read_route_table(rt) != 0) {
1309 if ((rt->rt_flags & RTF_UP) == 0)
1312 if (kernel_version > KVERSION(2,1,0) && SIN_ADDR(rt->rt_genmask) != 0)
1314 if (SIN_ADDR(rt->rt_dst) == 0L) {
1320 close_route_table();
1325 * have_route_to - determine if the system has any route to
1326 * a given IP address. `addr' is in network byte order.
1327 * Return value is 1 if yes, 0 if no, -1 if don't know.
1328 * For demand mode to work properly, we have to ignore routes
1329 * through our own interface.
1331 int have_route_to(u_int32_t addr)
1336 if (!open_route_table())
1337 return -1; /* don't know */
1339 while (read_route_table(&rt)) {
1340 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1342 if ((addr & SIN_ADDR(rt.rt_genmask)) == SIN_ADDR(rt.rt_dst)) {
1348 close_route_table();
1352 /********************************************************************
1354 * sifdefaultroute - assign a default route through the address given.
1357 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1361 if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0) {
1362 u_int32_t old_gateway = SIN_ADDR(rt.rt_gateway);
1364 if (old_gateway != gateway)
1365 error("not replacing existing default route to %s [%I]",
1366 rt.rt_dev, old_gateway);
1370 memset (&rt, '\0', sizeof (rt));
1371 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1372 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1374 if (kernel_version > KVERSION(2,1,0)) {
1375 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1376 SIN_ADDR(rt.rt_genmask) = 0L;
1379 SIN_ADDR(rt.rt_gateway) = gateway;
1381 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1382 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1383 if ( ! ok_error ( errno ))
1384 error("default route ioctl(SIOCADDRT): %m(%d)", errno);
1388 default_route_gateway = gateway;
1392 /********************************************************************
1394 * cifdefaultroute - delete a default route through the address given.
1397 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1401 default_route_gateway = 0;
1403 memset (&rt, '\0', sizeof (rt));
1404 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1405 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1407 if (kernel_version > KVERSION(2,1,0)) {
1408 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1409 SIN_ADDR(rt.rt_genmask) = 0L;
1412 SIN_ADDR(rt.rt_gateway) = gateway;
1414 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1415 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1417 if ( ! ok_error ( errno ))
1418 error("default route ioctl(SIOCDELRT): %m (%d)", errno);
1426 /********************************************************************
1428 * sifproxyarp - Make a proxy ARP entry for the peer.
1431 int sifproxyarp (int unit, u_int32_t his_adr)
1433 struct arpreq arpreq;
1436 if (has_proxy_arp == 0) {
1437 memset (&arpreq, '\0', sizeof(arpreq));
1439 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1440 SIN_ADDR(arpreq.arp_pa) = his_adr;
1441 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1443 * Get the hardware address of an interface on the same subnet
1444 * as our local address.
1446 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
1447 sizeof(proxy_arp_dev))) {
1448 error("Cannot determine ethernet address for proxy ARP");
1451 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1453 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
1454 if ( ! ok_error ( errno ))
1455 error("ioctl(SIOCSARP): %m(%d)", errno);
1458 proxy_arp_addr = his_adr;
1462 forw_path = path_to_procfs("/sys/net/ipv4/ip_forward");
1463 if (forw_path != 0) {
1464 int fd = open(forw_path, O_WRONLY);
1466 if (write(fd, "1", 1) != 1)
1467 error("Couldn't enable IP forwarding: %m");
1477 /********************************************************************
1479 * cifproxyarp - Delete the proxy ARP entry for the peer.
1482 int cifproxyarp (int unit, u_int32_t his_adr)
1484 struct arpreq arpreq;
1486 if (has_proxy_arp) {
1488 memset (&arpreq, '\0', sizeof(arpreq));
1489 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1490 SIN_ADDR(arpreq.arp_pa) = his_adr;
1491 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1492 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1494 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
1495 if ( ! ok_error ( errno ))
1496 warn("ioctl(SIOCDARP): %m(%d)", errno);
1503 /********************************************************************
1505 * get_ether_addr - get the hardware address of an interface on the
1506 * the same subnet as ipaddr.
1509 static int get_ether_addr (u_int32_t ipaddr,
1510 struct sockaddr *hwaddr,
1511 char *name, int namelen)
1513 struct ifreq *ifr, *ifend;
1514 u_int32_t ina, mask;
1518 struct ifreq ifs[MAX_IFS];
1520 ifc.ifc_len = sizeof(ifs);
1522 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1523 if ( ! ok_error ( errno ))
1524 error("ioctl(SIOCGIFCONF): %m(%d)", errno);
1528 SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1529 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1531 * Scan through looking for an interface with an Internet
1532 * address on the same subnet as `ipaddr'.
1534 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1535 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1536 if (ifr->ifr_addr.sa_family == AF_INET) {
1537 ina = SIN_ADDR(ifr->ifr_addr);
1538 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1539 SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1542 * Check that the interface is up, and not point-to-point
1545 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1548 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1551 * Get its netmask and check that it's on the right subnet.
1553 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1556 mask = SIN_ADDR(ifreq.ifr_addr);
1557 SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1558 ip_ntoa(ina), ntohl(mask)));
1560 if (((ipaddr ^ ina) & mask) != 0)
1569 strlcpy(name, ifreq.ifr_name, namelen);
1571 /* trim off the :1 in eth0:1 */
1572 aliasp = strchr(name, ':');
1576 info("found interface %s for proxy arp", name);
1578 * Now get the hardware address.
1580 memset (&ifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1581 if (ioctl (sock_fd, SIOCGIFHWADDR, &ifreq) < 0) {
1582 error("SIOCGIFHWADDR(%s): %m(%d)", ifreq.ifr_name, errno);
1588 sizeof (struct sockaddr));
1590 SYSDEBUG ((LOG_DEBUG,
1591 "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1592 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1593 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1594 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1595 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1596 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1597 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1598 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1599 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1603 /********************************************************************
1605 * Return user specified netmask, modified by any mask we might determine
1606 * for address `addr' (in network byte order).
1607 * Here we scan through the system's list of interfaces, looking for
1608 * any non-point-to-point interfaces which might appear to be on the same
1609 * network as `addr'. If we find any, we OR in their netmask to the
1610 * user-specified netmask.
1613 u_int32_t GetMask (u_int32_t addr)
1615 u_int32_t mask, nmask, ina;
1616 struct ifreq *ifr, *ifend, ifreq;
1618 struct ifreq ifs[MAX_IFS];
1622 if (IN_CLASSA(addr)) /* determine network mask for address class */
1623 nmask = IN_CLASSA_NET;
1624 else if (IN_CLASSB(addr))
1625 nmask = IN_CLASSB_NET;
1627 nmask = IN_CLASSC_NET;
1629 /* class D nets are disallowed by bad_ip_adrs */
1630 mask = netmask | htonl(nmask);
1632 * Scan through the system's network interfaces.
1634 ifc.ifc_len = sizeof(ifs);
1636 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1637 if ( ! ok_error ( errno ))
1638 warn("ioctl(SIOCGIFCONF): %m(%d)", errno);
1642 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1643 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1645 * Check the interface's internet address.
1647 if (ifr->ifr_addr.sa_family != AF_INET)
1649 ina = SIN_ADDR(ifr->ifr_addr);
1650 if (((ntohl(ina) ^ addr) & nmask) != 0)
1653 * Check that the interface is up, and not point-to-point nor loopback.
1655 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1656 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1659 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1662 * Get its netmask and OR it into our mask.
1664 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1666 mask |= SIN_ADDR(ifreq.ifr_addr);
1672 /********************************************************************
1674 * Internal routine to decode the version.modification.patch level
1677 static void decode_version (char *buf, int *version,
1678 int *modification, int *patch)
1680 *version = (int) strtoul (buf, &buf, 10);
1686 *modification = (int) strtoul (buf, &buf, 10);
1689 *patch = (int) strtoul (buf, &buf, 10);
1700 /********************************************************************
1702 * Procedure to determine if the PPP line discipline is registered.
1706 ppp_registered(void)
1714 * We used to open the serial device and set it to the ppp line
1715 * discipline here, in order to create a ppp unit. But that is
1716 * not a good idea - the user might have specified a device that
1717 * they can't open (permission, or maybe it doesn't really exist).
1718 * So we grab a pty master/slave pair and use that.
1720 if (!get_pty(&mfd, &local_fd, slave, 0)) {
1721 no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
1726 * Try to put the device into the PPP discipline.
1728 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
1729 error("ioctl(TIOCSETD(PPP)): %m(%d)", errno);
1738 /********************************************************************
1740 * ppp_available - check whether the system has any ppp interfaces
1741 * (in fact we check whether we can do an ioctl on ppp0).
1744 int ppp_available(void)
1749 int my_version, my_modification, my_patch;
1750 int osmaj, osmin, ospatch;
1753 "This system lacks kernel support for PPP. This could be because\n"
1754 "the PPP kernel module could not be loaded, or because PPP was not\n"
1755 "included in the kernel configuration. If PPP was included as a\n"
1756 "module, try `/sbin/modprobe -v ppp'. If that fails, check that\n"
1757 "ppp.o exists in /lib/modules/`uname -r`/net.\n"
1758 "See README.linux file in the ppp distribution for more details.\n";
1760 /* get the kernel version now, since we are called before sys_init */
1762 osmaj = osmin = ospatch = 0;
1763 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
1764 kernel_version = KVERSION(osmaj, osmin, ospatch);
1766 if (kernel_version >= KVERSION(2,3,13)) {
1767 fd = open("/dev/ppp", O_RDWR);
1769 if (fd < 0 && errno == ENOENT) {
1770 /* try making it and see if that helps. */
1771 if (mknod("/dev/ppp", S_IFCHR | S_IRUSR | S_IWUSR,
1772 makedev(108, 0)) >= 0) {
1773 fd = open("/dev/ppp", O_RDWR);
1775 info("Created /dev/ppp device node");
1777 unlink("/dev/ppp"); /* didn't work, undo the mknod */
1778 } else if (errno == EEXIST) {
1779 fd = open("/dev/ppp", O_RDWR);
1784 new_style_driver = 1;
1786 /* XXX should get from driver */
1788 driver_modification = 4;
1797 * Open a socket for doing the ioctl operations.
1799 s = socket(AF_INET, SOCK_DGRAM, 0);
1803 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1804 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1806 * If the device did not exist then attempt to create one by putting the
1807 * current tty into the PPP discipline. If this works then obtain the
1808 * flags for the device again.
1811 if (ppp_registered()) {
1812 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1813 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1817 * Ensure that the hardware address is for PPP and not something else
1820 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
1822 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
1826 * This is the PPP device. Validate the version of the driver at this
1827 * point to ensure that this program will work with the driver.
1830 char abBuffer [1024];
1832 ifr.ifr_data = abBuffer;
1833 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
1835 error("Couldn't read driver version: %m");
1837 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
1840 decode_version(abBuffer,
1842 &driver_modification,
1845 * Validate the version of the driver against the version that we used.
1847 decode_version(VERSION,
1852 /* The version numbers must match */
1853 if (driver_version != my_version)
1856 /* The modification levels must be legal */
1857 if (driver_modification < 3) {
1858 if (driver_modification >= 2) {
1859 /* we can cope with 2.2.0 and above */
1868 slprintf(route_buffer, sizeof(route_buffer),
1869 "Sorry - PPP driver version %d.%d.%d is out of date\n",
1870 driver_version, driver_modification, driver_patch);
1872 no_ppp_msg = route_buffer;
1879 /********************************************************************
1881 * Update the wtmp file with the appropriate user name and tty device.
1884 void logwtmp (const char *line, const char *name, const char *host)
1886 struct utmp ut, *utp;
1887 pid_t mypid = getpid();
1893 * Update the signon database for users.
1894 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
1896 utmpname(_PATH_UTMP);
1898 while ((utp = getutent()) && (utp->ut_pid != mypid))
1901 /* Is this call really necessary? There is another one after the 'put' */
1905 memcpy(&ut, utp, sizeof(ut));
1907 /* some gettys/telnetds don't initialize utmp... */
1908 memset(&ut, 0, sizeof(ut));
1910 if (ut.ut_id[0] == 0)
1911 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
1913 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
1914 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
1918 ut.ut_type = USER_PROCESS;
1921 /* Insert the host name if one is supplied */
1923 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
1925 /* Insert the IP address of the remote system if IP is enabled */
1926 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
1927 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
1928 sizeof(ut.ut_addr));
1930 /* CL: Makes sure that the logout works */
1931 if (*host == 0 && *name==0)
1937 * Update the wtmp file.
1940 updwtmp(_PATH_WTMP, &ut);
1942 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
1944 flock(wtmp, LOCK_EX);
1946 if (write (wtmp, (char *)&ut, sizeof(ut)) != sizeof(ut))
1947 warn("error writing %s: %m", _PATH_WTMP);
1949 flock(wtmp, LOCK_UN);
1957 /********************************************************************
1959 * sifvjcomp - config tcp header compression
1962 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
1964 u_int x = get_flags(ppp_dev_fd);
1967 if (ioctl (ppp_dev_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
1968 if (! ok_error (errno))
1969 error("ioctl(PPPIOCSMAXCID): %m(%d)", errno);
1974 x = vjcomp ? x | SC_COMP_TCP : x &~ SC_COMP_TCP;
1975 x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
1976 set_flags (ppp_dev_fd, x);
1981 /********************************************************************
1983 * sifup - Config the interface up and enable IP packets to pass.
1990 memset (&ifr, '\0', sizeof (ifr));
1991 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1992 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
1993 if (! ok_error (errno))
1994 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
1998 ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
1999 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2000 if (! ok_error (errno))
2001 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2009 /********************************************************************
2011 * sifdown - Disable the indicated protocol and config the interface
2012 * down if there are no remaining protocols.
2019 if (if_is_up && --if_is_up > 0)
2022 memset (&ifr, '\0', sizeof (ifr));
2023 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2024 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
2025 if (! ok_error (errno))
2026 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
2030 ifr.ifr_flags &= ~IFF_UP;
2031 ifr.ifr_flags |= IFF_POINTOPOINT;
2032 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
2033 if (! ok_error (errno))
2034 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2040 /********************************************************************
2042 * sifaddr - Config the interface IP addresses and netmask.
2045 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2051 memset (&ifr, '\0', sizeof (ifr));
2052 memset (&rt, '\0', sizeof (rt));
2054 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
2055 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2056 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2058 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2060 * Set our IP address
2062 SIN_ADDR(ifr.ifr_addr) = our_adr;
2063 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2064 if (errno != EEXIST) {
2065 if (! ok_error (errno))
2066 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
2069 warn("ioctl(SIOCSIFADDR): Address already exists");
2074 * Set the gateway address
2076 SIN_ADDR(ifr.ifr_dstaddr) = his_adr;
2077 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2078 if (! ok_error (errno))
2079 error("ioctl(SIOCSIFDSTADDR): %m(%d)", errno);
2084 * For recent kernels, force the netmask to 255.255.255.255.
2086 if (kernel_version >= KVERSION(2,1,16))
2088 if (net_mask != 0) {
2089 SIN_ADDR(ifr.ifr_netmask) = net_mask;
2090 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2091 if (! ok_error (errno))
2092 error("ioctl(SIOCSIFNETMASK): %m(%d)", errno);
2097 * Add the device route
2099 if (kernel_version < KVERSION(2,1,16)) {
2100 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2101 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2104 SIN_ADDR(rt.rt_gateway) = 0L;
2105 SIN_ADDR(rt.rt_dst) = his_adr;
2106 rt.rt_flags = RTF_UP | RTF_HOST;
2108 if (kernel_version > KVERSION(2,1,0)) {
2109 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2110 SIN_ADDR(rt.rt_genmask) = -1L;
2113 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2114 if (! ok_error (errno))
2115 error("ioctl(SIOCADDRT) device route: %m(%d)", errno);
2120 /* set ip_dynaddr in demand mode if address changes */
2121 if (demand && tune_kernel && !dynaddr_set
2122 && our_old_addr && our_old_addr != our_adr) {
2123 /* set ip_dynaddr if possible */
2127 path = path_to_procfs("/sys/net/ipv4/ip_dynaddr");
2128 if (path != 0 && (fd = open(path, O_WRONLY)) >= 0) {
2129 if (write(fd, "1", 1) != 1)
2130 error("Couldn't enable dynamic IP addressing: %m");
2133 dynaddr_set = 1; /* only 1 attempt */
2140 /********************************************************************
2142 * cifaddr - Clear the interface IP addresses, and delete routes
2143 * through the interface if possible.
2146 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2150 if (kernel_version < KVERSION(2,1,16)) {
2152 * Delete the route through the device
2155 memset (&rt, '\0', sizeof (rt));
2157 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2158 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2161 SIN_ADDR(rt.rt_gateway) = 0;
2162 SIN_ADDR(rt.rt_dst) = his_adr;
2163 rt.rt_flags = RTF_UP | RTF_HOST;
2165 if (kernel_version > KVERSION(2,1,0)) {
2166 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2167 SIN_ADDR(rt.rt_genmask) = -1L;
2170 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2171 if (still_ppp() && ! ok_error (errno))
2172 error("ioctl(SIOCDELRT) device route: %m(%d)", errno);
2177 /* This way it is possible to have an IPX-only or IPv6-only interface */
2178 memset(&ifr, 0, sizeof(ifr));
2179 SET_SA_FAMILY(ifr.ifr_addr, AF_INET);
2180 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2182 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2183 if (! ok_error (errno)) {
2184 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
2189 our_old_addr = our_adr;
2195 /********************************************************************
2197 * sif6addr - Config the interface with an IPv6 link-local address
2199 int sif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2201 struct in6_ifreq ifr6;
2203 struct in6_rtmsg rt6;
2205 memset(&ifr, 0, sizeof (ifr));
2206 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2207 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2208 error("sif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
2212 /* Local interface */
2213 memset(&ifr6, 0, sizeof(ifr6));
2214 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2215 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2216 ifr6.ifr6_prefixlen = 10;
2218 if (ioctl(sock6_fd, SIOCSIFADDR, &ifr6) < 0) {
2219 error("sif6addr: ioctl(SIOCSIFADDR): %m (%d)", errno);
2223 /* Route to remote host */
2224 memset(&rt6, 0, sizeof(rt6));
2225 IN6_LLADDR_FROM_EUI64(rt6.rtmsg_dst, his_eui64);
2226 rt6.rtmsg_flags = RTF_UP;
2227 rt6.rtmsg_dst_len = 10;
2228 rt6.rtmsg_ifindex = ifr.ifr_ifindex;
2229 rt6.rtmsg_metric = 1;
2231 if (ioctl(sock6_fd, SIOCADDRT, &rt6) < 0) {
2232 error("sif6addr: ioctl(SIOCADDRT): %m (%d)", errno);
2240 /********************************************************************
2242 * cif6addr - Remove IPv6 address from interface
2244 int cif6addr (int unit, eui64_t our_eui64, eui64_t his_eui64)
2247 struct in6_ifreq ifr6;
2249 memset(&ifr, 0, sizeof(ifr));
2250 strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2251 if (ioctl(sock6_fd, SIOCGIFINDEX, (caddr_t) &ifr) < 0) {
2252 error("cif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno);
2256 memset(&ifr6, 0, sizeof(ifr6));
2257 IN6_LLADDR_FROM_EUI64(ifr6.ifr6_addr, our_eui64);
2258 ifr6.ifr6_ifindex = ifr.ifr_ifindex;
2259 ifr6.ifr6_prefixlen = 10;
2261 if (ioctl(sock6_fd, SIOCDIFADDR, &ifr6) < 0) {
2262 if (errno != EADDRNOTAVAIL) {
2263 if (! ok_error (errno))
2264 error("cif6addr: ioctl(SIOCDIFADDR): %m (%d)", errno);
2267 warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
2276 * get_pty - get a pty master/slave pair and chown the slave side
2277 * to the uid given. Assumes slave_name points to >= 16 bytes of space.
2280 get_pty(master_fdp, slave_fdp, slave_name, uid)
2286 int i, mfd, sfd = -1;
2288 struct termios tios;
2292 * Try the unix98 way first.
2294 mfd = open("/dev/ptmx", O_RDWR);
2297 if (ioctl(mfd, TIOCGPTN, &ptn) >= 0) {
2298 slprintf(pty_name, sizeof(pty_name), "/dev/pts/%d", ptn);
2299 chmod(pty_name, S_IRUSR | S_IWUSR);
2302 if (ioctl(mfd, TIOCSPTLCK, &ptn) < 0)
2303 warn("Couldn't unlock pty slave %s: %m", pty_name);
2305 if ((sfd = open(pty_name, O_RDWR | O_NOCTTY)) < 0)
2306 warn("Couldn't open pty slave %s: %m", pty_name);
2309 #endif /* TIOCGPTN */
2312 /* the old way - scan through the pty name space */
2313 for (i = 0; i < 64; ++i) {
2314 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2315 'p' + i / 16, i % 16);
2316 mfd = open(pty_name, O_RDWR, 0);
2319 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2321 fchown(sfd, uid, -1);
2322 fchmod(sfd, S_IRUSR | S_IWUSR);
2333 strlcpy(slave_name, pty_name, 16);
2336 if (tcgetattr(sfd, &tios) == 0) {
2337 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2338 tios.c_cflag |= CS8 | CREAD;
2339 tios.c_iflag = IGNPAR | CLOCAL;
2342 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2343 warn("couldn't set attributes on pty: %m");
2345 warn("couldn't get attributes on pty: %m");
2350 /********************************************************************
2352 * open_loopback - open the device we use for getting packets
2353 * in demand mode. Under Linux, we use a pty master/slave pair.
2356 open_ppp_loopback(void)
2361 if (new_style_driver) {
2362 /* allocate ourselves a ppp unit */
2364 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
2365 if (x < 0 && req_unit >= 0 && errno == EEXIST) {
2366 warn("Couldn't allocate PPP unit %d as it is already in use");
2368 x = ioctl(ppp_dev_fd, PPPIOCNEWUNIT, &ifunit);
2371 fatal("Couldn't create PPP unit: %m");
2372 set_flags(ppp_dev_fd, SC_LOOP_TRAFFIC);
2373 set_kdebugflag(kdebugflag);
2378 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2379 fatal("No free pty for loopback");
2380 SYSDEBUG(("using %s for loopback", loop_name));
2382 set_ppp_fd(slave_fd);
2384 flags = fcntl(master_fd, F_GETFL);
2386 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2387 warn("couldn't set master loopback to nonblock: %m(%d)", errno);
2389 flags = fcntl(ppp_fd, F_GETFL);
2391 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2392 warn("couldn't set slave loopback to nonblock: %m(%d)", errno);
2394 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2395 fatal("ioctl(TIOCSETD): %m(%d)", errno);
2397 * Find out which interface we were given.
2399 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2400 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
2402 * Enable debug in the driver if requested.
2404 set_kdebugflag (kdebugflag);
2409 /********************************************************************
2411 * restore_loop - reattach the ppp unit to the loopback.
2413 * The kernel ppp driver automatically reattaches the ppp unit to
2414 * the loopback if the serial port is set to a line discipline other
2415 * than ppp, or if it detects a modem hangup. The former will happen
2416 * in disestablish_ppp if the latter hasn't already happened, so we
2417 * shouldn't need to do anything.
2419 * Just to be sure, set the real serial port to the normal discipline.
2426 if (new_style_driver) {
2427 set_flags(ppp_dev_fd, get_flags(ppp_dev_fd) | SC_LOOP_TRAFFIC);
2430 if (ppp_fd != slave_fd) {
2431 (void) ioctl(ppp_fd, TIOCSETD, &tty_disc);
2432 set_ppp_fd(slave_fd);
2436 /********************************************************************
2438 * sifnpmode - Set the mode for handling packets for a given NP.
2442 sifnpmode(u, proto, mode)
2449 npi.protocol = proto;
2451 if (ioctl(ppp_dev_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2452 if (! ok_error (errno))
2453 error("ioctl(PPPIOCSNPMODE, %d, %d): %m (%d)",
2454 proto, mode, errno);
2461 /********************************************************************
2463 * sipxfaddr - Config the interface IPX networknumber
2466 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2473 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2475 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2477 if (! ok_error (errno))
2478 dbglog("socket(AF_IPX): %m (%d)", errno);
2482 memset (&ifr, '\0', sizeof (ifr));
2483 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2485 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2486 sipx->sipx_family = AF_IPX;
2487 sipx->sipx_port = 0;
2488 sipx->sipx_network = htonl (network);
2489 sipx->sipx_type = IPX_FRAME_ETHERII;
2490 sipx->sipx_action = IPX_CRTITF;
2492 * Set the IPX device
2494 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2496 if (errno != EEXIST) {
2497 if (! ok_error (errno))
2498 dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (%d)", errno);
2501 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2510 /********************************************************************
2512 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2513 * are removed and the device is no longer able to pass IPX
2517 int cipxfaddr (int unit)
2524 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2526 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2528 if (! ok_error (errno))
2529 dbglog("socket(AF_IPX): %m (%d)", errno);
2533 memset (&ifr, '\0', sizeof (ifr));
2534 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2536 sipx->sipx_type = IPX_FRAME_ETHERII;
2537 sipx->sipx_action = IPX_DLTITF;
2538 sipx->sipx_family = AF_IPX;
2540 * Set the IPX device
2542 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2543 if (! ok_error (errno))
2544 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (%d)", errno);
2554 * Use the hostname as part of the random number seed.
2563 for (p = hostname; *p != 0; ++p)
2568 /********************************************************************
2570 * sys_check_options - check the options that the user specified
2574 sys_check_options(void)
2578 * Disable the IPX protocol if the support is not present in the kernel.
2582 if (ipxcp_protent.enabled_flag) {
2583 struct stat stat_buf;
2584 if ((path = path_to_procfs("/net/ipx_interface")) == 0
2585 || lstat(path, &stat_buf) < 0) {
2586 error("IPX support is not present in the kernel\n");
2587 ipxcp_protent.enabled_flag = 0;
2591 if (demand && driver_is_old) {
2592 option_error("demand dialling is not supported by kernel driver "
2593 "version %d.%d.%d", driver_version, driver_modification,
2597 if (multilink && !new_style_driver) {
2598 option_error("multilink is not supported by the kernel driver");