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)
388 * Flush the tty output buffer so that the TIOCSETD doesn't hang.
389 * We may have to do this several times because the tcflush only
390 * affects the serial driver, and may trigger the ppp driver to
391 * supply more data to the serial driver.
394 if (tcflush(tty_fd, TCIOFLUSH) < 0)
397 } while (ioctl(tty_fd, TIOCOUTQ, &nout) >= 0 && nout > 0);
399 * Restore the previous line discipline
401 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
402 if ( ! ok_error (errno))
403 error("ioctl(TIOCSETD, N_TTY): %m");
406 if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
407 if ( ! ok_error (errno))
408 warn("ioctl(TIOCNXCL): %m(%d)", errno);
411 /* Reset non-blocking mode on fd. */
412 if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0) {
413 if ( ! ok_error (errno))
414 warn("Couldn't restore device fd flags: %m");
420 /********************************************************************
422 * clean_check - Fetch the flags for the device and generate
423 * appropriate error messages.
425 void clean_check(void)
431 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
433 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
435 case SC_RCV_B7_0 | SC_RCV_EVNP:
436 case SC_RCV_B7_0 | SC_RCV_ODDP:
437 case SC_RCV_B7_0 | SC_RCV_ODDP | SC_RCV_EVNP:
438 s = "all had bit 7 set to 1";
442 case SC_RCV_B7_1 | SC_RCV_EVNP:
443 case SC_RCV_B7_1 | SC_RCV_ODDP:
444 case SC_RCV_B7_1 | SC_RCV_ODDP | SC_RCV_EVNP:
445 s = "all had bit 7 set to 0";
449 s = "all had odd parity";
453 s = "all had even parity";
458 warn("Receive serial link is not 8-bit clean:");
459 warn("Problem: %s", s);
467 * List of valid speeds.
471 int speed_int, speed_val;
548 /********************************************************************
550 * Translate from bits/second to a speed_t.
553 static int translate_speed (int bps)
555 struct speed *speedp;
558 for (speedp = speeds; speedp->speed_int; speedp++) {
559 if (bps == speedp->speed_int)
560 return speedp->speed_val;
562 warn("speed %d not supported", bps);
567 /********************************************************************
569 * Translate from a speed_t to bits/second.
572 static int baud_rate_of (int speed)
574 struct speed *speedp;
577 for (speedp = speeds; speedp->speed_int; speedp++) {
578 if (speed == speedp->speed_val)
579 return speedp->speed_int;
585 /********************************************************************
587 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
588 * at the requested speed, etc. If `local' is true, set CLOCAL
589 * regardless of whether the modem option was specified.
592 void set_up_tty(int tty_fd, int local)
598 if (tcgetattr(tty_fd, &tios) < 0) {
599 if (!ok_error(errno))
600 fatal("tcgetattr: %m(%d)", errno);
607 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
608 tios.c_cflag |= CS8 | CREAD | HUPCL;
610 tios.c_iflag = IGNBRK | IGNPAR;
614 tios.c_cc[VTIME] = 0;
617 tios.c_cflag ^= (CLOCAL | HUPCL);
621 tios.c_cflag |= CRTSCTS;
625 tios.c_iflag |= IXON | IXOFF;
626 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
627 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
631 tios.c_cflag &= ~CRTSCTS;
638 speed = translate_speed(inspeed);
640 cfsetospeed (&tios, speed);
641 cfsetispeed (&tios, speed);
644 * We can't proceed if the serial port speed is B0,
645 * since that implies that the serial port is disabled.
648 speed = cfgetospeed(&tios);
650 fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
653 if (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0)
654 if (!ok_error(errno))
655 fatal("tcsetattr: %m");
657 baud_rate = baud_rate_of(speed);
661 /********************************************************************
663 * setdtr - control the DTR line on the serial port.
664 * This is called from die(), so it shouldn't call die().
667 void setdtr (int tty_fd, int on)
669 int modembits = TIOCM_DTR;
671 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
674 /********************************************************************
676 * restore_tty - restore the terminal to the saved settings.
679 void restore_tty (int tty_fd)
684 * Turn off echoing, because otherwise we can get into
685 * a loop with the tty and the modem echoing to each other.
686 * We presume we are the sole user of this tty device, so
687 * when we close it, it will revert to its defaults anyway.
690 inittermios.c_lflag &= ~(ECHO | ECHONL);
692 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
693 if (! ok_error (errno))
694 warn("tcsetattr: %m");
699 /********************************************************************
701 * output - Output PPP packet.
704 void output (int unit, unsigned char *p, int len)
707 dbglog("sent %P", p, len);
709 if (write(ppp_fd, p, len) < 0) {
710 if (errno == EWOULDBLOCK || errno == ENOBUFS
711 || errno == ENXIO || errno == EIO || errno == EINTR)
712 warn("write: warning: %m (%d)", errno);
714 error("write: %m (%d)", errno);
718 /********************************************************************
720 * wait_input - wait until there is data available,
721 * for the length of time specified by *timo (indefinite
725 void wait_input(struct timeval *timo)
731 n = select(max_in_fd + 1, &ready, NULL, &ready, timo);
732 if (n < 0 && errno != EINTR)
733 fatal("select: %m(%d)", errno);
737 * add_fd - add an fd to the set that wait_input waits for.
747 * remove_fd - remove an fd from the set that wait_input waits for.
749 void remove_fd(int fd)
755 /********************************************************************
757 * wait_loop_output - wait until there is data available on the
758 * loopback, for the length of time specified by *timo (indefinite
761 void wait_loop_output(timo)
762 struct timeval *timo;
768 FD_SET(master_fd, &ready);
769 n = select(master_fd + 1, &ready, NULL, &ready, timo);
770 if (n < 0 && errno != EINTR)
771 fatal("select: %m(%d)", errno);
774 /********************************************************************
776 * wait_time - wait for a given length of time or until a
777 * signal is received.
781 struct timeval *timo;
785 n = select(0, NULL, NULL, NULL, timo);
786 if (n < 0 && errno != EINTR)
787 fatal("select: %m(%d)", errno);
791 /********************************************************************
793 * read_packet - get a PPP packet from the serial device.
796 int read_packet (unsigned char *buf)
800 len = read(ppp_fd, buf, PPP_MTU + PPP_HDRLEN);
802 if (errno == EWOULDBLOCK || errno == EIO)
804 fatal("read: %m(%d)", errno);
809 /********************************************************************
811 * get_loop_output - get outgoing packets from the ppp device,
812 * and detect when we want to bring the real link up.
813 * Return value is 1 if we need to bring up the link, 0 otherwise.
816 get_loop_output(void)
819 int n = read(master_fd, inbuf, sizeof(inbuf));
822 if (loop_chars(inbuf, n))
824 n = read(master_fd, inbuf, sizeof(inbuf));
828 fatal("eof on loopback");
830 if (errno != EWOULDBLOCK)
831 fatal("read from loopback: %m(%d)", errno);
836 /********************************************************************
838 * ppp_send_config - configure the transmit characteristics of
842 void ppp_send_config (int unit,int mtu,u_int32_t asyncmap,int pcomp,int accomp)
847 SYSDEBUG ((LOG_DEBUG, "send_config: mtu = %d\n", mtu));
849 * Ensure that the link is still up.
854 * Set the MTU and other parameters for the ppp device
856 memset (&ifr, '\0', sizeof (ifr));
857 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
860 if (ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
861 fatal("ioctl(SIOCSIFMTU): %m(%d)", errno);
863 SYSDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
864 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
865 if (!ok_error(errno))
866 fatal("ioctl(PPPIOCSASYNCMAP): %m(%d)", errno);
871 x = pcomp ? x | SC_COMP_PROT : x & ~SC_COMP_PROT;
872 x = accomp ? x | SC_COMP_AC : x & ~SC_COMP_AC;
873 x = sync_serial ? x | SC_SYNC : x & ~SC_SYNC;
877 /********************************************************************
879 * ppp_set_xaccm - set the extended transmit ACCM for the interface.
882 void ppp_set_xaccm (int unit, ext_accm accm)
884 SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
885 accm[0], accm[1], accm[2], accm[3]));
887 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
888 if ( ! ok_error (errno))
889 warn("ioctl(set extended ACCM): %m(%d)", errno);
893 /********************************************************************
895 * ppp_recv_config - configure the receive-side characteristics of
899 void ppp_recv_config (int unit,int mru,u_int32_t asyncmap,int pcomp,int accomp)
903 SYSDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
905 * If we were called because the link has gone down then there is nothing
906 * which may be done. Just return without incident.
911 * Set the receiver parameters
913 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
914 if ( ! ok_error (errno))
915 error("ioctl(PPPIOCSMRU): %m(%d)", errno);
918 SYSDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
919 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
920 if (!ok_error(errno))
921 error("ioctl(PPPIOCSRASYNCMAP): %m(%d)", errno);
925 x = !accomp? x | SC_REJ_COMP_AC: x &~ SC_REJ_COMP_AC;
929 /********************************************************************
931 * ccp_test - ask kernel whether a given compression method
932 * is acceptable for use.
935 int ccp_test (int unit, u_char *opt_ptr, int opt_len, int for_transmit)
937 struct ppp_option_data data;
939 memset (&data, '\0', sizeof (data));
941 data.length = opt_len;
942 data.transmit = for_transmit;
944 if (ioctl(ppp_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
947 return (errno == ENOBUFS)? 0: -1;
950 /********************************************************************
952 * ccp_flags_set - inform kernel about the current state of CCP.
955 void ccp_flags_set (int unit, int isopen, int isup)
959 x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
960 x = isup? x | SC_CCP_UP : x &~ SC_CCP_UP;
965 /********************************************************************
967 * get_idle_time - return how long the link has been idle.
974 return ioctl(ppp_fd, PPPIOCGIDLE, ip) >= 0;
977 /********************************************************************
979 * get_ppp_stats - return statistics for the link.
982 get_ppp_stats(u, stats)
984 struct pppd_stats *stats;
986 struct ifpppstatsreq req;
988 memset (&req, 0, sizeof (req));
990 req.stats_ptr = (caddr_t) &req.stats;
991 strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
992 if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
993 error("Couldn't get PPP statistics: %m");
996 stats->bytes_in = req.stats.p.ppp_ibytes;
997 stats->bytes_out = req.stats.p.ppp_obytes;
1001 /********************************************************************
1003 * ccp_fatal_error - returns 1 if decompression was disabled as a
1004 * result of an error detected after decompression of a packet,
1005 * 0 otherwise. This is necessary because of patent nonsense.
1008 int ccp_fatal_error (int unit)
1010 int x = get_flags();
1012 return x & SC_DC_FERROR;
1016 * path_to_route - determine the path to the proc file system data
1018 #define ROUTE_MAX_COLS 12
1019 FILE *route_fd = (FILE *) 0;
1020 static char route_buffer [512];
1021 static int route_dev_col, route_dest_col, route_gw_col;
1022 static int route_flags_col, route_mask_col;
1023 static int route_num_cols;
1025 static char *path_to_route (void);
1026 static int open_route_table (void);
1027 static void close_route_table (void);
1028 static int read_route_table (struct rtentry *rt);
1030 /********************************************************************
1032 * path_to_procfs - find the path to the proc file system mount point
1035 static int path_to_procfs (void)
1037 struct mntent *mntent;
1040 fp = fopen(MOUNTED, "r");
1042 /* Default the mount location of /proc */
1043 strlcpy (route_buffer, "/proc", sizeof (route_buffer));
1047 while ((mntent = getmntent(fp)) != NULL) {
1048 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1050 if (strcmp(mntent->mnt_type, "proc") == 0)
1057 strlcpy(route_buffer, mntent->mnt_dir, sizeof (route_buffer));
1061 /********************************************************************
1063 * path_to_route - find the path to the route tables in the proc file system
1066 static char *path_to_route (void)
1068 if (!path_to_procfs()) {
1069 error("proc file system not mounted");
1072 strlcat (route_buffer, "/net/route", sizeof(route_buffer));
1073 return (route_buffer);
1076 /********************************************************************
1078 * close_route_table - close the interface to the route table
1081 static void close_route_table (void)
1083 if (route_fd != (FILE *) 0) {
1085 route_fd = (FILE *) 0;
1089 /********************************************************************
1091 * open_route_table - open the interface to the route table
1093 static char route_delims[] = " \t\n";
1095 static int open_route_table (void)
1099 close_route_table();
1101 path = path_to_route();
1105 route_fd = fopen (path, "r");
1106 if (route_fd == NULL) {
1107 error("can't open %s: %m (%d)", path, errno);
1111 route_dev_col = 0; /* default to usual columns */
1114 route_flags_col = 3;
1118 /* parse header line */
1119 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1120 char *p = route_buffer, *q;
1122 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1124 if ((q = strtok(p, route_delims)) == 0)
1126 if (strcasecmp(q, "iface") == 0)
1127 route_dev_col = col;
1128 else if (strcasecmp(q, "destination") == 0)
1129 route_dest_col = col;
1130 else if (strcasecmp(q, "gateway") == 0)
1132 else if (strcasecmp(q, "flags") == 0)
1133 route_flags_col = col;
1134 else if (strcasecmp(q, "mask") == 0)
1135 route_mask_col = col;
1138 if (used && col >= route_num_cols)
1139 route_num_cols = col + 1;
1147 /********************************************************************
1149 * read_route_table - read the next entry from the route table
1152 static int read_route_table(struct rtentry *rt)
1154 char *cols[ROUTE_MAX_COLS], *p;
1157 memset (rt, '\0', sizeof (struct rtentry));
1159 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1163 for (col = 0; col < route_num_cols; ++col) {
1164 cols[col] = strtok(p, route_delims);
1165 if (cols[col] == NULL)
1166 return 0; /* didn't get enough columns */
1169 ((struct sockaddr_in *) &rt->rt_dst)->sin_addr.s_addr =
1170 strtoul(cols[route_dest_col], NULL, 16);
1172 ((struct sockaddr_in *) &rt->rt_gateway)->sin_addr.s_addr =
1173 strtoul(cols[route_gw_col], NULL, 16);
1175 ((struct sockaddr_in *) &rt->rt_genmask)->sin_addr.s_addr =
1176 strtoul(cols[route_mask_col], NULL, 16);
1178 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1179 rt->rt_dev = cols[route_dev_col];
1184 /********************************************************************
1186 * defaultroute_exists - determine if there is a default route
1189 static int defaultroute_exists (struct rtentry *rt)
1193 if (!open_route_table())
1196 while (read_route_table(rt) != 0) {
1197 if ((rt->rt_flags & RTF_UP) == 0)
1200 if (((struct sockaddr_in *) (&rt->rt_dst))->sin_addr.s_addr == 0L) {
1206 close_route_table();
1211 * have_route_to - determine if the system has any route to
1212 * a given IP address. `addr' is in network byte order.
1213 * Return value is 1 if yes, 0 if no, -1 if don't know.
1214 * For demand mode to work properly, we have to ignore routes
1215 * through our own interface.
1217 int have_route_to(u_int32_t addr)
1222 if (!open_route_table())
1223 return -1; /* don't know */
1225 while (read_route_table(&rt)) {
1226 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1228 if ((addr & ((struct sockaddr_in *)&rt.rt_genmask)->sin_addr.s_addr)
1229 == ((struct sockaddr_in *)&rt.rt_dst)->sin_addr.s_addr) {
1235 close_route_table();
1239 /********************************************************************
1241 * sifdefaultroute - assign a default route through the address given.
1244 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1248 if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0) {
1249 struct in_addr old_gateway =
1250 ((struct sockaddr_in *) (&rt.rt_gateway))-> sin_addr;
1252 if (old_gateway.s_addr != gateway)
1253 error("not replacing existing default route to %s [%I]",
1254 rt.rt_dev, old_gateway);
1258 memset (&rt, '\0', sizeof (rt));
1259 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1260 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1262 if (kernel_version > KVERSION(2,1,0)) {
1263 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1264 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = 0L;
1267 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = gateway;
1269 rt.rt_flags = RTF_UP | RTF_GATEWAY | RTF_DEFAULT;
1270 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1271 if ( ! ok_error ( errno ))
1272 error("default route ioctl(SIOCADDRT): %m(%d)", errno);
1276 default_route_gateway = gateway;
1280 /********************************************************************
1282 * cifdefaultroute - delete a default route through the address given.
1285 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1289 default_route_gateway = 0;
1291 memset (&rt, '\0', sizeof (rt));
1292 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1293 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1295 if (kernel_version > KVERSION(2,1,0)) {
1296 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1297 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = 0L;
1300 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = gateway;
1302 rt.rt_flags = RTF_UP | RTF_GATEWAY | RTF_DEFAULT;
1303 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1305 if ( ! ok_error ( errno ))
1306 error("default route ioctl(SIOCDELRT): %m (%d)", errno);
1314 /********************************************************************
1316 * sifproxyarp - Make a proxy ARP entry for the peer.
1319 int sifproxyarp (int unit, u_int32_t his_adr)
1321 struct arpreq arpreq;
1323 if (has_proxy_arp == 0) {
1324 memset (&arpreq, '\0', sizeof(arpreq));
1326 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1327 ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = his_adr;
1328 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1330 * Get the hardware address of an interface on the same subnet
1331 * as our local address.
1333 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
1334 sizeof(proxy_arp_dev))) {
1335 error("Cannot determine ethernet address for proxy ARP");
1338 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1340 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
1341 if ( ! ok_error ( errno ))
1342 error("ioctl(SIOCSARP): %m(%d)", errno);
1345 proxy_arp_addr = his_adr;
1352 /********************************************************************
1354 * cifproxyarp - Delete the proxy ARP entry for the peer.
1357 int cifproxyarp (int unit, u_int32_t his_adr)
1359 struct arpreq arpreq;
1361 if (has_proxy_arp) {
1363 memset (&arpreq, '\0', sizeof(arpreq));
1364 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1365 ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = his_adr;
1366 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1367 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1369 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
1370 if ( ! ok_error ( errno ))
1371 warn("ioctl(SIOCDARP): %m(%d)", errno);
1378 /********************************************************************
1380 * get_ether_addr - get the hardware address of an interface on the
1381 * the same subnet as ipaddr.
1384 static int get_ether_addr (u_int32_t ipaddr,
1385 struct sockaddr *hwaddr,
1386 char *name, int namelen)
1388 struct ifreq *ifr, *ifend;
1389 u_int32_t ina, mask;
1392 struct ifreq ifs[MAX_IFS];
1394 ifc.ifc_len = sizeof(ifs);
1396 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1397 if ( ! ok_error ( errno ))
1398 error("ioctl(SIOCGIFCONF): %m(%d)", errno);
1402 SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1403 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1405 * Scan through looking for an interface with an Internet
1406 * address on the same subnet as `ipaddr'.
1408 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1409 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1410 if (ifr->ifr_addr.sa_family == AF_INET) {
1411 ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
1412 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1413 SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1416 * Check that the interface is up, and not point-to-point
1419 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1422 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1425 * Get its netmask and check that it's on the right subnet.
1427 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1430 mask = ((struct sockaddr_in *) &ifreq.ifr_addr)->sin_addr.s_addr;
1431 SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1432 ip_ntoa(ina), ntohl(mask)));
1434 if (((ipaddr ^ ina) & mask) != 0)
1443 strlcpy(name, ifreq.ifr_name, namelen);
1444 info("found interface %s for proxy arp", name);
1446 * Now get the hardware address.
1448 memset (&ifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1449 if (ioctl (sock_fd, SIOCGIFHWADDR, &ifreq) < 0) {
1450 error("SIOCGIFHWADDR(%s): %m(%d)", ifreq.ifr_name, errno);
1456 sizeof (struct sockaddr));
1458 SYSDEBUG ((LOG_DEBUG,
1459 "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1460 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1461 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1462 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1463 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1464 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1465 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1466 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1467 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1471 /********************************************************************
1473 * Return user specified netmask, modified by any mask we might determine
1474 * for address `addr' (in network byte order).
1475 * Here we scan through the system's list of interfaces, looking for
1476 * any non-point-to-point interfaces which might appear to be on the same
1477 * network as `addr'. If we find any, we OR in their netmask to the
1478 * user-specified netmask.
1481 u_int32_t GetMask (u_int32_t addr)
1483 u_int32_t mask, nmask, ina;
1484 struct ifreq *ifr, *ifend, ifreq;
1486 struct ifreq ifs[MAX_IFS];
1490 if (IN_CLASSA(addr)) /* determine network mask for address class */
1491 nmask = IN_CLASSA_NET;
1492 else if (IN_CLASSB(addr))
1493 nmask = IN_CLASSB_NET;
1495 nmask = IN_CLASSC_NET;
1497 /* class D nets are disallowed by bad_ip_adrs */
1498 mask = netmask | htonl(nmask);
1500 * Scan through the system's network interfaces.
1502 ifc.ifc_len = sizeof(ifs);
1504 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1505 if ( ! ok_error ( errno ))
1506 warn("ioctl(SIOCGIFCONF): %m(%d)", errno);
1510 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1511 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1513 * Check the interface's internet address.
1515 if (ifr->ifr_addr.sa_family != AF_INET)
1517 ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
1518 if (((ntohl(ina) ^ addr) & nmask) != 0)
1521 * Check that the interface is up, and not point-to-point nor loopback.
1523 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1524 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1527 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1530 * Get its netmask and OR it into our mask.
1532 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1534 mask |= ((struct sockaddr_in *)&ifreq.ifr_addr)->sin_addr.s_addr;
1540 /********************************************************************
1542 * Internal routine to decode the version.modification.patch level
1545 static void decode_version (char *buf, int *version,
1546 int *modification, int *patch)
1548 *version = (int) strtoul (buf, &buf, 10);
1554 *modification = (int) strtoul (buf, &buf, 10);
1557 *patch = (int) strtoul (buf, &buf, 10);
1568 /********************************************************************
1570 * Procedure to determine if the PPP line discipline is registered.
1574 ppp_registered(void)
1582 * We used to open the serial device and set it to the ppp line
1583 * discipline here, in order to create a ppp unit. But that is
1584 * not a good idea - the user might have specified a device that
1585 * they can't open (permission, or maybe it doesn't really exist).
1586 * So we grab a pty master/slave pair and use that.
1588 if (!get_pty(&mfd, &local_fd, slave, 0)) {
1589 no_ppp_msg = "Couldn't determine if PPP is supported (no free ptys)";
1594 * Try to put the device into the PPP discipline.
1596 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
1597 error("ioctl(TIOCSETD(PPP)): %m(%d)", errno);
1606 /********************************************************************
1608 * ppp_available - check whether the system has any ppp interfaces
1609 * (in fact we check whether we can do an ioctl on ppp0).
1612 int ppp_available(void)
1617 int my_version, my_modification, my_patch;
1620 "This system lacks kernel support for PPP. This could be because\n"
1621 "the PPP kernel module could not be loaded, or because PPP was not\n"
1622 "included in the kernel configuration. If PPP was included as a\n"
1623 "module, try `/sbin/modprobe -v ppp'. If that fails, check that\n"
1624 "ppp.o exists in /lib/modules/`uname -r`/net.\n"
1625 "See README.linux file in the ppp distribution for more details.\n";
1628 * Open a socket for doing the ioctl operations.
1630 s = socket(AF_INET, SOCK_DGRAM, 0);
1634 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1635 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1637 * If the device did not exist then attempt to create one by putting the
1638 * current tty into the PPP discipline. If this works then obtain the
1639 * flags for the device again.
1642 if (ppp_registered()) {
1643 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1644 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1648 * Ensure that the hardware address is for PPP and not something else
1651 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
1653 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
1657 * This is the PPP device. Validate the version of the driver at this
1658 * point to ensure that this program will work with the driver.
1661 char abBuffer [1024];
1663 ifr.ifr_data = abBuffer;
1664 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
1666 error("Couldn't read driver version: %m");
1668 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
1671 decode_version(abBuffer,
1673 &driver_modification,
1676 * Validate the version of the driver against the version that we used.
1678 decode_version(VERSION,
1683 /* The version numbers must match */
1684 if (driver_version != my_version)
1687 /* The modification levels must be legal */
1688 if (driver_modification < 3) {
1689 if (driver_modification >= 2) {
1690 /* we can cope with 2.2.0 and above */
1699 slprintf(route_buffer, sizeof(route_buffer),
1700 "Sorry - PPP driver version %d.%d.%d is out of date\n",
1701 driver_version, driver_modification, driver_patch);
1703 no_ppp_msg = route_buffer;
1710 /********************************************************************
1712 * Update the wtmp file with the appropriate user name and tty device.
1715 void logwtmp (const char *line, const char *name, const char *host)
1718 struct utmp ut, *utp;
1719 pid_t mypid = getpid();
1721 * Update the signon database for users.
1722 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
1724 utmpname(_PATH_UTMP);
1726 while ((utp = getutent()) && (utp->ut_pid != mypid))
1729 /* Is this call really necessary? There is another one after the 'put' */
1733 memcpy(&ut, utp, sizeof(ut));
1735 /* some gettys/telnetds don't initialize utmp... */
1736 memset(&ut, 0, sizeof(ut));
1738 if (ut.ut_id[0] == 0)
1739 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
1741 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
1742 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
1746 ut.ut_type = USER_PROCESS;
1749 /* Insert the host name if one is supplied */
1751 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
1753 /* Insert the IP address of the remote system if IP is enabled */
1754 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
1755 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
1756 sizeof(ut.ut_addr));
1758 /* CL: Makes sure that the logout works */
1759 if (*host == 0 && *name==0)
1765 * Update the wtmp file.
1767 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
1769 flock(wtmp, LOCK_EX);
1771 /* we really should check for error on the write for a full disk! */
1772 write (wtmp, (char *)&ut, sizeof(ut));
1775 flock(wtmp, LOCK_UN);
1780 /********************************************************************
1781 * Code for locking/unlocking the serial device.
1782 * This code is derived from chat.c.
1786 #define LOCK_PREFIX "/var/lock/LCK.."
1789 static char *lock_file;
1792 * lock - create a lock file for the named device
1795 int lock (char *dev)
1799 lock_file = strdup(dev);
1800 if (lock_file == NULL)
1801 novm("lock file name");
1802 result = mklock (dev, (void *) 0);
1805 notice("Device %s is locked by pid %d", dev, result);
1812 error("Can't create lock file %s", lock_file);
1820 char hdb_lock_buffer[12];
1826 p = strrchr(dev, '/');
1830 l = strlen(LOCK_PREFIX) + strlen(dev) + 1;
1831 lock_file = malloc(l);
1832 if (lock_file == NULL)
1833 novm("lock file name");
1835 slprintf(lock_file, l, "%s%s", LOCK_PREFIX, dev);
1837 * Attempt to create the lock file at this point.
1840 fd = open(lock_file, O_EXCL | O_CREAT | O_RDWR, 0644);
1844 slprintf(hdb_lock_buffer, sizeof(hdb_lock_buffer), "%010d\n", pid);
1845 write (fd, hdb_lock_buffer, 11);
1847 write(fd, &pid, sizeof (pid));
1853 * If the file exists then check to see if the pid is stale
1855 if (errno == EEXIST) {
1856 fd = open(lock_file, O_RDONLY, 0);
1858 if (errno == ENOENT) /* This is just a timing problem. */
1863 /* Read the lock file to find out who has the device locked */
1864 n = read (fd, hdb_lock_buffer, 11);
1867 error("Can't read pid from lock file %s", lock_file);
1871 /* See the process still exists. */
1874 hdb_lock_buffer[n] = '\0';
1875 sscanf (hdb_lock_buffer, " %d", &pid);
1877 pid = ((int *) hdb_lock_buffer)[0];
1879 if (pid == 0 || pid == getpid()
1880 || (kill(pid, 0) == -1 && errno == ESRCH))
1884 /* If the process does not exist then try to remove the lock */
1885 if (n == 0 && unlink (lock_file) == 0) {
1886 notice("Removed stale lock on %s (pid %d)",
1891 notice("Device %s is locked by pid %d", dev, pid);
1895 error("Can't create lock file %s: %m(%d)", lock_file, errno);
1906 /********************************************************************
1908 * unlock - remove our lockfile
1915 (void) rmlock (lock_file, (void *) 0);
1925 /********************************************************************
1927 * sifvjcomp - config tcp header compression
1930 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
1932 u_int x = get_flags();
1935 if (ioctl (ppp_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
1936 if (! ok_error (errno))
1937 error("ioctl(PPPIOCSMAXCID): %m(%d)", errno);
1942 x = vjcomp ? x | SC_COMP_TCP : x &~ SC_COMP_TCP;
1943 x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
1949 /********************************************************************
1951 * sifup - Config the interface up and enable IP packets to pass.
1958 memset (&ifr, '\0', sizeof (ifr));
1959 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1960 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
1961 if (! ok_error (errno))
1962 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
1966 ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
1967 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
1968 if (! ok_error (errno))
1969 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
1976 /********************************************************************
1978 * sifdown - Config the interface down and disable IP.
1987 memset (&ifr, '\0', sizeof (ifr));
1988 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1989 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
1990 if (! ok_error (errno))
1991 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
1995 ifr.ifr_flags &= ~IFF_UP;
1996 ifr.ifr_flags |= IFF_POINTOPOINT;
1997 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
1998 if (! ok_error (errno))
1999 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2005 /********************************************************************
2007 * sifaddr - Config the interface IP addresses and netmask.
2010 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2016 memset (&ifr, '\0', sizeof (ifr));
2017 memset (&rt, '\0', sizeof (rt));
2019 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
2020 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2021 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2023 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2025 * Set our IP address
2027 ((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr.s_addr = our_adr;
2028 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2029 if (errno != EEXIST) {
2030 if (! ok_error (errno))
2031 error("ioctl(SIOCSIFADDR): %m(%d)", errno);
2034 warn("ioctl(SIOCSIFADDR): Address already exists");
2039 * Set the gateway address
2041 ((struct sockaddr_in *) &ifr.ifr_dstaddr)->sin_addr.s_addr = his_adr;
2042 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2043 if (! ok_error (errno))
2044 error("ioctl(SIOCSIFDSTADDR): %m(%d)", errno);
2049 * For recent kernels, force the netmask to 255.255.255.255.
2051 if (kernel_version >= KVERSION(2,1,16))
2053 if (net_mask != 0) {
2054 ((struct sockaddr_in *) &ifr.ifr_netmask)->sin_addr.s_addr = net_mask;
2055 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2056 if (! ok_error (errno))
2057 error("ioctl(SIOCSIFNETMASK): %m(%d)", errno);
2062 * Add the device route
2064 if (kernel_version < KVERSION(2,1,16)) {
2065 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2066 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2069 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = 0L;
2070 ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr = his_adr;
2071 rt.rt_flags = RTF_UP | RTF_HOST;
2073 if (kernel_version > KVERSION(2,1,0)) {
2074 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2075 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = -1L;
2078 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2079 if (! ok_error (errno))
2080 error("ioctl(SIOCADDRT) device route: %m(%d)", errno);
2087 /********************************************************************
2089 * cifaddr - Clear the interface IP addresses, and delete routes
2090 * through the interface if possible.
2093 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2097 if (kernel_version < KVERSION(2,1,16)) {
2099 * Delete the route through the device
2101 memset (&rt, '\0', sizeof (rt));
2103 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2104 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2107 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = 0;
2108 ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr = his_adr;
2109 rt.rt_flags = RTF_UP | RTF_HOST;
2111 if (kernel_version > KVERSION(2,1,0)) {
2112 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2113 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = -1L;
2116 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2117 if (still_ppp() && ! ok_error (errno))
2118 error("ioctl(SIOCDELRT) device route: %m(%d)", errno);
2126 * get_pty - get a pty master/slave pair and chown the slave side
2127 * to the uid given. Assumes slave_name points to >= 12 bytes of space.
2130 get_pty(master_fdp, slave_fdp, slave_name, uid)
2138 struct termios tios;
2141 for (i = 0; i < 64; ++i) {
2142 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2143 'p' + i / 16, i % 16);
2144 mfd = open(pty_name, O_RDWR, 0);
2147 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2156 strlcpy(slave_name, pty_name, 12);
2159 fchown(sfd, uid, -1);
2160 fchmod(sfd, S_IRUSR | S_IWUSR);
2161 if (tcgetattr(sfd, &tios) == 0) {
2162 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2163 tios.c_cflag |= CS8 | CREAD;
2164 tios.c_iflag = IGNPAR | CLOCAL;
2167 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2168 warn("couldn't set attributes on pty: %m");
2170 warn("couldn't get attributes on pty: %m");
2175 /********************************************************************
2177 * open_loopback - open the device we use for getting packets
2178 * in demand mode. Under Linux, we use a pty master/slave pair.
2181 open_ppp_loopback(void)
2185 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2186 fatal("No free pty for loopback");
2187 SYSDEBUG(("using %s for loopback", loop_name));
2189 set_ppp_fd(slave_fd);
2191 flags = fcntl(master_fd, F_GETFL);
2193 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2194 warn("couldn't set master loopback to nonblock: %m(%d)", errno);
2196 flags = fcntl(ppp_fd, F_GETFL);
2198 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2199 warn("couldn't set slave loopback to nonblock: %m(%d)", errno);
2201 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2202 fatal("ioctl(TIOCSETD): %m(%d)", errno);
2204 * Find out which interface we were given.
2206 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2207 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
2209 * Enable debug in the driver if requested.
2211 set_kdebugflag (kdebugflag);
2216 /********************************************************************
2218 * restore_loop - reattach the ppp unit to the loopback.
2220 * The kernel ppp driver automatically reattaches the ppp unit to
2221 * the loopback if the serial port is set to a line discipline other
2222 * than ppp, or if it detects a modem hangup. The former will happen
2223 * in disestablish_ppp if the latter hasn't already happened, so we
2224 * shouldn't need to do anything.
2226 * Just to be sure, set the real serial port to the normal discipline.
2232 if (ppp_fd != slave_fd) {
2233 (void) ioctl(ppp_fd, TIOCSETD, &tty_disc);
2234 set_ppp_fd(slave_fd);
2238 /********************************************************************
2240 * sifnpmode - Set the mode for handling packets for a given NP.
2244 sifnpmode(u, proto, mode)
2251 npi.protocol = proto;
2253 if (ioctl(ppp_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2254 if (! ok_error (errno)) {
2255 error("ioctl(PPPIOCSNPMODE, %d, %d): %m (%d)",
2256 proto, mode, errno);
2257 error("ppp_fd=%d slave_fd=%d\n", ppp_fd, slave_fd);
2265 /********************************************************************
2267 * sipxfaddr - Config the interface IPX networknumber
2270 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2277 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2279 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2281 if (! ok_error (errno))
2282 dbglog("socket(AF_IPX): %m (%d)", errno);
2286 memset (&ifr, '\0', sizeof (ifr));
2287 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2289 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2290 sipx->sipx_family = AF_IPX;
2291 sipx->sipx_port = 0;
2292 sipx->sipx_network = htonl (network);
2293 sipx->sipx_type = IPX_FRAME_ETHERII;
2294 sipx->sipx_action = IPX_CRTITF;
2296 * Set the IPX device
2298 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2300 if (errno != EEXIST) {
2301 if (! ok_error (errno))
2302 dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (%d)", errno);
2305 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2314 /********************************************************************
2316 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2317 * are removed and the device is no longer able to pass IPX
2321 int cipxfaddr (int unit)
2328 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2330 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2332 if (! ok_error (errno))
2333 dbglog("socket(AF_IPX): %m (%d)", errno);
2337 memset (&ifr, '\0', sizeof (ifr));
2338 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2340 sipx->sipx_type = IPX_FRAME_ETHERII;
2341 sipx->sipx_action = IPX_DLTITF;
2342 sipx->sipx_family = AF_IPX;
2344 * Set the IPX device
2346 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2347 if (! ok_error (errno))
2348 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (%d)", errno);
2359 * daemon - Detach us from controlling terminal session.
2362 daemon(nochdir, noclose)
2363 int nochdir, noclose;
2367 if ((pid = fork()) < 0)
2370 exit(0); /* parent dies */
2375 fclose(stdin); /* don't need stdin, stdout, stderr */
2384 * Use the hostname as part of the random number seed.
2393 for (p = hostname; *p != 0; ++p)
2398 /********************************************************************
2400 * sys_check_options - check the options that the user specified
2404 sys_check_options(void)
2407 struct stat stat_buf;
2409 * Disable the IPX protocol if the support is not present in the kernel.
2410 * If we disable it then ensure that IP support is enabled.
2412 while (ipxcp_protent.enabled_flag) {
2413 if (path_to_procfs()) {
2414 strlcat (route_buffer, "/net/ipx_interface", sizeof(route_buffer));
2415 if (lstat (route_buffer, &stat_buf) >= 0)
2418 error("IPX support is not present in the kernel\n");
2419 ipxcp_protent.enabled_flag = 0;
2420 ipcp_protent.enabled_flag = 1;
2424 if (demand && driver_is_old) {
2425 option_error("demand dialling is not supported by kernel driver "
2426 "version %d.%d.%d", driver_version, driver_modification,