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>
44 /* This is in netdevice.h. However, this compile will fail miserably if
45 you attempt to include netdevice.h because it has so many references
46 to __memcpy functions which it should not attempt to do. So, since I
47 really don't use it, but it must be defined, define it now. */
50 #define MAX_ADDR_LEN 7
54 #include <asm/types.h> /* glibc 2 conflicts with linux/types.h */
56 #include <net/if_arp.h>
57 #include <net/route.h>
58 #include <netinet/if_ether.h>
60 #include <linux/types.h>
62 #include <linux/if_arp.h>
63 #include <linux/route.h>
64 #include <linux/if_ether.h>
66 #include <netinet/in.h>
67 #include <arpa/inet.h>
69 #include <linux/ppp_defs.h>
70 #include <linux/if_ppp.h>
75 #include "patchlevel.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 */
88 #include <sys/locks.h>
91 #ifndef RTF_DEFAULT /* Normally in <linux/route.h> from <net/route.h> */
95 /* We can get an EIO error on an ioctl if the modem has hung up */
96 #define ok_error(num) ((num)==EIO)
98 static int tty_disc = N_TTY; /* The TTY discipline */
99 static int ppp_disc = N_PPP; /* The PPP discpline */
100 static int initfdflags = -1; /* Initial file descriptor flags for fd */
101 static int ppp_fd = -1; /* fd which is set to PPP discipline */
102 static int sock_fd = -1; /* socket for doing interface ioctls */
103 static int slave_fd = -1;
104 static int master_fd = -1;
106 static fd_set in_fds; /* set of fds that wait_input waits for */
107 static int max_in_fd; /* highest fd set in in_fds */
109 static int has_proxy_arp = 0;
110 static int driver_version = 0;
111 static int driver_modification = 0;
112 static int driver_patch = 0;
113 static int driver_is_old = 0;
114 static int restore_term = 0; /* 1 => we've munged the terminal */
115 static struct termios inittermios; /* Initial TTY termios */
117 static char loop_name[20];
118 static unsigned char inbuf[512]; /* buffer for chars read from loopback */
120 static int if_is_up; /* Interface has been marked up */
121 static u_int32_t default_route_gateway; /* Gateway for default route added */
122 static u_int32_t proxy_arp_addr; /* Addr for proxy arp entry added */
124 static char *lock_file;
126 static struct utsname utsname; /* for the kernel version */
127 static int kernel_version;
128 #define KVERSION(j,n,p) ((j)*1000000 + (n)*1000 + (p))
132 #define FLAGS_GOOD (IFF_UP | IFF_BROADCAST)
133 #define FLAGS_MASK (IFF_UP | IFF_BROADCAST | \
134 IFF_POINTOPOINT | IFF_LOOPBACK | IFF_NOARP)
136 /* Prototypes for procedures local to this file. */
137 static int get_flags (void);
138 static void set_flags (int flags);
139 static int translate_speed (int bps);
140 static int baud_rate_of (int speed);
141 static char *path_to_route (void);
142 static void close_route_table (void);
143 static int open_route_table (void);
144 static int read_route_table (struct rtentry *rt);
145 static int defaultroute_exists (struct rtentry *rt);
146 static int get_ether_addr (u_int32_t ipaddr, struct sockaddr *hwaddr,
148 static void decode_version (char *buf, int *version, int *mod, int *patch);
150 extern u_char inpacket_buf[]; /* borrowed from main.c */
153 * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
157 #define SET_SA_FAMILY(addr, family) \
158 memset ((char *) &(addr), '\0', sizeof(addr)); \
159 addr.sa_family = (family);
162 * Determine if the PPP connection should still be present.
168 #define LOCK_PREFIX "/var/lock/LCK.."
171 static void set_ppp_fd (int new_fd)
173 SYSDEBUG ((LOG_DEBUG, "setting ppp_fd to %d\n", new_fd));
177 static int still_ppp(void)
179 if (!hungup || ppp_fd == slave_fd)
182 set_ppp_fd(slave_fd);
188 /********************************************************************
190 * Functions to read and set the flags value in the device driver
193 static int get_flags (void)
197 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &flags) < 0) {
198 if ( ok_error (errno) )
201 fatal("ioctl(PPPIOCGFLAGS): %m");
204 SYSDEBUG ((LOG_DEBUG, "get flags = %x\n", flags));
208 /********************************************************************/
210 static void set_flags (int flags)
212 SYSDEBUG ((LOG_DEBUG, "set flags = %x\n", flags));
214 if (ioctl(ppp_fd, PPPIOCSFLAGS, (caddr_t) &flags) < 0) {
215 if (! ok_error (errno) )
216 fatal("ioctl(PPPIOCSFLAGS, %x): %m(%d)", flags, errno);
220 /********************************************************************
222 * sys_init - System-dependent initialization.
227 int osmaj, osmin, ospatch;
229 openlog("pppd", LOG_PID | LOG_NDELAY, LOG_PPP);
230 setlogmask(LOG_UPTO(LOG_INFO));
232 setlogmask(LOG_UPTO(LOG_DEBUG));
234 /* Get an internet socket for doing socket ioctls. */
235 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
237 if ( ! ok_error ( errno ))
238 fatal("Couldn't create IP socket: %m(%d)", errno);
245 osmaj = osmin = ospatch = 0;
246 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
247 kernel_version = KVERSION(osmaj, osmin, ospatch);
250 /********************************************************************
252 * sys_cleanup - restore any system state we modified before exiting:
253 * mark the interface down, delete default route and/or proxy arp entry.
254 * This should call die() because it's called from die().
257 void sys_cleanup(void)
260 * Take down the device
265 * Delete any routes through the device.
267 if (default_route_gateway != 0)
268 cifdefaultroute(0, 0, default_route_gateway);
271 cifproxyarp(0, proxy_arp_addr);
274 /********************************************************************
276 * sys_close - Clean up in a child process before execing.
286 /********************************************************************
288 * note_debug_level - note a change in the debug level.
291 void note_debug_level (void)
294 SYSDEBUG ((LOG_INFO, "Debug turned ON, Level %d", debug));
295 setlogmask(LOG_UPTO(LOG_DEBUG));
298 setlogmask(LOG_UPTO(LOG_WARNING));
302 /********************************************************************
304 * set_kdebugflag - Define the debugging level for the kernel
307 int set_kdebugflag (int requested_level)
309 if (ioctl(ppp_fd, PPPIOCSDEBUG, &requested_level) < 0) {
310 if ( ! ok_error (errno) )
311 error("ioctl(PPPIOCSDEBUG): %m");
314 SYSDEBUG ((LOG_INFO, "set kernel debugging level to %d",
319 /********************************************************************
321 * establish_ppp - Turn the serial port into a ppp interface.
324 int establish_ppp (int tty_fd)
328 * The current PPP device will be the tty file.
332 * Ensure that the tty device is in exclusive mode.
334 if (ioctl(tty_fd, TIOCEXCL, 0) < 0) {
335 if ( ! ok_error ( errno ))
336 warn("ioctl(TIOCEXCL): %m");
339 * Demand mode - prime the old ppp device to relinquish the unit.
341 if (demand && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0)
342 fatal("ioctl(transfer ppp unit): %m(%d)", errno);
344 * Set the current tty to the PPP discpline
346 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0) {
347 if ( ! ok_error (errno) )
348 fatal("ioctl(TIOCSETD): %m(%d)", errno);
351 * Find out which interface we were given.
353 if (ioctl(ppp_fd, PPPIOCGUNIT, &x) < 0) {
354 if ( ! ok_error (errno))
355 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
358 * Check that we got the same unit again.
362 fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
367 * Enable debug in the driver if requested.
370 set_kdebugflag (kdebugflag);
372 set_flags (get_flags() & ~(SC_RCV_B7_0 | SC_RCV_B7_1 |
373 SC_RCV_EVNP | SC_RCV_ODDP));
375 SYSDEBUG ((LOG_NOTICE, "Using version %d.%d.%d of PPP driver",
376 driver_version, driver_modification, driver_patch));
378 * Fetch the initial file flags and reset blocking mode on the file.
380 initfdflags = fcntl(ppp_fd, F_GETFL);
382 if (initfdflags == -1 ||
383 fcntl(ppp_fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
384 if ( ! ok_error (errno))
385 warn("Couldn't set device to non-blocking mode: %m");
391 /********************************************************************
393 * disestablish_ppp - Restore the serial port to normal operation.
394 * This shouldn't call die() because it's called from die().
397 void disestablish_ppp(int tty_fd)
400 * Attempt to restore the previous tty settings
404 * Restore the previous line discipline
406 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
407 if ( ! ok_error (errno))
408 error("ioctl(TIOCSETD, N_TTY): %m");
411 if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
412 if ( ! ok_error (errno))
413 warn("ioctl(TIOCNXCL): %m(%d)", errno);
416 /* Reset non-blocking mode on fd. */
417 if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0) {
418 if ( ! ok_error (errno))
419 warn("Couldn't restore device fd flags: %m");
425 /********************************************************************
427 * clean_check - Fetch the flags for the device and generate
428 * appropriate error messages.
430 void clean_check(void)
436 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
438 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
440 case SC_RCV_B7_0 | SC_RCV_EVNP:
441 case SC_RCV_B7_0 | SC_RCV_ODDP:
442 case SC_RCV_B7_0 | SC_RCV_ODDP | SC_RCV_EVNP:
443 s = "all had bit 7 set to 1";
447 case SC_RCV_B7_1 | SC_RCV_EVNP:
448 case SC_RCV_B7_1 | SC_RCV_ODDP:
449 case SC_RCV_B7_1 | SC_RCV_ODDP | SC_RCV_EVNP:
450 s = "all had bit 7 set to 0";
454 s = "all had odd parity";
458 s = "all had even parity";
463 warn("Receive serial link is not 8-bit clean:");
464 warn("Problem: %s", s);
472 * List of valid speeds.
476 int speed_int, speed_val;
553 /********************************************************************
555 * Translate from bits/second to a speed_t.
558 static int translate_speed (int bps)
560 struct speed *speedp;
563 for (speedp = speeds; speedp->speed_int; speedp++) {
564 if (bps == speedp->speed_int)
565 return speedp->speed_val;
567 warn("speed %d not supported", bps);
572 /********************************************************************
574 * Translate from a speed_t to bits/second.
577 static int baud_rate_of (int speed)
579 struct speed *speedp;
582 for (speedp = speeds; speedp->speed_int; speedp++) {
583 if (speed == speedp->speed_val)
584 return speedp->speed_int;
590 /********************************************************************
592 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
593 * at the requested speed, etc. If `local' is true, set CLOCAL
594 * regardless of whether the modem option was specified.
597 void set_up_tty(int tty_fd, int local)
603 if (tcgetattr(tty_fd, &tios) < 0) {
604 if (!ok_error(errno))
605 fatal("tcgetattr: %m(%d)", errno);
612 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
613 tios.c_cflag |= CS8 | CREAD | HUPCL;
615 tios.c_iflag = IGNBRK | IGNPAR;
619 tios.c_cc[VTIME] = 0;
622 tios.c_cflag ^= (CLOCAL | HUPCL);
626 tios.c_cflag |= CRTSCTS;
630 tios.c_iflag |= IXON | IXOFF;
631 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
632 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
636 tios.c_cflag &= ~CRTSCTS;
643 speed = translate_speed(inspeed);
645 cfsetospeed (&tios, speed);
646 cfsetispeed (&tios, speed);
649 * We can't proceed if the serial port speed is B0,
650 * since that implies that the serial port is disabled.
653 speed = cfgetospeed(&tios);
655 fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
658 if (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0)
659 if (!ok_error(errno))
660 fatal("tcsetattr: %m");
662 baud_rate = baud_rate_of(speed);
666 /********************************************************************
668 * setdtr - control the DTR line on the serial port.
669 * This is called from die(), so it shouldn't call die().
672 void setdtr (int tty_fd, int on)
674 int modembits = TIOCM_DTR;
676 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
679 /********************************************************************
681 * restore_tty - restore the terminal to the saved settings.
684 void restore_tty (int tty_fd)
689 * Turn off echoing, because otherwise we can get into
690 * a loop with the tty and the modem echoing to each other.
691 * We presume we are the sole user of this tty device, so
692 * when we close it, it will revert to its defaults anyway.
695 inittermios.c_lflag &= ~(ECHO | ECHONL);
697 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
698 if (! ok_error (errno))
699 warn("tcsetattr: %m");
704 /********************************************************************
706 * output - Output PPP packet.
709 void output (int unit, unsigned char *p, int len)
712 dbglog("sent %P", p, len);
714 if (write(ppp_fd, p, len) < 0) {
715 if (errno == EWOULDBLOCK || errno == ENOBUFS
716 || errno == ENXIO || errno == EIO || errno == EINTR)
717 warn("write: warning: %m (%d)", errno);
719 error("write: %m (%d)", errno);
723 /********************************************************************
725 * wait_input - wait until there is data available,
726 * for the length of time specified by *timo (indefinite
730 void wait_input(struct timeval *timo)
736 n = select(max_in_fd + 1, &ready, NULL, &ready, timo);
737 if (n < 0 && errno != EINTR)
738 fatal("select: %m(%d)", errno);
742 * add_fd - add an fd to the set that wait_input waits for.
752 * remove_fd - remove an fd from the set that wait_input waits for.
754 void remove_fd(int fd)
760 /********************************************************************
762 * wait_loop_output - wait until there is data available on the
763 * loopback, for the length of time specified by *timo (indefinite
766 void wait_loop_output(timo)
767 struct timeval *timo;
773 FD_SET(master_fd, &ready);
774 n = select(master_fd + 1, &ready, NULL, &ready, timo);
775 if (n < 0 && errno != EINTR)
776 fatal("select: %m(%d)", errno);
779 /********************************************************************
781 * wait_time - wait for a given length of time or until a
782 * signal is received.
786 struct timeval *timo;
790 n = select(0, NULL, NULL, NULL, timo);
791 if (n < 0 && errno != EINTR)
792 fatal("select: %m(%d)", errno);
796 /********************************************************************
798 * read_packet - get a PPP packet from the serial device.
801 int read_packet (unsigned char *buf)
805 len = read(ppp_fd, buf, PPP_MTU + PPP_HDRLEN);
807 if (errno == EWOULDBLOCK || errno == EIO)
809 fatal("read: %m(%d)", errno);
814 /********************************************************************
816 * get_loop_output - get outgoing packets from the ppp device,
817 * and detect when we want to bring the real link up.
818 * Return value is 1 if we need to bring up the link, 0 otherwise.
821 get_loop_output(void)
824 int n = read(master_fd, inbuf, sizeof(inbuf));
827 if (loop_chars(inbuf, n))
829 n = read(master_fd, inbuf, sizeof(inbuf));
833 fatal("eof on loopback");
835 if (errno != EWOULDBLOCK)
836 fatal("read from loopback: %m(%d)", errno);
841 /********************************************************************
843 * ppp_send_config - configure the transmit characteristics of
847 void ppp_send_config (int unit,int mtu,u_int32_t asyncmap,int pcomp,int accomp)
852 SYSDEBUG ((LOG_DEBUG, "send_config: mtu = %d\n", mtu));
854 * Ensure that the link is still up.
859 * Set the MTU and other parameters for the ppp device
861 memset (&ifr, '\0', sizeof (ifr));
862 strlcpy(ifr.ifr_name, sizeof (ifr.ifr_name), ifname);
865 if (ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
866 fatal("ioctl(SIOCSIFMTU): %m(%d)", errno);
868 SYSDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
869 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
870 if (!ok_error(errno))
871 fatal("ioctl(PPPIOCSASYNCMAP): %m(%d)", errno);
876 x = pcomp ? x | SC_COMP_PROT : x & ~SC_COMP_PROT;
877 x = accomp ? x | SC_COMP_AC : x & ~SC_COMP_AC;
881 /********************************************************************
883 * ppp_set_xaccm - set the extended transmit ACCM for the interface.
886 void ppp_set_xaccm (int unit, ext_accm accm)
888 SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
889 accm[0], accm[1], accm[2], accm[3]));
891 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
892 if ( ! ok_error (errno))
893 warn("ioctl(set extended ACCM): %m(%d)", errno);
897 /********************************************************************
899 * ppp_recv_config - configure the receive-side characteristics of
903 void ppp_recv_config (int unit,int mru,u_int32_t asyncmap,int pcomp,int accomp)
907 SYSDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
909 * If we were called because the link has gone down then there is nothing
910 * which may be done. Just return without incident.
915 * Set the receiver parameters
917 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
918 if ( ! ok_error (errno))
919 error("ioctl(PPPIOCSMRU): %m(%d)", errno);
922 SYSDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
923 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
924 if (!ok_error(errno))
925 error("ioctl(PPPIOCSRASYNCMAP): %m(%d)", errno);
929 x = !accomp? x | SC_REJ_COMP_AC: x &~ SC_REJ_COMP_AC;
933 /********************************************************************
935 * ccp_test - ask kernel whether a given compression method
936 * is acceptable for use.
939 int ccp_test (int unit, u_char *opt_ptr, int opt_len, int for_transmit)
941 struct ppp_option_data data;
943 memset (&data, '\0', sizeof (data));
945 data.length = opt_len;
946 data.transmit = for_transmit;
948 if (ioctl(ppp_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
951 return (errno == ENOBUFS)? 0: -1;
954 /********************************************************************
956 * ccp_flags_set - inform kernel about the current state of CCP.
959 void ccp_flags_set (int unit, int isopen, int isup)
963 x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
964 x = isup? x | SC_CCP_UP : x &~ SC_CCP_UP;
969 /********************************************************************
971 * get_idle_time - return how long the link has been idle.
978 return ioctl(ppp_fd, PPPIOCGIDLE, ip) >= 0;
981 /********************************************************************
983 * ccp_fatal_error - returns 1 if decompression was disabled as a
984 * result of an error detected after decompression of a packet,
985 * 0 otherwise. This is necessary because of patent nonsense.
988 int ccp_fatal_error (int unit)
992 return x & SC_DC_FERROR;
996 * path_to_route - determine the path to the proc file system data
998 #define ROUTE_MAX_COLS 12
999 FILE *route_fd = (FILE *) 0;
1000 static char route_buffer [512];
1001 static int route_dev_col, route_dest_col, route_gw_col;
1002 static int route_flags_col, route_mask_col;
1003 static int route_num_cols;
1005 static char *path_to_route (void);
1006 static int open_route_table (void);
1007 static void close_route_table (void);
1008 static int read_route_table (struct rtentry *rt);
1010 /********************************************************************
1012 * path_to_procfs - find the path to the proc file system mount point
1015 static int path_to_procfs (void)
1017 struct mntent *mntent;
1020 fp = fopen(MOUNTED, "r");
1022 /* Default the mount location of /proc */
1023 strlcpy (route_buffer, sizeof (route_buffer), "/proc");
1027 while ((mntent = getmntent(fp)) != NULL) {
1028 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1030 if (strcmp(mntent->mnt_type, "proc") == 0)
1037 strlcpy(route_buffer, sizeof (route_buffer), mntent->mnt_dir);
1041 /********************************************************************
1043 * path_to_route - find the path to the route tables in the proc file system
1046 static char *path_to_route (void)
1048 if (!path_to_procfs()) {
1049 error("proc file system not mounted");
1052 strlcat (route_buffer, sizeof(route_buffer), "/net/route");
1053 return (route_buffer);
1056 /********************************************************************
1058 * close_route_table - close the interface to the route table
1061 static void close_route_table (void)
1063 if (route_fd != (FILE *) 0) {
1065 route_fd = (FILE *) 0;
1069 /********************************************************************
1071 * open_route_table - open the interface to the route table
1073 static char route_delims[] = " \t\n";
1075 static int open_route_table (void)
1079 close_route_table();
1081 path = path_to_route();
1085 route_fd = fopen (path, "r");
1086 if (route_fd == NULL) {
1087 error("can't open %s: %m (%d)", path, errno);
1091 route_dev_col = 0; /* default to usual columns */
1094 route_flags_col = 3;
1098 /* parse header line */
1099 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1100 char *p = route_buffer, *q;
1102 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1104 if ((q = strtok(p, route_delims)) == 0)
1106 if (strcasecmp(q, "iface") == 0)
1107 route_dev_col = col;
1108 else if (strcasecmp(q, "destination") == 0)
1109 route_dest_col = col;
1110 else if (strcasecmp(q, "gateway") == 0)
1112 else if (strcasecmp(q, "flags") == 0)
1113 route_flags_col = col;
1114 else if (strcasecmp(q, "mask") == 0)
1115 route_mask_col = col;
1118 if (used && col >= route_num_cols)
1119 route_num_cols = col + 1;
1127 /********************************************************************
1129 * read_route_table - read the next entry from the route table
1132 static int read_route_table(struct rtentry *rt)
1134 char *cols[ROUTE_MAX_COLS], *p;
1137 memset (rt, '\0', sizeof (struct rtentry));
1139 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1143 for (col = 0; col < route_num_cols; ++col) {
1144 cols[col] = strtok(p, route_delims);
1145 if (cols[col] == NULL)
1146 return 0; /* didn't get enough columns */
1149 ((struct sockaddr_in *) &rt->rt_dst)->sin_addr.s_addr =
1150 strtoul(cols[route_dest_col], NULL, 16);
1152 ((struct sockaddr_in *) &rt->rt_gateway)->sin_addr.s_addr =
1153 strtoul(cols[route_gw_col], NULL, 16);
1155 ((struct sockaddr_in *) &rt->rt_genmask)->sin_addr.s_addr =
1156 strtoul(cols[route_mask_col], NULL, 16);
1158 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1159 rt->rt_dev = cols[route_dev_col];
1164 /********************************************************************
1166 * defaultroute_exists - determine if there is a default route
1169 static int defaultroute_exists (struct rtentry *rt)
1173 if (!open_route_table())
1176 while (read_route_table(rt) != 0) {
1177 if ((rt->rt_flags & RTF_UP) == 0)
1180 if (((struct sockaddr_in *) (&rt->rt_dst))->sin_addr.s_addr == 0L) {
1186 close_route_table();
1191 * have_route_to - determine if the system has any route to
1192 * a given IP address. `addr' is in network byte order.
1193 * Return value is 1 if yes, 0 if no, -1 if don't know.
1194 * For demand mode to work properly, we have to ignore routes
1195 * through our own interface.
1197 int have_route_to(u_int32_t addr)
1202 if (!open_route_table())
1203 return -1; /* don't know */
1205 while (read_route_table(&rt)) {
1206 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1208 if ((addr & ((struct sockaddr_in *)&rt.rt_genmask)->sin_addr.s_addr)
1209 == ((struct sockaddr_in *)&rt.rt_dst)->sin_addr.s_addr) {
1215 close_route_table();
1219 /********************************************************************
1221 * sifdefaultroute - assign a default route through the address given.
1224 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1228 if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0) {
1229 struct in_addr old_gateway =
1230 ((struct sockaddr_in *) (&rt.rt_gateway))-> sin_addr;
1232 if (old_gateway.s_addr != gateway)
1233 error("not replacing existing default route to %s [%I]",
1234 rt.rt_dev, old_gateway);
1238 memset (&rt, '\0', sizeof (rt));
1239 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1240 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1242 if (kernel_version > KVERSION(2,1,0)) {
1243 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1244 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = 0L;
1247 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = gateway;
1249 rt.rt_flags = RTF_UP | RTF_GATEWAY | RTF_DEFAULT;
1250 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1251 if ( ! ok_error ( errno ))
1252 error("default route ioctl(SIOCADDRT): %m(%d)", errno);
1256 default_route_gateway = gateway;
1260 /********************************************************************
1262 * cifdefaultroute - delete a default route through the address given.
1265 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1269 default_route_gateway = 0;
1271 memset (&rt, '\0', sizeof (rt));
1272 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1273 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1275 if (kernel_version > KVERSION(2,1,0)) {
1276 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1277 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = 0L;
1280 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = gateway;
1282 rt.rt_flags = RTF_UP | RTF_GATEWAY | RTF_DEFAULT;
1283 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1285 if ( ! ok_error ( errno ))
1286 error("default route ioctl(SIOCDELRT): %m (%d)", errno);
1294 /********************************************************************
1296 * sifproxyarp - Make a proxy ARP entry for the peer.
1299 int sifproxyarp (int unit, u_int32_t his_adr)
1301 struct arpreq arpreq;
1303 if (has_proxy_arp == 0) {
1304 memset (&arpreq, '\0', sizeof(arpreq));
1306 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1307 ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = his_adr;
1308 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1310 * Get the hardware address of an interface on the same subnet
1311 * as our local address.
1313 if (!get_ether_addr(his_adr, &arpreq.arp_ha, arpreq.arp_dev)) {
1314 error("Cannot determine ethernet address for proxy ARP");
1318 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
1319 if ( ! ok_error ( errno ))
1320 error("ioctl(SIOCSARP): %m(%d)", errno);
1323 proxy_arp_addr = his_adr;
1330 /********************************************************************
1332 * cifproxyarp - Delete the proxy ARP entry for the peer.
1335 int cifproxyarp (int unit, u_int32_t his_adr)
1337 struct arpreq arpreq;
1339 if (has_proxy_arp) {
1341 memset (&arpreq, '\0', sizeof(arpreq));
1342 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1343 ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = his_adr;
1344 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1346 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
1347 if ( ! ok_error ( errno ))
1348 warn("ioctl(SIOCDARP): %m(%d)", errno);
1355 /********************************************************************
1357 * get_ether_addr - get the hardware address of an interface on the
1358 * the same subnet as ipaddr.
1361 static int get_ether_addr (u_int32_t ipaddr,
1362 struct sockaddr *hwaddr,
1365 struct ifreq *ifr, *ifend;
1366 u_int32_t ina, mask;
1369 struct ifreq ifs[MAX_IFS];
1371 ifc.ifc_len = sizeof(ifs);
1373 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1374 if ( ! ok_error ( errno ))
1375 error("ioctl(SIOCGIFCONF): %m(%d)", errno);
1379 SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1380 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1382 * Scan through looking for an interface with an Internet
1383 * address on the same subnet as `ipaddr'.
1385 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1386 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1387 if (ifr->ifr_addr.sa_family == AF_INET) {
1388 ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
1389 strlcpy(ifreq.ifr_name, sizeof(ifreq.ifr_name), ifr->ifr_name);
1390 SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1393 * Check that the interface is up, and not point-to-point
1396 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1399 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1402 * Get its netmask and check that it's on the right subnet.
1404 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1407 mask = ((struct sockaddr_in *) &ifreq.ifr_addr)->sin_addr.s_addr;
1408 SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1409 ip_ntoa(ina), ntohl(mask)));
1411 if (((ipaddr ^ ina) & mask) != 0)
1420 memcpy (name, ifreq.ifr_name, sizeof(ifreq.ifr_name));
1421 info("found interface %s for proxy arp", name);
1423 * Now get the hardware address.
1425 memset (&ifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1426 if (ioctl (sock_fd, SIOCGIFHWADDR, &ifreq) < 0) {
1427 error("SIOCGIFHWADDR(%s): %m(%d)", ifreq.ifr_name, errno);
1433 sizeof (struct sockaddr));
1435 SYSDEBUG ((LOG_DEBUG,
1436 "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1437 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1438 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1439 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1440 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1441 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1442 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1443 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1444 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1448 /********************************************************************
1450 * Return user specified netmask, modified by any mask we might determine
1451 * for address `addr' (in network byte order).
1452 * Here we scan through the system's list of interfaces, looking for
1453 * any non-point-to-point interfaces which might appear to be on the same
1454 * network as `addr'. If we find any, we OR in their netmask to the
1455 * user-specified netmask.
1458 u_int32_t GetMask (u_int32_t addr)
1460 u_int32_t mask, nmask, ina;
1461 struct ifreq *ifr, *ifend, ifreq;
1463 struct ifreq ifs[MAX_IFS];
1467 if (IN_CLASSA(addr)) /* determine network mask for address class */
1468 nmask = IN_CLASSA_NET;
1469 else if (IN_CLASSB(addr))
1470 nmask = IN_CLASSB_NET;
1472 nmask = IN_CLASSC_NET;
1474 /* class D nets are disallowed by bad_ip_adrs */
1475 mask = netmask | htonl(nmask);
1477 * Scan through the system's network interfaces.
1479 ifc.ifc_len = sizeof(ifs);
1481 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1482 if ( ! ok_error ( errno ))
1483 warn("ioctl(SIOCGIFCONF): %m(%d)", errno);
1487 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1488 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1490 * Check the interface's internet address.
1492 if (ifr->ifr_addr.sa_family != AF_INET)
1494 ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
1495 if (((ntohl(ina) ^ addr) & nmask) != 0)
1498 * Check that the interface is up, and not point-to-point nor loopback.
1500 strlcpy(ifreq.ifr_name, sizeof(ifreq.ifr_name), ifr->ifr_name);
1501 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1504 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1507 * Get its netmask and OR it into our mask.
1509 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1511 mask |= ((struct sockaddr_in *)&ifreq.ifr_addr)->sin_addr.s_addr;
1517 /********************************************************************
1519 * Internal routine to decode the version.modification.patch level
1522 static void decode_version (char *buf, int *version,
1523 int *modification, int *patch)
1525 *version = (int) strtoul (buf, &buf, 10);
1531 *modification = (int) strtoul (buf, &buf, 10);
1534 *patch = (int) strtoul (buf, &buf, 10);
1545 /********************************************************************
1547 * Procedure to determine if the PPP line discipline is registered.
1551 ppp_registered(void)
1557 local_fd = open(devnam, O_NONBLOCK | O_RDWR, 0);
1559 error("Failed to open %s: %m(%d)", devnam, errno);
1563 initfdflags = fcntl(local_fd, F_GETFL);
1564 if (initfdflags == -1) {
1565 error("Couldn't get device fd flags: %m(%d)", errno);
1570 initfdflags &= ~O_NONBLOCK;
1571 fcntl(local_fd, F_SETFL, initfdflags);
1573 * Read the initial line dicipline and try to put the device into the
1576 if (ioctl(local_fd, TIOCGETD, &init_disc) < 0) {
1577 error("ioctl(TIOCGETD): %m(%d)", errno);
1582 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
1583 error("ioctl(TIOCSETD): %m(%d)", errno);
1588 if (ioctl(local_fd, TIOCSETD, &init_disc) < 0) {
1589 error("ioctl(TIOCSETD): %m(%d)", errno);
1598 /********************************************************************
1600 * ppp_available - check whether the system has any ppp interfaces
1601 * (in fact we check whether we can do an ioctl on ppp0).
1604 int ppp_available(void)
1609 int my_version, my_modification, my_patch;
1610 extern char *no_ppp_msg;
1612 * Open a socket for doing the ioctl operations.
1614 s = socket(AF_INET, SOCK_DGRAM, 0);
1618 strlcpy (ifr.ifr_name, sizeof (ifr.ifr_name), "ppp0");
1619 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1621 * If the device did not exist then attempt to create one by putting the
1622 * current tty into the PPP discipline. If this works then obtain the
1623 * flags for the device again.
1626 if (ppp_registered()) {
1627 strlcpy (ifr.ifr_name, sizeof (ifr.ifr_name), "ppp0");
1628 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1632 * Ensure that the hardware address is for PPP and not something else
1635 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
1637 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
1642 "This system lacks kernel support for PPP. This could be because\n"
1643 "the PPP kernel module is not loaded, or because the kernel is\n"
1644 "not configured for PPP. See the README.linux file in the\n"
1645 "ppp-2.3.6 distribution.\n";
1648 * This is the PPP device. Validate the version of the driver at this
1649 * point to ensure that this program will work with the driver.
1652 char abBuffer [1024];
1654 ifr.ifr_data = abBuffer;
1655 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
1657 error("Couldn't read driver version: %m");
1659 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
1662 decode_version(abBuffer,
1664 &driver_modification,
1667 * Validate the version of the driver against the version that we used.
1669 decode_version(VERSION,
1674 /* The version numbers must match */
1675 if (driver_version != my_version)
1678 /* The modification levels must be legal */
1679 if (driver_modification < 3) {
1680 if (driver_modification >= 2) {
1681 /* we can cope with 2.2.0 and above */
1690 slprintf(route_buffer, sizeof(route_buffer),
1691 "Sorry - PPP driver version %d.%d.%d is out of date\n",
1692 driver_version, driver_modification, driver_patch);
1694 no_ppp_msg = route_buffer;
1701 /********************************************************************
1703 * Update the wtmp file with the appropriate user name and tty device.
1706 void logwtmp (const char *line, const char *name, const char *host)
1709 struct utmp ut, *utp;
1710 pid_t mypid = getpid();
1712 * Update the signon database for users.
1713 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
1715 utmpname(_PATH_UTMP);
1717 while ((utp = getutent()) && (utp->ut_pid != mypid))
1720 /* Is this call really necessary? There is another one after the 'put' */
1724 memcpy(&ut, utp, sizeof(ut));
1726 /* some gettys/telnetds don't initialize utmp... */
1727 memset(&ut, 0, sizeof(ut));
1729 if (ut.ut_id[0] == 0)
1730 strlcpy(ut.ut_id, sizeof(ut.ut_id), line + 3);
1732 strlcpy(ut.ut_user, sizeof(ut.ut_user), name);
1733 strlcpy(ut.ut_line, sizeof(ut.ut_line), line);
1737 ut.ut_type = USER_PROCESS;
1740 /* Insert the host name if one is supplied */
1742 strlcpy (ut.ut_host, sizeof(ut.ut_host), host);
1744 /* Insert the IP address of the remote system if IP is enabled */
1745 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
1746 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
1747 sizeof(ut.ut_addr));
1749 /* CL: Makes sure that the logout works */
1750 if (*host == 0 && *name==0)
1756 * Update the wtmp file.
1758 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
1760 flock(wtmp, LOCK_EX);
1762 /* we really should check for error on the write for a full disk! */
1763 write (wtmp, (char *)&ut, sizeof(ut));
1766 flock(wtmp, LOCK_UN);
1770 /********************************************************************
1771 * Code for locking/unlocking the serial device.
1772 * This code is derived from chat.c.
1776 * lock - create a lock file for the named device
1779 int lock (char *dev)
1783 lock_file = strdup(dev);
1784 if (lock_file == NULL)
1785 novm("lock file name");
1786 result = mklock (dev, (void *) 0);
1789 notice("Device %s is locked by pid %d", dev, result);
1796 error("Can't create lock file %s", lock_file);
1804 char hdb_lock_buffer[12];
1810 p = strrchr(dev, '/');
1814 l = strlen(LOCK_PREFIX) + strlen(dev) + 1;
1815 lock_file = malloc(l);
1816 if (lock_file == NULL)
1817 novm("lock file name");
1819 slprintf(lock_file, l, "%s%s", LOCK_PREFIX, dev);
1821 * Attempt to create the lock file at this point.
1824 fd = open(lock_file, O_EXCL | O_CREAT | O_RDWR, 0644);
1828 slprintf(hdb_lock_buffer, sizeof(hdb_lock_buffer), "%010d\n", pid);
1829 write (fd, hdb_lock_buffer, 11);
1831 write(fd, &pid, sizeof (pid));
1837 * If the file exists then check to see if the pid is stale
1839 if (errno == EEXIST) {
1840 fd = open(lock_file, O_RDONLY, 0);
1842 if (errno == ENOENT) /* This is just a timing problem. */
1847 /* Read the lock file to find out who has the device locked */
1848 n = read (fd, hdb_lock_buffer, 11);
1851 error("Can't read pid from lock file %s", lock_file);
1855 /* See the process still exists. */
1858 hdb_lock_buffer[n] = '\0';
1859 sscanf (hdb_lock_buffer, " %d", &pid);
1861 pid = ((int *) hdb_lock_buffer)[0];
1863 if (pid == 0 || pid == getpid()
1864 || (kill(pid, 0) == -1 && errno == ESRCH))
1868 /* If the process does not exist then try to remove the lock */
1869 if (n == 0 && unlink (lock_file) == 0) {
1870 notice("Removed stale lock on %s (pid %d)",
1875 notice("Device %s is locked by pid %d", dev, pid);
1879 error("Can't create lock file %s: %m(%d)", lock_file, errno);
1890 /********************************************************************
1892 * unlock - remove our lockfile
1899 (void) rmlock (lock_file, (void *) 0);
1908 /********************************************************************
1910 * sifvjcomp - config tcp header compression
1913 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
1915 u_int x = get_flags();
1918 if (ioctl (ppp_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
1919 if (! ok_error (errno))
1920 error("ioctl(PPPIOCSMAXCID): %m(%d)", errno);
1925 x = vjcomp ? x | SC_COMP_TCP : x &~ SC_COMP_TCP;
1926 x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
1932 /********************************************************************
1934 * sifup - Config the interface up and enable IP packets to pass.
1941 memset (&ifr, '\0', sizeof (ifr));
1942 strlcpy(ifr.ifr_name, sizeof (ifr.ifr_name), ifname);
1943 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
1944 if (! ok_error (errno))
1945 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
1949 ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
1950 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
1951 if (! ok_error (errno))
1952 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
1959 /********************************************************************
1961 * sifdown - Config the interface down and disable IP.
1970 memset (&ifr, '\0', sizeof (ifr));
1971 strlcpy(ifr.ifr_name, sizeof (ifr.ifr_name), ifname);
1972 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
1973 if (! ok_error (errno))
1974 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
1978 ifr.ifr_flags &= ~IFF_UP;
1979 ifr.ifr_flags |= IFF_POINTOPOINT;
1980 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
1981 if (! ok_error (errno))
1982 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
1988 /********************************************************************
1990 * sifaddr - Config the interface IP addresses and netmask.
1993 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
1999 memset (&ifr, '\0', sizeof (ifr));
2000 memset (&rt, '\0', sizeof (rt));
2002 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
2003 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2004 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2006 strlcpy (ifr.ifr_name, sizeof (ifr.ifr_name), ifname);
2008 * Set our IP address
2010 ((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr.s_addr = our_adr;
2011 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2012 if (errno != EEXIST) {
2013 if (! ok_error (errno))
2014 error("ioctl(SIOCAIFADDR): %m(%d)", errno);
2017 warn("ioctl(SIOCAIFADDR): Address already exists");
2022 * Set the gateway address
2024 ((struct sockaddr_in *) &ifr.ifr_dstaddr)->sin_addr.s_addr = his_adr;
2025 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2026 if (! ok_error (errno))
2027 error("ioctl(SIOCSIFDSTADDR): %m(%d)", errno);
2032 * For recent kernels, force the netmask to 255.255.255.255.
2034 if (kernel_version >= KVERSION(2,1,16))
2036 if (net_mask != 0) {
2037 ((struct sockaddr_in *) &ifr.ifr_netmask)->sin_addr.s_addr = net_mask;
2038 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2039 if (! ok_error (errno))
2040 error("ioctl(SIOCSIFNETMASK): %m(%d)", errno);
2045 * Add the device route
2047 if (kernel_version < KVERSION(2,1,16)) {
2048 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2049 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2052 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = 0L;
2053 ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr = his_adr;
2054 rt.rt_flags = RTF_UP | RTF_HOST;
2056 if (kernel_version > KVERSION(2,1,0)) {
2057 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2058 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = -1L;
2061 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2062 if (! ok_error (errno))
2063 error("ioctl(SIOCADDRT) device route: %m(%d)", errno);
2070 /********************************************************************
2072 * cifaddr - Clear the interface IP addresses, and delete routes
2073 * through the interface if possible.
2076 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2080 if (kernel_version < KVERSION(2,1,16)) {
2082 * Delete the route through the device
2084 memset (&rt, '\0', sizeof (rt));
2086 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2087 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2090 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = 0;
2091 ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr = his_adr;
2092 rt.rt_flags = RTF_UP | RTF_HOST;
2094 if (kernel_version > KVERSION(2,1,0)) {
2095 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2096 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = -1L;
2099 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2100 if (still_ppp() && ! ok_error (errno))
2101 error("ioctl(SIOCDELRT) device route: %m(%d)", errno);
2108 /********************************************************************
2110 * open_loopback - open the device we use for getting packets
2111 * in demand mode. Under Linux, we use a pty master/slave pair.
2114 open_ppp_loopback(void)
2117 struct termios tios;
2120 for (i = 0; i < 64; ++i) {
2121 slprintf(loop_name, sizeof(loop_name), "/dev/pty%c%x",
2122 'p' + i / 16, i % 16);
2123 master_fd = open(loop_name, O_RDWR | O_NOCTTY, 0);
2128 fatal("No free pty for loopback");
2129 SYSDEBUG(("using %s for loopback", loop_name));
2131 slave_fd = open(loop_name, O_RDWR | O_NOCTTY, 0);
2133 fatal("Couldn't open %s for loopback: %m", loop_name);
2135 set_ppp_fd(slave_fd);
2137 if (tcgetattr(ppp_fd, &tios) == 0) {
2138 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2139 tios.c_cflag |= CS8 | CREAD;
2140 tios.c_iflag = IGNPAR | CLOCAL;
2143 if (tcsetattr(ppp_fd, TCSAFLUSH, &tios) < 0)
2144 warn("couldn't set attributes on loopback: %m(%d)", errno);
2147 flags = fcntl(master_fd, F_GETFL);
2149 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2150 warn("couldn't set master loopback to nonblock: %m(%d)", errno);
2152 flags = fcntl(ppp_fd, F_GETFL);
2154 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2155 warn("couldn't set slave loopback to nonblock: %m(%d)", errno);
2157 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2158 fatal("ioctl(TIOCSETD): %m(%d)", errno);
2160 * Find out which interface we were given.
2162 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2163 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
2165 * Enable debug in the driver if requested.
2167 set_kdebugflag (kdebugflag);
2172 /********************************************************************
2174 * restore_loop - reattach the ppp unit to the loopback.
2176 * The kernel ppp driver automatically reattaches the ppp unit to
2177 * the loopback if the serial port is set to a line discipline other
2178 * than ppp, or if it detects a modem hangup. The former will happen
2179 * in disestablish_ppp if the latter hasn't already happened, so we
2180 * shouldn't need to do anything.
2182 * Just to be sure, set the real serial port to the normal discipline.
2188 if (ppp_fd != slave_fd) {
2189 (void) ioctl(ppp_fd, TIOCSETD, &tty_disc);
2190 set_ppp_fd(slave_fd);
2194 /********************************************************************
2196 * sifnpmode - Set the mode for handling packets for a given NP.
2200 sifnpmode(u, proto, mode)
2207 npi.protocol = proto;
2209 if (ioctl(ppp_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2210 if (! ok_error (errno)) {
2211 error("ioctl(PPPIOCSNPMODE, %d, %d): %m (%d)",
2212 proto, mode, errno);
2213 error("ppp_fd=%d slave_fd=%d\n", ppp_fd, slave_fd);
2221 /********************************************************************
2223 * sipxfaddr - Config the interface IPX networknumber
2226 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2233 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2235 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2237 if (! ok_error (errno))
2238 dbglog("socket(AF_IPX): %m (%d)", errno);
2242 memset (&ifr, '\0', sizeof (ifr));
2243 strlcpy (ifr.ifr_name, sizeof(ifr.ifr_name), ifname);
2245 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2246 sipx->sipx_family = AF_IPX;
2247 sipx->sipx_port = 0;
2248 sipx->sipx_network = htonl (network);
2249 sipx->sipx_type = IPX_FRAME_ETHERII;
2250 sipx->sipx_action = IPX_CRTITF;
2252 * Set the IPX device
2254 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2256 if (errno != EEXIST) {
2257 if (! ok_error (errno))
2258 dbglog("ioctl(SIOCAIFADDR, CRTITF): %m (%d)", errno);
2261 warn("ioctl(SIOCAIFADDR, CRTITF): Address already exists");
2270 /********************************************************************
2272 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2273 * are removed and the device is no longer able to pass IPX
2277 int cipxfaddr (int unit)
2284 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2286 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2288 if (! ok_error (errno))
2289 dbglog("socket(AF_IPX): %m (%d)", errno);
2293 memset (&ifr, '\0', sizeof (ifr));
2294 strlcpy (ifr.ifr_name, sizeof(ifr.ifr_name), ifname);
2296 sipx->sipx_type = IPX_FRAME_ETHERII;
2297 sipx->sipx_action = IPX_DLTITF;
2298 sipx->sipx_family = AF_IPX;
2300 * Set the IPX device
2302 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2303 if (! ok_error (errno))
2304 info("ioctl(SIOCAIFADDR, IPX_DLTITF): %m (%d)", errno);
2314 * daemon - Detach us from controlling terminal session.
2317 daemon(nochdir, noclose)
2318 int nochdir, noclose;
2322 if ((pid = fork()) < 0)
2325 exit(0); /* parent dies */
2330 fclose(stdin); /* don't need stdin, stdout, stderr */
2338 * Use the hostname as part of the random number seed.
2347 for (p = hostname; *p != 0; ++p)
2352 /********************************************************************
2354 * sys_check_options - check the options that the user specified
2358 sys_check_options(void)
2361 struct stat stat_buf;
2363 * Disable the IPX protocol if the support is not present in the kernel.
2364 * If we disable it then ensure that IP support is enabled.
2366 while (ipxcp_protent.enabled_flag) {
2367 if (path_to_procfs()) {
2368 strlcat (route_buffer, sizeof(route_buffer), "/net/ipx_interface");
2369 if (lstat (route_buffer, &stat_buf) >= 0)
2372 error("IPX support is not present in the kernel\n");
2373 ipxcp_protent.enabled_flag = 0;
2374 ipcp_protent.enabled_flag = 1;
2378 if (demand && driver_is_old) {
2379 option_error("demand dialling is not supported by kernel driver "
2380 "version %d.%d.%d", driver_version, driver_modification,