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 */
123 static char proxy_arp_dev[16]; /* Device for proxy arp entry */
125 static struct utsname utsname; /* for the kernel version */
126 static int kernel_version;
127 #define KVERSION(j,n,p) ((j)*1000000 + (n)*1000 + (p))
131 #define FLAGS_GOOD (IFF_UP | IFF_BROADCAST)
132 #define FLAGS_MASK (IFF_UP | IFF_BROADCAST | \
133 IFF_POINTOPOINT | IFF_LOOPBACK | IFF_NOARP)
135 /* Prototypes for procedures local to this file. */
136 static int get_flags (void);
137 static void set_flags (int flags);
138 static int translate_speed (int bps);
139 static int baud_rate_of (int speed);
140 static char *path_to_route (void);
141 static void close_route_table (void);
142 static int open_route_table (void);
143 static int read_route_table (struct rtentry *rt);
144 static int defaultroute_exists (struct rtentry *rt);
145 static int get_ether_addr (u_int32_t ipaddr, struct sockaddr *hwaddr,
146 char *name, int namelen);
147 static void decode_version (char *buf, int *version, int *mod, int *patch);
148 static int set_kdebugflag(int level);
149 static int ppp_registered(void);
151 extern u_char inpacket_buf[]; /* borrowed from main.c */
154 * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
158 #define SET_SA_FAMILY(addr, family) \
159 memset ((char *) &(addr), '\0', sizeof(addr)); \
160 addr.sa_family = (family);
163 * Determine if the PPP connection should still be present.
168 static void set_ppp_fd (int new_fd)
170 SYSDEBUG ((LOG_DEBUG, "setting ppp_fd to %d\n", new_fd));
174 static int still_ppp(void)
176 if (!hungup || ppp_fd == slave_fd)
179 set_ppp_fd(slave_fd);
185 /********************************************************************
187 * Functions to read and set the flags value in the device driver
190 static int get_flags (void)
194 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &flags) < 0) {
195 if ( ok_error (errno) )
198 fatal("ioctl(PPPIOCGFLAGS): %m");
201 SYSDEBUG ((LOG_DEBUG, "get flags = %x\n", flags));
205 /********************************************************************/
207 static void set_flags (int flags)
209 SYSDEBUG ((LOG_DEBUG, "set flags = %x\n", flags));
211 if (ioctl(ppp_fd, PPPIOCSFLAGS, (caddr_t) &flags) < 0) {
212 if (! ok_error (errno) )
213 fatal("ioctl(PPPIOCSFLAGS, %x): %m(%d)", flags, errno);
217 /********************************************************************
219 * sys_init - System-dependent initialization.
224 int osmaj, osmin, ospatch;
226 openlog("pppd", LOG_PID | LOG_NDELAY, LOG_PPP);
227 setlogmask(LOG_UPTO(LOG_INFO));
229 setlogmask(LOG_UPTO(LOG_DEBUG));
231 /* Get an internet socket for doing socket ioctls. */
232 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
234 if ( ! ok_error ( errno ))
235 fatal("Couldn't create IP socket: %m(%d)", errno);
242 osmaj = osmin = ospatch = 0;
243 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
244 kernel_version = KVERSION(osmaj, osmin, ospatch);
247 /********************************************************************
249 * sys_cleanup - restore any system state we modified before exiting:
250 * mark the interface down, delete default route and/or proxy arp entry.
251 * This shouldn't call die() because it's called from die().
254 void sys_cleanup(void)
257 * Take down the device
262 * Delete any routes through the device.
264 if (default_route_gateway != 0)
265 cifdefaultroute(0, 0, default_route_gateway);
268 cifproxyarp(0, proxy_arp_addr);
271 /********************************************************************
273 * sys_close - Clean up in a child process before execing.
287 /********************************************************************
289 * set_kdebugflag - Define the debugging level for the kernel
292 static int set_kdebugflag (int requested_level)
294 if (ioctl(ppp_fd, PPPIOCSDEBUG, &requested_level) < 0) {
295 if ( ! ok_error (errno) )
296 error("ioctl(PPPIOCSDEBUG): %m");
299 SYSDEBUG ((LOG_INFO, "set kernel debugging level to %d",
304 /********************************************************************
306 * establish_ppp - Turn the serial port into a ppp interface.
309 int establish_ppp (int tty_fd)
313 * The current PPP device will be the tty file.
317 * Ensure that the tty device is in exclusive mode.
319 if (ioctl(tty_fd, TIOCEXCL, 0) < 0) {
320 if ( ! ok_error ( errno ))
321 warn("ioctl(TIOCEXCL): %m");
324 * Demand mode - prime the old ppp device to relinquish the unit.
326 if (demand && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0)
327 fatal("ioctl(transfer ppp unit): %m(%d)", errno);
329 * Set the current tty to the PPP discpline
331 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0) {
332 if ( ! ok_error (errno) )
333 fatal("ioctl(TIOCSETD): %m(%d)", errno);
336 * Find out which interface we were given.
338 if (ioctl(ppp_fd, PPPIOCGUNIT, &x) < 0) {
339 if ( ! ok_error (errno))
340 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
343 * Check that we got the same unit again.
347 fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
352 * Enable debug in the driver if requested.
355 set_kdebugflag (kdebugflag);
357 set_flags (get_flags() & ~(SC_RCV_B7_0 | SC_RCV_B7_1 |
358 SC_RCV_EVNP | SC_RCV_ODDP));
360 SYSDEBUG ((LOG_NOTICE, "Using version %d.%d.%d of PPP driver",
361 driver_version, driver_modification, driver_patch));
363 * Fetch the initial file flags and reset blocking mode on the file.
365 initfdflags = fcntl(ppp_fd, F_GETFL);
367 if (initfdflags == -1 ||
368 fcntl(ppp_fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
369 if ( ! ok_error (errno))
370 warn("Couldn't set device to non-blocking mode: %m");
376 /********************************************************************
378 * disestablish_ppp - Restore the serial port to normal operation.
379 * This shouldn't call die() because it's called from die().
382 void disestablish_ppp(int tty_fd)
385 * Attempt to restore the previous tty settings
389 * Restore the previous line discipline
391 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
392 if ( ! ok_error (errno))
393 error("ioctl(TIOCSETD, N_TTY): %m");
396 if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
397 if ( ! ok_error (errno))
398 warn("ioctl(TIOCNXCL): %m(%d)", errno);
401 /* Reset non-blocking mode on fd. */
402 if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0) {
403 if ( ! ok_error (errno))
404 warn("Couldn't restore device fd flags: %m");
410 /********************************************************************
412 * clean_check - Fetch the flags for the device and generate
413 * appropriate error messages.
415 void clean_check(void)
421 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
423 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
425 case SC_RCV_B7_0 | SC_RCV_EVNP:
426 case SC_RCV_B7_0 | SC_RCV_ODDP:
427 case SC_RCV_B7_0 | SC_RCV_ODDP | SC_RCV_EVNP:
428 s = "all had bit 7 set to 1";
432 case SC_RCV_B7_1 | SC_RCV_EVNP:
433 case SC_RCV_B7_1 | SC_RCV_ODDP:
434 case SC_RCV_B7_1 | SC_RCV_ODDP | SC_RCV_EVNP:
435 s = "all had bit 7 set to 0";
439 s = "all had odd parity";
443 s = "all had even parity";
448 warn("Receive serial link is not 8-bit clean:");
449 warn("Problem: %s", s);
457 * List of valid speeds.
461 int speed_int, speed_val;
538 /********************************************************************
540 * Translate from bits/second to a speed_t.
543 static int translate_speed (int bps)
545 struct speed *speedp;
548 for (speedp = speeds; speedp->speed_int; speedp++) {
549 if (bps == speedp->speed_int)
550 return speedp->speed_val;
552 warn("speed %d not supported", bps);
557 /********************************************************************
559 * Translate from a speed_t to bits/second.
562 static int baud_rate_of (int speed)
564 struct speed *speedp;
567 for (speedp = speeds; speedp->speed_int; speedp++) {
568 if (speed == speedp->speed_val)
569 return speedp->speed_int;
575 /********************************************************************
577 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
578 * at the requested speed, etc. If `local' is true, set CLOCAL
579 * regardless of whether the modem option was specified.
582 void set_up_tty(int tty_fd, int local)
588 if (tcgetattr(tty_fd, &tios) < 0) {
589 if (!ok_error(errno))
590 fatal("tcgetattr: %m(%d)", errno);
597 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
598 tios.c_cflag |= CS8 | CREAD | HUPCL;
600 tios.c_iflag = IGNBRK | IGNPAR;
604 tios.c_cc[VTIME] = 0;
607 tios.c_cflag ^= (CLOCAL | HUPCL);
611 tios.c_cflag |= CRTSCTS;
615 tios.c_iflag |= IXON | IXOFF;
616 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
617 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
621 tios.c_cflag &= ~CRTSCTS;
628 speed = translate_speed(inspeed);
630 cfsetospeed (&tios, speed);
631 cfsetispeed (&tios, speed);
634 * We can't proceed if the serial port speed is B0,
635 * since that implies that the serial port is disabled.
638 speed = cfgetospeed(&tios);
640 fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
643 if (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0)
644 if (!ok_error(errno))
645 fatal("tcsetattr: %m");
647 baud_rate = baud_rate_of(speed);
651 /********************************************************************
653 * setdtr - control the DTR line on the serial port.
654 * This is called from die(), so it shouldn't call die().
657 void setdtr (int tty_fd, int on)
659 int modembits = TIOCM_DTR;
661 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
664 /********************************************************************
666 * restore_tty - restore the terminal to the saved settings.
669 void restore_tty (int tty_fd)
674 * Turn off echoing, because otherwise we can get into
675 * a loop with the tty and the modem echoing to each other.
676 * We presume we are the sole user of this tty device, so
677 * when we close it, it will revert to its defaults anyway.
680 inittermios.c_lflag &= ~(ECHO | ECHONL);
682 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
683 if (! ok_error (errno))
684 warn("tcsetattr: %m");
689 /********************************************************************
691 * output - Output PPP packet.
694 void output (int unit, unsigned char *p, int len)
697 dbglog("sent %P", p, len);
699 if (write(ppp_fd, p, len) < 0) {
700 if (errno == EWOULDBLOCK || errno == ENOBUFS
701 || errno == ENXIO || errno == EIO || errno == EINTR)
702 warn("write: warning: %m (%d)", errno);
704 error("write: %m (%d)", errno);
708 /********************************************************************
710 * wait_input - wait until there is data available,
711 * for the length of time specified by *timo (indefinite
715 void wait_input(struct timeval *timo)
721 n = select(max_in_fd + 1, &ready, NULL, &ready, timo);
722 if (n < 0 && errno != EINTR)
723 fatal("select: %m(%d)", errno);
727 * add_fd - add an fd to the set that wait_input waits for.
737 * remove_fd - remove an fd from the set that wait_input waits for.
739 void remove_fd(int fd)
745 /********************************************************************
747 * wait_loop_output - wait until there is data available on the
748 * loopback, for the length of time specified by *timo (indefinite
751 void wait_loop_output(timo)
752 struct timeval *timo;
758 FD_SET(master_fd, &ready);
759 n = select(master_fd + 1, &ready, NULL, &ready, timo);
760 if (n < 0 && errno != EINTR)
761 fatal("select: %m(%d)", errno);
764 /********************************************************************
766 * wait_time - wait for a given length of time or until a
767 * signal is received.
771 struct timeval *timo;
775 n = select(0, NULL, NULL, NULL, timo);
776 if (n < 0 && errno != EINTR)
777 fatal("select: %m(%d)", errno);
781 /********************************************************************
783 * read_packet - get a PPP packet from the serial device.
786 int read_packet (unsigned char *buf)
790 len = read(ppp_fd, buf, PPP_MTU + PPP_HDRLEN);
792 if (errno == EWOULDBLOCK || errno == EIO)
794 fatal("read: %m(%d)", errno);
799 /********************************************************************
801 * get_loop_output - get outgoing packets from the ppp device,
802 * and detect when we want to bring the real link up.
803 * Return value is 1 if we need to bring up the link, 0 otherwise.
806 get_loop_output(void)
809 int n = read(master_fd, inbuf, sizeof(inbuf));
812 if (loop_chars(inbuf, n))
814 n = read(master_fd, inbuf, sizeof(inbuf));
818 fatal("eof on loopback");
820 if (errno != EWOULDBLOCK)
821 fatal("read from loopback: %m(%d)", errno);
826 /********************************************************************
828 * ppp_send_config - configure the transmit characteristics of
832 void ppp_send_config (int unit,int mtu,u_int32_t asyncmap,int pcomp,int accomp)
837 SYSDEBUG ((LOG_DEBUG, "send_config: mtu = %d\n", mtu));
839 * Ensure that the link is still up.
844 * Set the MTU and other parameters for the ppp device
846 memset (&ifr, '\0', sizeof (ifr));
847 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
850 if (ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
851 fatal("ioctl(SIOCSIFMTU): %m(%d)", errno);
853 SYSDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
854 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
855 if (!ok_error(errno))
856 fatal("ioctl(PPPIOCSASYNCMAP): %m(%d)", errno);
861 x = pcomp ? x | SC_COMP_PROT : x & ~SC_COMP_PROT;
862 x = accomp ? x | SC_COMP_AC : x & ~SC_COMP_AC;
863 x = sync_serial ? x | SC_SYNC : x & ~SC_SYNC;
867 /********************************************************************
869 * ppp_set_xaccm - set the extended transmit ACCM for the interface.
872 void ppp_set_xaccm (int unit, ext_accm accm)
874 SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
875 accm[0], accm[1], accm[2], accm[3]));
877 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
878 if ( ! ok_error (errno))
879 warn("ioctl(set extended ACCM): %m(%d)", errno);
883 /********************************************************************
885 * ppp_recv_config - configure the receive-side characteristics of
889 void ppp_recv_config (int unit,int mru,u_int32_t asyncmap,int pcomp,int accomp)
893 SYSDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
895 * If we were called because the link has gone down then there is nothing
896 * which may be done. Just return without incident.
901 * Set the receiver parameters
903 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
904 if ( ! ok_error (errno))
905 error("ioctl(PPPIOCSMRU): %m(%d)", errno);
908 SYSDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
909 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
910 if (!ok_error(errno))
911 error("ioctl(PPPIOCSRASYNCMAP): %m(%d)", errno);
915 x = !accomp? x | SC_REJ_COMP_AC: x &~ SC_REJ_COMP_AC;
919 /********************************************************************
921 * ccp_test - ask kernel whether a given compression method
922 * is acceptable for use.
925 int ccp_test (int unit, u_char *opt_ptr, int opt_len, int for_transmit)
927 struct ppp_option_data data;
929 memset (&data, '\0', sizeof (data));
931 data.length = opt_len;
932 data.transmit = for_transmit;
934 if (ioctl(ppp_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
937 return (errno == ENOBUFS)? 0: -1;
940 /********************************************************************
942 * ccp_flags_set - inform kernel about the current state of CCP.
945 void ccp_flags_set (int unit, int isopen, int isup)
949 x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
950 x = isup? x | SC_CCP_UP : x &~ SC_CCP_UP;
955 /********************************************************************
957 * get_idle_time - return how long the link has been idle.
964 return ioctl(ppp_fd, PPPIOCGIDLE, ip) >= 0;
967 /********************************************************************
969 * get_ppp_stats - return statistics for the link.
972 get_ppp_stats(u, stats)
974 struct pppd_stats *stats;
976 struct ifpppstatsreq req;
978 memset (&req, 0, sizeof (req));
980 req.stats_ptr = (caddr_t) &req.stats;
981 strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
982 if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
983 error("Couldn't get PPP statistics: %m");
986 stats->bytes_in = req.stats.p.ppp_ibytes;
987 stats->bytes_out = req.stats.p.ppp_obytes;
991 /********************************************************************
993 * ccp_fatal_error - returns 1 if decompression was disabled as a
994 * result of an error detected after decompression of a packet,
995 * 0 otherwise. This is necessary because of patent nonsense.
998 int ccp_fatal_error (int unit)
1000 int x = get_flags();
1002 return x & SC_DC_FERROR;
1006 * path_to_route - determine the path to the proc file system data
1008 #define ROUTE_MAX_COLS 12
1009 FILE *route_fd = (FILE *) 0;
1010 static char route_buffer [512];
1011 static int route_dev_col, route_dest_col, route_gw_col;
1012 static int route_flags_col, route_mask_col;
1013 static int route_num_cols;
1015 static char *path_to_route (void);
1016 static int open_route_table (void);
1017 static void close_route_table (void);
1018 static int read_route_table (struct rtentry *rt);
1020 /********************************************************************
1022 * path_to_procfs - find the path to the proc file system mount point
1025 static int path_to_procfs (void)
1027 struct mntent *mntent;
1030 fp = fopen(MOUNTED, "r");
1032 /* Default the mount location of /proc */
1033 strlcpy (route_buffer, "/proc", sizeof (route_buffer));
1037 while ((mntent = getmntent(fp)) != NULL) {
1038 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1040 if (strcmp(mntent->mnt_type, "proc") == 0)
1047 strlcpy(route_buffer, mntent->mnt_dir, sizeof (route_buffer));
1051 /********************************************************************
1053 * path_to_route - find the path to the route tables in the proc file system
1056 static char *path_to_route (void)
1058 if (!path_to_procfs()) {
1059 error("proc file system not mounted");
1062 strlcat (route_buffer, "/net/route", sizeof(route_buffer));
1063 return (route_buffer);
1066 /********************************************************************
1068 * close_route_table - close the interface to the route table
1071 static void close_route_table (void)
1073 if (route_fd != (FILE *) 0) {
1075 route_fd = (FILE *) 0;
1079 /********************************************************************
1081 * open_route_table - open the interface to the route table
1083 static char route_delims[] = " \t\n";
1085 static int open_route_table (void)
1089 close_route_table();
1091 path = path_to_route();
1095 route_fd = fopen (path, "r");
1096 if (route_fd == NULL) {
1097 error("can't open %s: %m (%d)", path, errno);
1101 route_dev_col = 0; /* default to usual columns */
1104 route_flags_col = 3;
1108 /* parse header line */
1109 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1110 char *p = route_buffer, *q;
1112 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1114 if ((q = strtok(p, route_delims)) == 0)
1116 if (strcasecmp(q, "iface") == 0)
1117 route_dev_col = col;
1118 else if (strcasecmp(q, "destination") == 0)
1119 route_dest_col = col;
1120 else if (strcasecmp(q, "gateway") == 0)
1122 else if (strcasecmp(q, "flags") == 0)
1123 route_flags_col = col;
1124 else if (strcasecmp(q, "mask") == 0)
1125 route_mask_col = col;
1128 if (used && col >= route_num_cols)
1129 route_num_cols = col + 1;
1137 /********************************************************************
1139 * read_route_table - read the next entry from the route table
1142 static int read_route_table(struct rtentry *rt)
1144 char *cols[ROUTE_MAX_COLS], *p;
1147 memset (rt, '\0', sizeof (struct rtentry));
1149 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1153 for (col = 0; col < route_num_cols; ++col) {
1154 cols[col] = strtok(p, route_delims);
1155 if (cols[col] == NULL)
1156 return 0; /* didn't get enough columns */
1159 ((struct sockaddr_in *) &rt->rt_dst)->sin_addr.s_addr =
1160 strtoul(cols[route_dest_col], NULL, 16);
1162 ((struct sockaddr_in *) &rt->rt_gateway)->sin_addr.s_addr =
1163 strtoul(cols[route_gw_col], NULL, 16);
1165 ((struct sockaddr_in *) &rt->rt_genmask)->sin_addr.s_addr =
1166 strtoul(cols[route_mask_col], NULL, 16);
1168 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1169 rt->rt_dev = cols[route_dev_col];
1174 /********************************************************************
1176 * defaultroute_exists - determine if there is a default route
1179 static int defaultroute_exists (struct rtentry *rt)
1183 if (!open_route_table())
1186 while (read_route_table(rt) != 0) {
1187 if ((rt->rt_flags & RTF_UP) == 0)
1190 if (((struct sockaddr_in *) (&rt->rt_dst))->sin_addr.s_addr == 0L) {
1196 close_route_table();
1201 * have_route_to - determine if the system has any route to
1202 * a given IP address. `addr' is in network byte order.
1203 * Return value is 1 if yes, 0 if no, -1 if don't know.
1204 * For demand mode to work properly, we have to ignore routes
1205 * through our own interface.
1207 int have_route_to(u_int32_t addr)
1212 if (!open_route_table())
1213 return -1; /* don't know */
1215 while (read_route_table(&rt)) {
1216 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1218 if ((addr & ((struct sockaddr_in *)&rt.rt_genmask)->sin_addr.s_addr)
1219 == ((struct sockaddr_in *)&rt.rt_dst)->sin_addr.s_addr) {
1225 close_route_table();
1229 /********************************************************************
1231 * sifdefaultroute - assign a default route through the address given.
1234 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1238 if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0) {
1239 struct in_addr old_gateway =
1240 ((struct sockaddr_in *) (&rt.rt_gateway))-> sin_addr;
1242 if (old_gateway.s_addr != gateway)
1243 error("not replacing existing default route to %s [%I]",
1244 rt.rt_dev, old_gateway);
1248 memset (&rt, '\0', sizeof (rt));
1249 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1250 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1252 if (kernel_version > KVERSION(2,1,0)) {
1253 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1254 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = 0L;
1257 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = gateway;
1259 rt.rt_flags = RTF_UP | RTF_GATEWAY | RTF_DEFAULT;
1260 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1261 if ( ! ok_error ( errno ))
1262 error("default route ioctl(SIOCADDRT): %m(%d)", errno);
1266 default_route_gateway = gateway;
1270 /********************************************************************
1272 * cifdefaultroute - delete a default route through the address given.
1275 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1279 default_route_gateway = 0;
1281 memset (&rt, '\0', sizeof (rt));
1282 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1283 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1285 if (kernel_version > KVERSION(2,1,0)) {
1286 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1287 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = 0L;
1290 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = gateway;
1292 rt.rt_flags = RTF_UP | RTF_GATEWAY | RTF_DEFAULT;
1293 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1295 if ( ! ok_error ( errno ))
1296 error("default route ioctl(SIOCDELRT): %m (%d)", errno);
1304 /********************************************************************
1306 * sifproxyarp - Make a proxy ARP entry for the peer.
1309 int sifproxyarp (int unit, u_int32_t his_adr)
1311 struct arpreq arpreq;
1313 if (has_proxy_arp == 0) {
1314 memset (&arpreq, '\0', sizeof(arpreq));
1316 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1317 ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = his_adr;
1318 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1320 * Get the hardware address of an interface on the same subnet
1321 * as our local address.
1323 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
1324 sizeof(proxy_arp_dev))) {
1325 error("Cannot determine ethernet address for proxy ARP");
1328 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1330 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
1331 if ( ! ok_error ( errno ))
1332 error("ioctl(SIOCSARP): %m(%d)", errno);
1335 proxy_arp_addr = his_adr;
1342 /********************************************************************
1344 * cifproxyarp - Delete the proxy ARP entry for the peer.
1347 int cifproxyarp (int unit, u_int32_t his_adr)
1349 struct arpreq arpreq;
1351 if (has_proxy_arp) {
1353 memset (&arpreq, '\0', sizeof(arpreq));
1354 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1355 ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = his_adr;
1356 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1357 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1359 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
1360 if ( ! ok_error ( errno ))
1361 warn("ioctl(SIOCDARP): %m(%d)", errno);
1368 /********************************************************************
1370 * get_ether_addr - get the hardware address of an interface on the
1371 * the same subnet as ipaddr.
1374 static int get_ether_addr (u_int32_t ipaddr,
1375 struct sockaddr *hwaddr,
1376 char *name, int namelen)
1378 struct ifreq *ifr, *ifend;
1379 u_int32_t ina, mask;
1382 struct ifreq ifs[MAX_IFS];
1384 ifc.ifc_len = sizeof(ifs);
1386 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1387 if ( ! ok_error ( errno ))
1388 error("ioctl(SIOCGIFCONF): %m(%d)", errno);
1392 SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1393 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1395 * Scan through looking for an interface with an Internet
1396 * address on the same subnet as `ipaddr'.
1398 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1399 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1400 if (ifr->ifr_addr.sa_family == AF_INET) {
1401 ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
1402 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1403 SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1406 * Check that the interface is up, and not point-to-point
1409 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1412 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1415 * Get its netmask and check that it's on the right subnet.
1417 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1420 mask = ((struct sockaddr_in *) &ifreq.ifr_addr)->sin_addr.s_addr;
1421 SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1422 ip_ntoa(ina), ntohl(mask)));
1424 if (((ipaddr ^ ina) & mask) != 0)
1433 strlcpy(name, ifreq.ifr_name, namelen);
1434 info("found interface %s for proxy arp", name);
1436 * Now get the hardware address.
1438 memset (&ifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1439 if (ioctl (sock_fd, SIOCGIFHWADDR, &ifreq) < 0) {
1440 error("SIOCGIFHWADDR(%s): %m(%d)", ifreq.ifr_name, errno);
1446 sizeof (struct sockaddr));
1448 SYSDEBUG ((LOG_DEBUG,
1449 "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1450 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1451 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1452 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1453 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1454 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1455 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1456 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1457 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1461 /********************************************************************
1463 * Return user specified netmask, modified by any mask we might determine
1464 * for address `addr' (in network byte order).
1465 * Here we scan through the system's list of interfaces, looking for
1466 * any non-point-to-point interfaces which might appear to be on the same
1467 * network as `addr'. If we find any, we OR in their netmask to the
1468 * user-specified netmask.
1471 u_int32_t GetMask (u_int32_t addr)
1473 u_int32_t mask, nmask, ina;
1474 struct ifreq *ifr, *ifend, ifreq;
1476 struct ifreq ifs[MAX_IFS];
1480 if (IN_CLASSA(addr)) /* determine network mask for address class */
1481 nmask = IN_CLASSA_NET;
1482 else if (IN_CLASSB(addr))
1483 nmask = IN_CLASSB_NET;
1485 nmask = IN_CLASSC_NET;
1487 /* class D nets are disallowed by bad_ip_adrs */
1488 mask = netmask | htonl(nmask);
1490 * Scan through the system's network interfaces.
1492 ifc.ifc_len = sizeof(ifs);
1494 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1495 if ( ! ok_error ( errno ))
1496 warn("ioctl(SIOCGIFCONF): %m(%d)", errno);
1500 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1501 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1503 * Check the interface's internet address.
1505 if (ifr->ifr_addr.sa_family != AF_INET)
1507 ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
1508 if (((ntohl(ina) ^ addr) & nmask) != 0)
1511 * Check that the interface is up, and not point-to-point nor loopback.
1513 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1514 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1517 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1520 * Get its netmask and OR it into our mask.
1522 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1524 mask |= ((struct sockaddr_in *)&ifreq.ifr_addr)->sin_addr.s_addr;
1530 /********************************************************************
1532 * Internal routine to decode the version.modification.patch level
1535 static void decode_version (char *buf, int *version,
1536 int *modification, int *patch)
1538 *version = (int) strtoul (buf, &buf, 10);
1544 *modification = (int) strtoul (buf, &buf, 10);
1547 *patch = (int) strtoul (buf, &buf, 10);
1558 /********************************************************************
1560 * Procedure to determine if the PPP line discipline is registered.
1564 ppp_registered(void)
1572 * We used to open the serial device and set it to the ppp line
1573 * discipline here, in order to create a ppp unit. But that is
1574 * not a good idea - the user might have specified a device that
1575 * they can't open (permission, or maybe it doesn't really exist).
1576 * So we grab a pty master/slave pair and use that.
1578 if (!get_pty(&mfd, &local_fd, slave, 0)) {
1579 no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
1584 * Try to put the device into the PPP discipline.
1586 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
1587 error("ioctl(TIOCSETD(PPP)): %m(%d)", errno);
1596 /********************************************************************
1598 * ppp_available - check whether the system has any ppp interfaces
1599 * (in fact we check whether we can do an ioctl on ppp0).
1602 int ppp_available(void)
1607 int my_version, my_modification, my_patch;
1610 "This system lacks kernel support for PPP. This could be because\n"
1611 "the PPP kernel module is not loaded, or because the kernel is\n"
1612 "not configured for PPP. See the README.linux file in the\n"
1613 "ppp-2.3.7 distribution.\n";
1616 * Open a socket for doing the ioctl operations.
1618 s = socket(AF_INET, SOCK_DGRAM, 0);
1622 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1623 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1625 * If the device did not exist then attempt to create one by putting the
1626 * current tty into the PPP discipline. If this works then obtain the
1627 * flags for the device again.
1630 if (ppp_registered()) {
1631 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1632 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1636 * Ensure that the hardware address is for PPP and not something else
1639 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
1641 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
1645 * This is the PPP device. Validate the version of the driver at this
1646 * point to ensure that this program will work with the driver.
1649 char abBuffer [1024];
1651 ifr.ifr_data = abBuffer;
1652 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
1654 error("Couldn't read driver version: %m");
1656 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
1659 decode_version(abBuffer,
1661 &driver_modification,
1664 * Validate the version of the driver against the version that we used.
1666 decode_version(VERSION,
1671 /* The version numbers must match */
1672 if (driver_version != my_version)
1675 /* The modification levels must be legal */
1676 if (driver_modification < 3) {
1677 if (driver_modification >= 2) {
1678 /* we can cope with 2.2.0 and above */
1687 slprintf(route_buffer, sizeof(route_buffer),
1688 "Sorry - PPP driver version %d.%d.%d is out of date\n",
1689 driver_version, driver_modification, driver_patch);
1691 no_ppp_msg = route_buffer;
1698 /********************************************************************
1700 * Update the wtmp file with the appropriate user name and tty device.
1703 void logwtmp (const char *line, const char *name, const char *host)
1706 struct utmp ut, *utp;
1707 pid_t mypid = getpid();
1709 * Update the signon database for users.
1710 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
1712 utmpname(_PATH_UTMP);
1714 while ((utp = getutent()) && (utp->ut_pid != mypid))
1717 /* Is this call really necessary? There is another one after the 'put' */
1721 memcpy(&ut, utp, sizeof(ut));
1723 /* some gettys/telnetds don't initialize utmp... */
1724 memset(&ut, 0, sizeof(ut));
1726 if (ut.ut_id[0] == 0)
1727 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
1729 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
1730 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
1734 ut.ut_type = USER_PROCESS;
1737 /* Insert the host name if one is supplied */
1739 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
1741 /* Insert the IP address of the remote system if IP is enabled */
1742 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
1743 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
1744 sizeof(ut.ut_addr));
1746 /* CL: Makes sure that the logout works */
1747 if (*host == 0 && *name==0)
1753 * Update the wtmp file.
1755 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
1757 flock(wtmp, LOCK_EX);
1759 /* we really should check for error on the write for a full disk! */
1760 write (wtmp, (char *)&ut, sizeof(ut));
1763 flock(wtmp, LOCK_UN);
1768 /********************************************************************
1769 * Code for locking/unlocking the serial device.
1770 * This code is derived from chat.c.
1774 #define LOCK_PREFIX "/var/lock/LCK.."
1777 static char *lock_file;
1780 * lock - create a lock file for the named device
1783 int lock (char *dev)
1787 lock_file = strdup(dev);
1788 if (lock_file == NULL)
1789 novm("lock file name");
1790 result = mklock (dev, (void *) 0);
1793 notice("Device %s is locked by pid %d", dev, result);
1800 error("Can't create lock file %s", lock_file);
1808 char hdb_lock_buffer[12];
1814 p = strrchr(dev, '/');
1818 l = strlen(LOCK_PREFIX) + strlen(dev) + 1;
1819 lock_file = malloc(l);
1820 if (lock_file == NULL)
1821 novm("lock file name");
1823 slprintf(lock_file, l, "%s%s", LOCK_PREFIX, dev);
1825 * Attempt to create the lock file at this point.
1828 fd = open(lock_file, O_EXCL | O_CREAT | O_RDWR, 0644);
1832 slprintf(hdb_lock_buffer, sizeof(hdb_lock_buffer), "%010d\n", pid);
1833 write (fd, hdb_lock_buffer, 11);
1835 write(fd, &pid, sizeof (pid));
1841 * If the file exists then check to see if the pid is stale
1843 if (errno == EEXIST) {
1844 fd = open(lock_file, O_RDONLY, 0);
1846 if (errno == ENOENT) /* This is just a timing problem. */
1851 /* Read the lock file to find out who has the device locked */
1852 n = read (fd, hdb_lock_buffer, 11);
1855 error("Can't read pid from lock file %s", lock_file);
1859 /* See the process still exists. */
1862 hdb_lock_buffer[n] = '\0';
1863 sscanf (hdb_lock_buffer, " %d", &pid);
1865 pid = ((int *) hdb_lock_buffer)[0];
1867 if (pid == 0 || pid == getpid()
1868 || (kill(pid, 0) == -1 && errno == ESRCH))
1872 /* If the process does not exist then try to remove the lock */
1873 if (n == 0 && unlink (lock_file) == 0) {
1874 notice("Removed stale lock on %s (pid %d)",
1879 notice("Device %s is locked by pid %d", dev, pid);
1883 error("Can't create lock file %s: %m(%d)", lock_file, errno);
1894 /********************************************************************
1896 * unlock - remove our lockfile
1903 (void) rmlock (lock_file, (void *) 0);
1913 /********************************************************************
1915 * sifvjcomp - config tcp header compression
1918 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
1920 u_int x = get_flags();
1923 if (ioctl (ppp_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
1924 if (! ok_error (errno))
1925 error("ioctl(PPPIOCSMAXCID): %m(%d)", errno);
1930 x = vjcomp ? x | SC_COMP_TCP : x &~ SC_COMP_TCP;
1931 x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
1937 /********************************************************************
1939 * sifup - Config the interface up and enable IP packets to pass.
1946 memset (&ifr, '\0', sizeof (ifr));
1947 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1948 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
1949 if (! ok_error (errno))
1950 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
1954 ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
1955 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
1956 if (! ok_error (errno))
1957 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
1964 /********************************************************************
1966 * sifdown - Config the interface down and disable IP.
1975 memset (&ifr, '\0', sizeof (ifr));
1976 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1977 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
1978 if (! ok_error (errno))
1979 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
1983 ifr.ifr_flags &= ~IFF_UP;
1984 ifr.ifr_flags |= IFF_POINTOPOINT;
1985 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
1986 if (! ok_error (errno))
1987 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
1993 /********************************************************************
1995 * sifaddr - Config the interface IP addresses and netmask.
1998 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2004 memset (&ifr, '\0', sizeof (ifr));
2005 memset (&rt, '\0', sizeof (rt));
2007 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
2008 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2009 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2011 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2013 * Set our IP address
2015 ((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr.s_addr = our_adr;
2016 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2017 if (errno != EEXIST) {
2018 if (! ok_error (errno))
2019 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
2022 warn("ioctl(SIOCSIFADDR): Address already exists");
2027 * Set the gateway address
2029 ((struct sockaddr_in *) &ifr.ifr_dstaddr)->sin_addr.s_addr = his_adr;
2030 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2031 if (! ok_error (errno))
2032 error("ioctl(SIOCSIFDSTADDR): %m(%d)", errno);
2037 * For recent kernels, force the netmask to 255.255.255.255.
2039 if (kernel_version >= KVERSION(2,1,16))
2041 if (net_mask != 0) {
2042 ((struct sockaddr_in *) &ifr.ifr_netmask)->sin_addr.s_addr = net_mask;
2043 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2044 if (! ok_error (errno))
2045 error("ioctl(SIOCSIFNETMASK): %m(%d)", errno);
2050 * Add the device route
2052 if (kernel_version < KVERSION(2,1,16)) {
2053 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2054 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2057 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = 0L;
2058 ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr = his_adr;
2059 rt.rt_flags = RTF_UP | RTF_HOST;
2061 if (kernel_version > KVERSION(2,1,0)) {
2062 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2063 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = -1L;
2066 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2067 if (! ok_error (errno))
2068 error("ioctl(SIOCADDRT) device route: %m(%d)", errno);
2075 /********************************************************************
2077 * cifaddr - Clear the interface IP addresses, and delete routes
2078 * through the interface if possible.
2081 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2085 if (kernel_version < KVERSION(2,1,16)) {
2087 * Delete the route through the device
2089 memset (&rt, '\0', sizeof (rt));
2091 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2092 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2095 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = 0;
2096 ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr = his_adr;
2097 rt.rt_flags = RTF_UP | RTF_HOST;
2099 if (kernel_version > KVERSION(2,1,0)) {
2100 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2101 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = -1L;
2104 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2105 if (still_ppp() && ! ok_error (errno))
2106 error("ioctl(SIOCDELRT) device route: %m(%d)", errno);
2114 * get_pty - get a pty master/slave pair and chown the slave side
2115 * to the uid given. Assumes slave_name points to >= 12 bytes of space.
2118 get_pty(master_fdp, slave_fdp, slave_name, uid)
2126 struct termios tios;
2129 for (i = 0; i < 64; ++i) {
2130 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2131 'p' + i / 16, i % 16);
2132 mfd = open(pty_name, O_RDWR, 0);
2135 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2144 strlcpy(slave_name, pty_name, 12);
2147 fchown(sfd, uid, -1);
2148 fchmod(sfd, S_IRUSR | S_IWUSR);
2149 if (tcgetattr(sfd, &tios) == 0) {
2150 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2151 tios.c_cflag |= CS8 | CREAD;
2152 tios.c_iflag = IGNPAR | CLOCAL;
2155 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2156 warn("couldn't set attributes on pty: %m");
2158 warn("couldn't get attributes on pty: %m");
2163 /********************************************************************
2165 * open_loopback - open the device we use for getting packets
2166 * in demand mode. Under Linux, we use a pty master/slave pair.
2169 open_ppp_loopback(void)
2173 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2174 fatal("No free pty for loopback");
2175 SYSDEBUG(("using %s for loopback", loop_name));
2177 set_ppp_fd(slave_fd);
2179 flags = fcntl(master_fd, F_GETFL);
2181 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2182 warn("couldn't set master loopback to nonblock: %m(%d)", errno);
2184 flags = fcntl(ppp_fd, F_GETFL);
2186 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2187 warn("couldn't set slave loopback to nonblock: %m(%d)", errno);
2189 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2190 fatal("ioctl(TIOCSETD): %m(%d)", errno);
2192 * Find out which interface we were given.
2194 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2195 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
2197 * Enable debug in the driver if requested.
2199 set_kdebugflag (kdebugflag);
2204 /********************************************************************
2206 * restore_loop - reattach the ppp unit to the loopback.
2208 * The kernel ppp driver automatically reattaches the ppp unit to
2209 * the loopback if the serial port is set to a line discipline other
2210 * than ppp, or if it detects a modem hangup. The former will happen
2211 * in disestablish_ppp if the latter hasn't already happened, so we
2212 * shouldn't need to do anything.
2214 * Just to be sure, set the real serial port to the normal discipline.
2220 if (ppp_fd != slave_fd) {
2221 (void) ioctl(ppp_fd, TIOCSETD, &tty_disc);
2222 set_ppp_fd(slave_fd);
2226 /********************************************************************
2228 * sifnpmode - Set the mode for handling packets for a given NP.
2232 sifnpmode(u, proto, mode)
2239 npi.protocol = proto;
2241 if (ioctl(ppp_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2242 if (! ok_error (errno)) {
2243 error("ioctl(PPPIOCSNPMODE, %d, %d): %m (%d)",
2244 proto, mode, errno);
2245 error("ppp_fd=%d slave_fd=%d\n", ppp_fd, slave_fd);
2253 /********************************************************************
2255 * sipxfaddr - Config the interface IPX networknumber
2258 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2265 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2267 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2269 if (! ok_error (errno))
2270 dbglog("socket(AF_IPX): %m (%d)", errno);
2274 memset (&ifr, '\0', sizeof (ifr));
2275 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2277 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2278 sipx->sipx_family = AF_IPX;
2279 sipx->sipx_port = 0;
2280 sipx->sipx_network = htonl (network);
2281 sipx->sipx_type = IPX_FRAME_ETHERII;
2282 sipx->sipx_action = IPX_CRTITF;
2284 * Set the IPX device
2286 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2288 if (errno != EEXIST) {
2289 if (! ok_error (errno))
2290 dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (%d)", errno);
2293 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2302 /********************************************************************
2304 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2305 * are removed and the device is no longer able to pass IPX
2309 int cipxfaddr (int unit)
2316 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2318 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2320 if (! ok_error (errno))
2321 dbglog("socket(AF_IPX): %m (%d)", errno);
2325 memset (&ifr, '\0', sizeof (ifr));
2326 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2328 sipx->sipx_type = IPX_FRAME_ETHERII;
2329 sipx->sipx_action = IPX_DLTITF;
2330 sipx->sipx_family = AF_IPX;
2332 * Set the IPX device
2334 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2335 if (! ok_error (errno))
2336 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (%d)", errno);
2347 * daemon - Detach us from controlling terminal session.
2350 daemon(nochdir, noclose)
2351 int nochdir, noclose;
2355 if ((pid = fork()) < 0)
2358 exit(0); /* parent dies */
2363 fclose(stdin); /* don't need stdin, stdout, stderr */
2372 * Use the hostname as part of the random number seed.
2381 for (p = hostname; *p != 0; ++p)
2386 /********************************************************************
2388 * sys_check_options - check the options that the user specified
2392 sys_check_options(void)
2395 struct stat stat_buf;
2397 * Disable the IPX protocol if the support is not present in the kernel.
2398 * If we disable it then ensure that IP support is enabled.
2400 while (ipxcp_protent.enabled_flag) {
2401 if (path_to_procfs()) {
2402 strlcat (route_buffer, "/net/ipx_interface", sizeof(route_buffer));
2403 if (lstat (route_buffer, &stat_buf) >= 0)
2406 error("IPX support is not present in the kernel\n");
2407 ipxcp_protent.enabled_flag = 0;
2408 ipcp_protent.enabled_flag = 1;
2412 if (demand && driver_is_old) {
2413 option_error("demand dialling is not supported by kernel driver "
2414 "version %d.%d.%d", driver_version, driver_modification,