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
55 #include <net/if_arp.h>
56 #include <net/route.h>
57 #include <netinet/if_ether.h>
60 #include <linux/if_arp.h>
61 #include <linux/route.h>
62 #include <linux/if_ether.h>
64 #include <netinet/in.h>
65 #include <arpa/inet.h>
67 #include <linux/types.h>
68 #include <linux/ppp_defs.h>
69 #include <linux/if_ppp.h>
74 #include "patchlevel.h"
78 #if __GLIBC__ >= 2 && \
79 !(defined(__powerpc__) && __GLIBC__ == 2 && __GLIBC_MINOR__ == 0)
80 #include <netipx/ipx.h>
82 #include <linux/ipx.h>
84 #endif /* IPX_CHANGE */
87 #include <sys/locks.h>
90 #ifndef RTF_DEFAULT /* Normally in <linux/route.h> from <net/route.h> */
94 #define ok_error(num) ((num)==EIO)
96 static int tty_disc = N_TTY; /* The TTY discipline */
97 static int ppp_disc = N_PPP; /* The PPP discpline */
98 static int initfdflags = -1; /* Initial file descriptor flags for fd */
99 static int ppp_fd = -1; /* fd which is set to PPP discipline */
100 static int sock_fd = -1; /* socket for doing interface ioctls */
101 static int slave_fd = -1;
102 static int master_fd = -1;
104 static int has_proxy_arp = 0;
105 static int driver_version = 0;
106 static int driver_modification = 0;
107 static int driver_patch = 0;
108 static int driver_is_old = 0;
109 static int restore_term = 0; /* 1 => we've munged the terminal */
110 static struct termios inittermios; /* Initial TTY termios */
112 static char loop_name[20];
113 static unsigned char inbuf[512]; /* buffer for chars read from loopback */
115 static int if_is_up; /* Interface has been marked up */
116 static u_int32_t default_route_gateway; /* Gateway for default route added */
117 static u_int32_t proxy_arp_addr; /* Addr for proxy arp entry added */
119 static char *lock_file;
121 static struct utsname utsname; /* for the kernel version */
122 static int kernel_version;
123 #define KVERSION(j,n,p) ((j)*1000000 + (n)*1000 + (p))
127 #define FLAGS_GOOD (IFF_UP | IFF_BROADCAST)
128 #define FLAGS_MASK (IFF_UP | IFF_BROADCAST | \
129 IFF_POINTOPOINT | IFF_LOOPBACK | IFF_NOARP)
131 /* Prototypes for procedures local to this file. */
132 static int get_flags (void);
133 static void set_flags (int flags);
134 static int translate_speed (int bps);
135 static int baud_rate_of (int speed);
136 static char *path_to_route (void);
137 static void close_route_table (void);
138 static int open_route_table (void);
139 static int read_route_table (struct rtentry *rt);
140 static int defaultroute_exists (struct rtentry *rt);
141 static int get_ether_addr (u_int32_t ipaddr, struct sockaddr *hwaddr,
143 static void decode_version (char *buf, int *version, int *mod, int *patch);
145 extern u_char inpacket_buf[]; /* borrowed from main.c */
148 * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
152 #define SET_SA_FAMILY(addr, family) \
153 memset ((char *) &(addr), '\0', sizeof(addr)); \
154 addr.sa_family = (family);
157 * Determine if the PPP connection should still be present.
163 #define LOCK_PREFIX "/var/lock/LCK.."
166 static void set_ppp_fd (int new_fd)
168 SYSDEBUG ((LOG_DEBUG, "setting ppp_fd to %d\n", ppp_fd));
172 static int still_ppp(void)
174 if (!hungup || ppp_fd == slave_fd)
177 set_ppp_fd(slave_fd);
183 /********************************************************************
185 * Functions to read and set the flags value in the device driver
188 static int get_flags (void)
192 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &flags) < 0)
194 if ( ok_error (errno) )
200 syslog(LOG_ERR, "ioctl(PPPIOCGFLAGS): %m");
205 SYSDEBUG ((LOG_DEBUG, "get flags = %x\n", flags));
209 /********************************************************************/
211 static void set_flags (int flags)
213 SYSDEBUG ((LOG_DEBUG, "set flags = %x\n", flags));
215 if (ioctl(ppp_fd, PPPIOCSFLAGS, (caddr_t) &flags) < 0)
217 if (! ok_error (errno) )
219 syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS, %x): %m(%d)", flags, errno);
225 /********************************************************************
227 * sys_init - System-dependent initialization.
232 int osmaj, osmin, ospatch;
234 openlog("pppd", LOG_PID | LOG_NDELAY, LOG_PPP);
235 setlogmask(LOG_UPTO(LOG_INFO));
238 setlogmask(LOG_UPTO(LOG_DEBUG));
241 /* Get an internet socket for doing socket ioctls. */
242 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
245 if ( ! ok_error ( errno ))
247 syslog(LOG_ERR, "Couldn't create IP socket: %m(%d)", errno);
253 osmaj = osmin = ospatch = 0;
254 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
255 kernel_version = KVERSION(osmaj, osmin, ospatch);
258 /********************************************************************
260 * sys_cleanup - restore any system state we modified before exiting:
261 * mark the interface down, delete default route and/or proxy arp entry.
262 * This should call die() because it's called from die().
265 void sys_cleanup(void)
268 * Take down the device
275 * Delete any routes through the device.
277 if (default_route_gateway != 0)
279 cifdefaultroute(0, 0, default_route_gateway);
284 cifproxyarp(0, proxy_arp_addr);
288 /********************************************************************
290 * sys_close - Clean up in a child process before execing.
300 /********************************************************************
302 * note_debug_level - note a change in the debug level.
305 void note_debug_level (void)
309 SYSDEBUG ((LOG_INFO, "Debug turned ON, Level %d", debug));
310 setlogmask(LOG_UPTO(LOG_DEBUG));
314 setlogmask(LOG_UPTO(LOG_WARNING));
318 /********************************************************************
320 * set_kdebugflag - Define the debugging level for the kernel
323 int set_kdebugflag (int requested_level)
325 if (ioctl(ppp_fd, PPPIOCSDEBUG, &requested_level) < 0)
327 if ( ! ok_error (errno) )
329 syslog (LOG_ERR, "ioctl(PPPIOCSDEBUG): %m");
333 SYSDEBUG ((LOG_INFO, "set kernel debugging level to %d",
338 /********************************************************************
340 * establish_ppp - Turn the serial port into a ppp interface.
343 void establish_ppp (int tty_fd)
347 * The current PPP device will be the tty file.
351 * Ensure that the tty device is in exclusive mode.
353 if (ioctl(tty_fd, TIOCEXCL, 0) < 0)
355 if ( ! ok_error ( errno ))
357 syslog (LOG_WARNING, "ioctl(TIOCEXCL): %m");
361 * Demand mode - prime the old ppp device to relinquish the unit.
363 if (demand && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0)
365 syslog(LOG_ERR, "ioctl(transfer ppp unit): %m(%d)", errno);
369 * Set the current tty to the PPP discpline
371 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
373 if ( ! ok_error (errno) )
375 syslog(LOG_ERR, "ioctl(TIOCSETD): %m(%d)", errno);
380 * Find out which interface we were given.
382 if (ioctl(ppp_fd, PPPIOCGUNIT, &x) < 0)
384 if ( ! ok_error (errno))
386 syslog(LOG_ERR, "ioctl(PPPIOCGUNIT): %m(%d)", errno);
391 * Check that we got the same unit again.
397 syslog(LOG_ERR, "transfer_ppp failed: wanted unit %d, got %d",
405 * Enable debug in the driver if requested.
408 set_kdebugflag (kdebugflag);
410 set_flags (get_flags() & ~(SC_RCV_B7_0 | SC_RCV_B7_1 |
411 SC_RCV_EVNP | SC_RCV_ODDP));
413 SYSDEBUG ((LOG_NOTICE, "Using version %d.%d.%d of PPP driver",
414 driver_version, driver_modification, driver_patch));
416 * Fetch the initial file flags and reset blocking mode on the file.
418 initfdflags = fcntl(ppp_fd, F_GETFL);
420 if (initfdflags == -1 ||
421 fcntl(ppp_fd, F_SETFL, initfdflags | O_NONBLOCK) == -1)
423 if ( ! ok_error (errno))
426 "Couldn't set device to non-blocking mode: %m");
431 /********************************************************************
433 * disestablish_ppp - Restore the serial port to normal operation.
434 * This shouldn't call die() because it's called from die().
437 void disestablish_ppp(int tty_fd)
440 * Attempt to restore the previous tty settings
445 * Restore the previous line discipline
447 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0)
449 if ( ! ok_error (errno))
451 syslog(LOG_ERR, "ioctl(TIOCSETD, N_TTY): %m");
455 if (ioctl(tty_fd, TIOCNXCL, 0) < 0)
457 if ( ! ok_error (errno))
459 syslog (LOG_WARNING, "ioctl(TIOCNXCL): %m(%d)", errno);
463 /* Reset non-blocking mode on fd. */
464 if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0)
466 if ( ! ok_error (errno))
469 "Couldn't restore device fd flags: %m");
476 /********************************************************************
478 * clean_check - Fetch the flags for the device and generate
479 * appropriate error messages.
481 void clean_check(void)
488 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0)
491 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP))
494 case SC_RCV_B7_0 | SC_RCV_EVNP:
495 case SC_RCV_B7_0 | SC_RCV_ODDP:
496 case SC_RCV_B7_0 | SC_RCV_ODDP | SC_RCV_EVNP:
497 s = "all had bit 7 set to 1";
501 case SC_RCV_B7_1 | SC_RCV_EVNP:
502 case SC_RCV_B7_1 | SC_RCV_ODDP:
503 case SC_RCV_B7_1 | SC_RCV_ODDP | SC_RCV_EVNP:
504 s = "all had bit 7 set to 0";
508 s = "all had odd parity";
512 s = "all had even parity";
518 syslog(LOG_WARNING, "Receive serial link is not"
520 syslog(LOG_WARNING, "Problem: %s", s);
528 * List of valid speeds.
532 int speed_int, speed_val;
609 /********************************************************************
611 * Translate from bits/second to a speed_t.
614 static int translate_speed (int bps)
616 struct speed *speedp;
620 for (speedp = speeds; speedp->speed_int; speedp++)
622 if (bps == speedp->speed_int)
624 return speedp->speed_val;
627 syslog(LOG_WARNING, "speed %d not supported", bps);
632 /********************************************************************
634 * Translate from a speed_t to bits/second.
637 static int baud_rate_of (int speed)
639 struct speed *speedp;
643 for (speedp = speeds; speedp->speed_int; speedp++)
645 if (speed == speedp->speed_val)
647 return speedp->speed_int;
654 /********************************************************************
656 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
657 * at the requested speed, etc. If `local' is true, set CLOCAL
658 * regardless of whether the modem option was specified.
661 void set_up_tty (int tty_fd, int local)
666 if (tcgetattr(tty_fd, &tios) < 0)
668 syslog(LOG_ERR, "tcgetattr: %m(%d)", errno);
677 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
678 tios.c_cflag |= CS8 | CREAD | HUPCL;
680 tios.c_iflag = IGNBRK | IGNPAR;
684 tios.c_cc[VTIME] = 0;
688 tios.c_cflag ^= (CLOCAL | HUPCL);
694 tios.c_cflag |= CRTSCTS;
698 tios.c_iflag |= IXON | IXOFF;
699 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
700 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
704 tios.c_cflag &= ~CRTSCTS;
711 speed = translate_speed(inspeed);
714 cfsetospeed (&tios, speed);
715 cfsetispeed (&tios, speed);
718 * We can't proceed if the serial port speed is B0,
719 * since that implies that the serial port is disabled.
723 speed = cfgetospeed(&tios);
726 syslog(LOG_ERR, "Baud rate for %s is 0; need explicit baud rate",
732 if (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0)
734 syslog(LOG_ERR, "tcsetattr: %m");
738 baud_rate = baud_rate_of(speed);
742 /********************************************************************
744 * setdtr - control the DTR line on the serial port.
745 * This is called from die(), so it shouldn't call die().
748 void setdtr (int tty_fd, int on)
750 int modembits = TIOCM_DTR;
752 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
755 /********************************************************************
757 * restore_tty - restore the terminal to the saved settings.
760 void restore_tty (int tty_fd)
766 * Turn off echoing, because otherwise we can get into
767 * a loop with the tty and the modem echoing to each other.
768 * We presume we are the sole user of this tty device, so
769 * when we close it, it will revert to its defaults anyway.
773 inittermios.c_lflag &= ~(ECHO | ECHONL);
776 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0)
778 if (! ok_error (errno))
780 syslog(LOG_WARNING, "tcsetattr: %m");
786 /********************************************************************
788 * output - Output PPP packet.
791 void output (int unit, unsigned char *p, int len)
795 log_packet(p, len, "sent ", LOG_DEBUG);
798 if (write(ppp_fd, p, len) < 0)
800 if (errno == EWOULDBLOCK || errno == ENOBUFS
801 || errno == ENXIO || errno == EIO)
803 syslog(LOG_WARNING, "write: warning: %m(%d)", errno);
807 syslog(LOG_ERR, "write: %m(%d)", errno);
813 /********************************************************************
815 * wait_input - wait until there is data available on ppp_fd,
816 * for the length of time specified by *timo (indefinite
820 void wait_input (struct timeval *timo)
826 FD_SET(ppp_fd, &ready);
828 n = select(ppp_fd + 1, &ready, NULL, &ready, timo);
829 if (n < 0 && errno != EINTR)
831 syslog(LOG_ERR, "select: %m(%d)", errno);
836 /********************************************************************
838 * wait_loop_output - wait until there is data available on the
839 * loopback, for the length of time specified by *timo (indefinite
842 void wait_loop_output(timo)
843 struct timeval *timo;
849 FD_SET(master_fd, &ready);
850 n = select(master_fd + 1, &ready, NULL, &ready, timo);
851 if (n < 0 && errno != EINTR)
853 syslog(LOG_ERR, "select: %m(%d)", errno);
858 /********************************************************************
860 * wait_time - wait for a given length of time or until a
861 * signal is received.
865 struct timeval *timo;
869 n = select(0, NULL, NULL, NULL, timo);
870 if (n < 0 && errno != EINTR) {
871 syslog(LOG_ERR, "select: %m(%d)", errno);
876 /********************************************************************
878 * read_packet - get a PPP packet from the serial device.
881 int read_packet (unsigned char *buf)
885 len = read(ppp_fd, buf, PPP_MTU + PPP_HDRLEN);
888 if (errno == EWOULDBLOCK)
892 syslog(LOG_ERR, "read: %m(%d)", errno);
898 /********************************************************************
900 * get_loop_output - get outgoing packets from the ppp device,
901 * and detect when we want to bring the real link up.
902 * Return value is 1 if we need to bring up the link, 0 otherwise.
905 get_loop_output(void)
908 int n = read(master_fd, inbuf, sizeof(inbuf));
912 if (loop_chars(inbuf, n))
916 n = read(master_fd, inbuf, sizeof(inbuf));
921 syslog(LOG_ERR, "eof on loopback");
925 if (errno != EWOULDBLOCK)
927 syslog(LOG_ERR, "read from loopback: %m(%d)", errno);
934 /********************************************************************
936 * ppp_send_config - configure the transmit characteristics of
940 void ppp_send_config (int unit,int mtu,u_int32_t asyncmap,int pcomp,int accomp)
945 SYSDEBUG ((LOG_DEBUG, "send_config: mtu = %d\n", mtu));
947 * Ensure that the link is still up.
952 * Set the MTU and other parameters for the ppp device
954 memset (&ifr, '\0', sizeof (ifr));
955 strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
958 if (ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
960 syslog(LOG_ERR, "ioctl(SIOCSIFMTU): %m(%d)", errno);
964 SYSDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
965 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0)
967 syslog(LOG_ERR, "ioctl(PPPIOCSASYNCMAP): %m(%d)", errno);
972 x = pcomp ? x | SC_COMP_PROT : x & ~SC_COMP_PROT;
973 x = accomp ? x | SC_COMP_AC : x & ~SC_COMP_AC;
978 /********************************************************************
980 * ppp_set_xaccm - set the extended transmit ACCM for the interface.
983 void ppp_set_xaccm (int unit, ext_accm accm)
985 SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
986 accm[0], accm[1], accm[2], accm[3]));
988 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY)
990 if ( ! ok_error (errno))
992 syslog(LOG_WARNING, "ioctl(set extended ACCM): %m(%d)", errno);
997 /********************************************************************
999 * ppp_recv_config - configure the receive-side characteristics of
1000 * the ppp interface.
1003 void ppp_recv_config (int unit,int mru,u_int32_t asyncmap,int pcomp,int accomp)
1007 SYSDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
1009 * If we were called because the link has gone down then there is nothing
1010 * which may be done. Just return without incident.
1017 * Set the receiver parameters
1019 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
1021 if ( ! ok_error (errno))
1023 syslog(LOG_ERR, "ioctl(PPPIOCSMRU): %m(%d)", errno);
1027 SYSDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
1028 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0)
1030 syslog(LOG_ERR, "ioctl(PPPIOCSRASYNCMAP): %m(%d)", errno);
1035 x = !accomp? x | SC_REJ_COMP_AC: x &~ SC_REJ_COMP_AC;
1039 /********************************************************************
1041 * ccp_test - ask kernel whether a given compression method
1042 * is acceptable for use.
1045 int ccp_test (int unit, u_char *opt_ptr, int opt_len, int for_transmit)
1047 struct ppp_option_data data;
1049 memset (&data, '\0', sizeof (data));
1051 data.length = opt_len;
1052 data.transmit = for_transmit;
1054 if (ioctl(ppp_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1059 return (errno == ENOBUFS)? 0: -1;
1062 /********************************************************************
1064 * ccp_flags_set - inform kernel about the current state of CCP.
1067 void ccp_flags_set (int unit, int isopen, int isup)
1071 int x = get_flags();
1072 x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
1073 x = isup? x | SC_CCP_UP : x &~ SC_CCP_UP;
1078 /********************************************************************
1080 * get_idle_time - return how long the link has been idle.
1083 get_idle_time(u, ip)
1085 struct ppp_idle *ip;
1087 return ioctl(ppp_fd, PPPIOCGIDLE, ip) >= 0;
1090 /********************************************************************
1092 * ccp_fatal_error - returns 1 if decompression was disabled as a
1093 * result of an error detected after decompression of a packet,
1094 * 0 otherwise. This is necessary because of patent nonsense.
1097 int ccp_fatal_error (int unit)
1099 int x = get_flags();
1101 return x & SC_DC_FERROR;
1105 * path_to_route - determine the path to the proc file system data
1108 FILE *route_fd = (FILE *) 0;
1109 static char route_buffer [512];
1111 static char *path_to_route (void);
1112 static int open_route_table (void);
1113 static void close_route_table (void);
1114 static int read_route_table (struct rtentry *rt);
1116 /********************************************************************
1118 * path_to_procfs - find the path to the proc file system mount point
1121 static int path_to_procfs (void)
1123 struct mntent *mntent;
1126 fp = fopen (MOUNTED, "r");
1129 mntent = getmntent (fp);
1130 while (mntent != (struct mntent *) 0)
1132 if (strcmp (mntent->mnt_type, MNTTYPE_IGNORE) != 0)
1134 if (strcmp (mntent->mnt_type, "proc") == 0)
1136 strncpy (route_buffer, mntent->mnt_dir,
1137 sizeof (route_buffer)-10);
1138 route_buffer [sizeof (route_buffer)-10] = '\0';
1143 mntent = getmntent (fp);
1148 /* Default the mount location of /proc */
1149 strncpy (route_buffer, "/proc", sizeof (route_buffer)-10);
1153 /********************************************************************
1155 * path_to_route - find the path to the route tables in the proc file system
1158 static char *path_to_route (void)
1160 if (! path_to_procfs())
1162 syslog (LOG_ERR, "proc file system not mounted");
1165 strcat (route_buffer, "/net/route");
1166 return (route_buffer);
1169 /********************************************************************
1171 * close_route_table - close the interface to the route table
1174 static void close_route_table (void)
1176 if (route_fd != (FILE *) 0)
1179 route_fd = (FILE *) 0;
1183 /********************************************************************
1185 * open_route_table - open the interface to the route table
1188 static int open_route_table (void)
1192 close_route_table();
1194 path = path_to_route();
1200 route_fd = fopen (path, "r");
1201 if (route_fd == (FILE *) 0)
1203 syslog (LOG_ERR, "can not open %s: %m(%d)", path, errno);
1209 /********************************************************************
1211 * read_route_table - read the next entry from the route table
1214 static int read_route_table (struct rtentry *rt)
1216 static char delims[] = " \t\n";
1217 char *dev_ptr, *dst_ptr, *gw_ptr, *flag_ptr;
1219 memset (rt, '\0', sizeof (struct rtentry));
1223 if (fgets (route_buffer, sizeof (route_buffer), route_fd) ==
1229 dev_ptr = strtok (route_buffer, delims); /* interface name */
1230 dst_ptr = strtok (NULL, delims); /* destination address */
1231 gw_ptr = strtok (NULL, delims); /* gateway */
1232 flag_ptr = strtok (NULL, delims); /* flags */
1234 if (flag_ptr == (char *) 0) /* assume that we failed, somewhere. */
1239 /* Discard that stupid header line which should never
1240 * have been there in the first place !! */
1241 if (isxdigit (*dst_ptr) && isxdigit (*gw_ptr) && isxdigit (*flag_ptr))
1247 ((struct sockaddr_in *) &rt->rt_dst)->sin_addr.s_addr =
1248 strtoul (dst_ptr, NULL, 16);
1250 ((struct sockaddr_in *) &rt->rt_gateway)->sin_addr.s_addr =
1251 strtoul (gw_ptr, NULL, 16);
1253 rt->rt_flags = (short) strtoul (flag_ptr, NULL, 16);
1254 rt->rt_dev = dev_ptr;
1259 /********************************************************************
1261 * defaultroute_exists - determine if there is a default route
1264 static int defaultroute_exists (struct rtentry *rt)
1268 if (!open_route_table())
1273 while (read_route_table(rt) != 0)
1275 if ((rt->rt_flags & RTF_UP) == 0)
1280 if (((struct sockaddr_in *) (&rt->rt_dst))->sin_addr.s_addr == 0L)
1287 close_route_table();
1291 /********************************************************************
1293 * sifdefaultroute - assign a default route through the address given.
1296 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1300 if (defaultroute_exists(&rt))
1302 struct in_addr old_gateway =
1303 ((struct sockaddr_in *) (&rt.rt_gateway))-> sin_addr;
1305 if (old_gateway.s_addr != gateway)
1308 "not replacing existing default route to %s [%s]",
1310 inet_ntoa (old_gateway));
1315 memset (&rt, '\0', sizeof (rt));
1316 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1317 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1319 if (kernel_version > KVERSION(2,1,0)) {
1320 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1321 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = 0L;
1324 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = gateway;
1326 rt.rt_flags = RTF_UP | RTF_GATEWAY | RTF_DEFAULT;
1327 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0)
1329 if ( ! ok_error ( errno ))
1331 syslog (LOG_ERR, "default route ioctl(SIOCADDRT): %m(%d)", errno);
1336 default_route_gateway = gateway;
1340 /********************************************************************
1342 * cifdefaultroute - delete a default route through the address given.
1345 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1349 default_route_gateway = 0;
1351 memset (&rt, '\0', sizeof (rt));
1352 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1353 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1355 if (kernel_version > KVERSION(2,1,0)) {
1356 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1357 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = 0L;
1360 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = gateway;
1362 rt.rt_flags = RTF_UP | RTF_GATEWAY | RTF_DEFAULT;
1363 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH)
1367 if ( ! ok_error ( errno ))
1370 "default route ioctl(SIOCDELRT): %m(%d)", errno);
1379 /********************************************************************
1381 * sifproxyarp - Make a proxy ARP entry for the peer.
1384 int sifproxyarp (int unit, u_int32_t his_adr)
1386 struct arpreq arpreq;
1388 if (has_proxy_arp == 0)
1390 memset (&arpreq, '\0', sizeof(arpreq));
1392 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1393 ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = his_adr;
1394 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1396 * Get the hardware address of an interface on the same subnet
1397 * as our local address.
1399 if (!get_ether_addr(his_adr, &arpreq.arp_ha, arpreq.arp_dev))
1401 syslog(LOG_ERR, "Cannot determine ethernet address for proxy ARP");
1405 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0)
1407 if ( ! ok_error ( errno ))
1409 syslog(LOG_ERR, "ioctl(SIOCSARP): %m(%d)", errno);
1415 proxy_arp_addr = his_adr;
1420 /********************************************************************
1422 * cifproxyarp - Delete the proxy ARP entry for the peer.
1425 int cifproxyarp (int unit, u_int32_t his_adr)
1427 struct arpreq arpreq;
1429 if (has_proxy_arp == 1)
1431 memset (&arpreq, '\0', sizeof(arpreq));
1432 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1433 ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = his_adr;
1434 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1436 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0)
1438 if ( ! ok_error ( errno ))
1440 syslog(LOG_WARNING, "ioctl(SIOCDARP): %m(%d)", errno);
1449 /********************************************************************
1451 * get_ether_addr - get the hardware address of an interface on the
1452 * the same subnet as ipaddr.
1455 static int get_ether_addr (u_int32_t ipaddr,
1456 struct sockaddr *hwaddr,
1459 struct ifreq *ifr, *ifend;
1460 u_int32_t ina, mask;
1463 struct ifreq ifs[MAX_IFS];
1465 ifc.ifc_len = sizeof(ifs);
1467 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0)
1469 if ( ! ok_error ( errno ))
1471 syslog(LOG_ERR, "ioctl(SIOCGIFCONF): %m(%d)", errno);
1476 SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1477 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1479 * Scan through looking for an interface with an Internet
1480 * address on the same subnet as `ipaddr'.
1482 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1483 for (ifr = ifc.ifc_req; ifr < ifend; ifr++)
1485 if (ifr->ifr_addr.sa_family == AF_INET)
1487 ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
1488 strncpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1489 SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1492 * Check that the interface is up, and not point-to-point
1495 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1500 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1505 * Get its netmask and check that it's on the right subnet.
1507 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1512 mask = ((struct sockaddr_in *) &ifreq.ifr_addr)->sin_addr.s_addr;
1513 SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1514 ip_ntoa(ina), ntohl(mask)));
1516 if (((ipaddr ^ ina) & mask) != 0)
1529 memcpy (name, ifreq.ifr_name, sizeof(ifreq.ifr_name));
1530 syslog(LOG_INFO, "found interface %s for proxy arp", name);
1532 * Now get the hardware address.
1534 memset (&ifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1535 if (ioctl (sock_fd, SIOCGIFHWADDR, &ifreq) < 0)
1537 syslog(LOG_ERR, "SIOCGIFHWADDR(%s): %m(%d)", ifreq.ifr_name, errno);
1543 sizeof (struct sockaddr));
1545 SYSDEBUG ((LOG_DEBUG,
1546 "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1547 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1548 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1549 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1550 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1551 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1552 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1553 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1554 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1558 /********************************************************************
1560 * Return user specified netmask, modified by any mask we might determine
1561 * for address `addr' (in network byte order).
1562 * Here we scan through the system's list of interfaces, looking for
1563 * any non-point-to-point interfaces which might appear to be on the same
1564 * network as `addr'. If we find any, we OR in their netmask to the
1565 * user-specified netmask.
1568 u_int32_t GetMask (u_int32_t addr)
1570 u_int32_t mask, nmask, ina;
1571 struct ifreq *ifr, *ifend, ifreq;
1573 struct ifreq ifs[MAX_IFS];
1577 if (IN_CLASSA(addr)) /* determine network mask for address class */
1579 nmask = IN_CLASSA_NET;
1583 if (IN_CLASSB(addr))
1585 nmask = IN_CLASSB_NET;
1589 nmask = IN_CLASSC_NET;
1593 /* class D nets are disallowed by bad_ip_adrs */
1594 mask = netmask | htonl(nmask);
1596 * Scan through the system's network interfaces.
1598 ifc.ifc_len = sizeof(ifs);
1600 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0)
1602 if ( ! ok_error ( errno ))
1604 syslog(LOG_WARNING, "ioctl(SIOCGIFCONF): %m(%d)", errno);
1609 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1610 for (ifr = ifc.ifc_req; ifr < ifend; ifr++)
1613 * Check the interface's internet address.
1615 if (ifr->ifr_addr.sa_family != AF_INET)
1619 ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
1620 if (((ntohl(ina) ^ addr) & nmask) != 0)
1625 * Check that the interface is up, and not point-to-point nor loopback.
1627 strncpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1628 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1633 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1638 * Get its netmask and OR it into our mask.
1640 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1644 mask |= ((struct sockaddr_in *)&ifreq.ifr_addr)->sin_addr.s_addr;
1650 /********************************************************************
1652 * Internal routine to decode the version.modification.patch level
1655 static void decode_version (char *buf, int *version,
1656 int *modification, int *patch)
1658 *version = (int) strtoul (buf, &buf, 10);
1665 *modification = (int) strtoul (buf, &buf, 10);
1669 *patch = (int) strtoul (buf, &buf, 10);
1681 /********************************************************************
1683 * Procedure to determine if the PPP line discipline is registered.
1687 ppp_registered(void)
1693 local_fd = open(devnam, O_NONBLOCK | O_RDWR, 0);
1696 syslog(LOG_ERR, "Failed to open %s: %m(%d)", devnam, errno);
1700 initfdflags = fcntl(local_fd, F_GETFL);
1701 if (initfdflags == -1)
1703 syslog(LOG_ERR, "Couldn't get device fd flags: %m(%d)", errno);
1708 initfdflags &= ~O_NONBLOCK;
1709 fcntl(local_fd, F_SETFL, initfdflags);
1711 * Read the initial line dicipline and try to put the device into the
1714 if (ioctl(local_fd, TIOCGETD, &init_disc) < 0)
1716 syslog(LOG_ERR, "ioctl(TIOCGETD): %m(%d)", errno);
1721 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0)
1723 syslog(LOG_ERR, "ioctl(TIOCSETD): %m(%d)", errno);
1728 if (ioctl(local_fd, TIOCSETD, &init_disc) < 0)
1730 syslog(LOG_ERR, "ioctl(TIOCSETD): %m(%d)", errno);
1739 /********************************************************************
1741 * ppp_available - check whether the system has any ppp interfaces
1742 * (in fact we check whether we can do an ioctl on ppp0).
1745 int ppp_available(void)
1750 int my_version, my_modification, my_patch;
1751 extern char *no_ppp_msg;
1753 * Open a socket for doing the ioctl operations.
1755 s = socket(AF_INET, SOCK_DGRAM, 0);
1761 strncpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1762 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1764 * If the device did not exist then attempt to create one by putting the
1765 * current tty into the PPP discipline. If this works then obtain the
1766 * flags for the device again.
1770 if (ppp_registered())
1772 strncpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1773 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1777 * Ensure that the hardware address is for PPP and not something else
1781 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
1784 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
1792 "This system lacks kernel support for PPP. This could be because\n"
1793 "the PPP kernel module is not loaded, or because the kernel is\n"
1794 "not configured for PPP. See the README.linux file in the\n"
1795 "ppp-2.3.5 distribution.\n";
1798 * This is the PPP device. Validate the version of the driver at this
1799 * point to ensure that this program will work with the driver.
1803 char abBuffer [1024];
1805 ifr.ifr_data = abBuffer;
1806 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
1808 syslog(LOG_ERR, "Couldn't read driver version: %m");
1810 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
1813 decode_version(abBuffer,
1815 &driver_modification,
1818 * Validate the version of the driver against the version that we used.
1820 decode_version(VERSION,
1825 /* The version numbers must match */
1826 if (driver_version != my_version)
1831 /* The modification levels must be legal */
1832 if (driver_modification < my_modification)
1834 if (driver_modification >= 2) {
1835 /* we can cope with 2.2.0 and above */
1845 sprintf (route_buffer,
1846 "Sorry - PPP driver version %d.%d.%d is out of date\n",
1847 driver_version, driver_modification, driver_patch);
1849 no_ppp_msg = route_buffer;
1856 /********************************************************************
1858 * Update the wtmp file with the appropriate user name and tty device.
1861 void logwtmp (const char *line, const char *name, const char *host)
1864 struct utmp ut, *utp;
1865 pid_t mypid = getpid();
1867 * Update the signon database for users.
1868 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
1870 utmpname(_PATH_UTMP);
1872 while ((utp = getutent()) && (utp->ut_pid != mypid))
1875 /* Is this call really necessary? There is another one after the 'put' */
1880 memcpy(&ut, utp, sizeof(ut));
1884 /* some gettys/telnetds don't initialize utmp... */
1885 memset(&ut, 0, sizeof(ut));
1888 if (ut.ut_id[0] == 0)
1890 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
1893 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
1894 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
1898 ut.ut_type = USER_PROCESS;
1901 /* Insert the host name if one is supplied */
1904 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
1907 /* Insert the IP address of the remote system if IP is enabled */
1908 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
1910 memcpy (&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
1911 sizeof(ut.ut_addr));
1914 /* CL: Makes sure that the logout works */
1915 if (*host == 0 && *name==0)
1923 * Update the wtmp file.
1925 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
1928 flock(wtmp, LOCK_EX);
1930 /* we really should check for error on the write for a full disk! */
1931 write (wtmp, (char *)&ut, sizeof(ut));
1934 flock(wtmp, LOCK_UN);
1938 /********************************************************************
1939 * Code for locking/unlocking the serial device.
1940 * This code is derived from chat.c.
1944 * lock - create a lock file for the named device
1947 int lock (char *dev)
1951 lock_file = malloc(strlen(dev) + 1);
1952 if (lock_file == NULL)
1954 novm("lock file name");
1956 strcpy (lock_file, dev);
1957 result = mklock (dev, (void *) 0);
1961 syslog (LOG_NOTICE, "Device %s is locked by pid %d", dev, result);
1970 syslog (LOG_ERR, "Can't create lock file %s", lock_file);
1978 char hdb_lock_buffer[12];
1983 p = strrchr(dev, '/');
1989 lock_file = malloc(strlen(LOCK_PREFIX) + strlen(dev) + 1);
1990 if (lock_file == NULL)
1992 novm("lock file name");
1995 strcpy (lock_file, LOCK_PREFIX);
1996 strcat (lock_file, dev);
1998 * Attempt to create the lock file at this point.
2002 fd = open(lock_file, O_EXCL | O_CREAT | O_RDWR, 0644);
2007 sprintf (hdb_lock_buffer, "%010d\n", pid);
2008 write (fd, hdb_lock_buffer, 11);
2010 write(fd, &pid, sizeof (pid));
2016 * If the file exists then check to see if the pid is stale
2018 if (errno == EEXIST)
2020 fd = open(lock_file, O_RDONLY, 0);
2023 if (errno == ENOENT) /* This is just a timing problem. */
2030 /* Read the lock file to find out who has the device locked */
2031 n = read (fd, hdb_lock_buffer, 11);
2035 syslog(LOG_ERR, "Can't read pid from lock file %s", lock_file);
2039 /* See the process still exists. */
2043 hdb_lock_buffer[n] = '\0';
2044 sscanf (hdb_lock_buffer, " %d", &pid);
2046 pid = ((int *) hdb_lock_buffer)[0];
2048 if (pid == 0 || pid == getpid()
2049 || (kill(pid, 0) == -1 && errno == ESRCH))
2055 /* If the process does not exist then try to remove the lock */
2056 if (n == 0 && unlink (lock_file) == 0)
2058 syslog (LOG_NOTICE, "Removed stale lock on %s (pid %d)",
2063 syslog (LOG_NOTICE, "Device %s is locked by pid %d", dev, pid);
2067 syslog(LOG_ERR, "Can't create lock file %s: %m(%d)", lock_file, errno);
2078 /********************************************************************
2080 * unlock - remove our lockfile
2088 (void) rmlock (lock_file, (void *) 0);
2097 /********************************************************************
2099 * sifvjcomp - config tcp header compression
2102 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2104 u_int x = get_flags();
2108 if (ioctl (ppp_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0)
2110 if (! ok_error (errno))
2112 syslog (LOG_ERR, "ioctl(PPPIOCSMAXCID): %m(%d)", errno);
2118 x = vjcomp ? x | SC_COMP_TCP : x &~ SC_COMP_TCP;
2119 x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
2125 /********************************************************************
2127 * sifup - Config the interface up and enable IP packets to pass.
2134 memset (&ifr, '\0', sizeof (ifr));
2135 strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2136 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0)
2138 if (! ok_error (errno))
2140 syslog(LOG_ERR, "ioctl (SIOCGIFFLAGS): %m(%d)", errno);
2145 ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
2146 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0)
2148 if (! ok_error (errno))
2150 syslog(LOG_ERR, "ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2158 /********************************************************************
2160 * sifdown - Config the interface down and disable IP.
2169 memset (&ifr, '\0', sizeof (ifr));
2170 strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2171 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0)
2173 if (! ok_error (errno))
2175 syslog(LOG_ERR, "ioctl (SIOCGIFFLAGS): %m(%d)", errno);
2180 ifr.ifr_flags &= ~IFF_UP;
2181 ifr.ifr_flags |= IFF_POINTOPOINT;
2182 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0)
2184 if (! ok_error (errno))
2186 syslog(LOG_ERR, "ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2193 /********************************************************************
2195 * sifaddr - Config the interface IP addresses and netmask.
2198 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2204 memset (&ifr, '\0', sizeof (ifr));
2205 memset (&rt, '\0', sizeof (rt));
2207 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
2208 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2209 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2211 strncpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2213 * Set our IP address
2215 ((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr.s_addr = our_adr;
2216 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0)
2218 if (errno != EEXIST)
2220 if (! ok_error (errno))
2222 syslog (LOG_ERR, "ioctl(SIOCAIFADDR): %m(%d)", errno);
2227 syslog (LOG_WARNING, "ioctl(SIOCAIFADDR): Address already exists");
2232 * Set the gateway address
2234 ((struct sockaddr_in *) &ifr.ifr_dstaddr)->sin_addr.s_addr = his_adr;
2235 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0)
2237 if (! ok_error (errno))
2239 syslog (LOG_ERR, "ioctl(SIOCSIFDSTADDR): %m(%d)", errno);
2245 * For recent kernels, force the netmask to 255.255.255.255.
2247 if (kernel_version >= KVERSION(2,1,16))
2251 ((struct sockaddr_in *) &ifr.ifr_netmask)->sin_addr.s_addr = net_mask;
2252 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0)
2254 if (! ok_error (errno))
2256 syslog (LOG_ERR, "ioctl(SIOCSIFNETMASK): %m(%d)", errno);
2262 * Add the device route
2264 if (kernel_version < KVERSION(2,1,16)) {
2265 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2266 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2269 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = 0L;
2270 ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr = his_adr;
2271 rt.rt_flags = RTF_UP | RTF_HOST;
2273 if (kernel_version > KVERSION(2,1,0)) {
2274 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2275 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = -1L;
2278 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0)
2280 if (! ok_error (errno))
2282 syslog (LOG_ERR, "ioctl(SIOCADDRT) device route: %m(%d)", errno);
2290 /********************************************************************
2292 * cifaddr - Clear the interface IP addresses, and delete routes
2293 * through the interface if possible.
2296 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2300 if (kernel_version < KVERSION(2,1,16)) {
2302 * Delete the route through the device
2304 memset (&rt, '\0', sizeof (rt));
2306 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2307 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2310 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = 0;
2311 ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr = his_adr;
2312 rt.rt_flags = RTF_UP | RTF_HOST;
2314 if (kernel_version > KVERSION(2,1,0)) {
2315 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2316 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = -1L;
2319 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH)
2321 if (still_ppp() && ! ok_error (errno))
2323 syslog (LOG_ERR, "ioctl(SIOCDELRT) device route: %m(%d)", errno);
2331 /********************************************************************
2333 * open_loopback - open the device we use for getting packets
2334 * in demand mode. Under Linux, we use our existing fd
2335 * to the ppp driver.
2338 open_ppp_loopback(void)
2341 struct termios tios;
2344 for (i = 0; i < 64; ++i) {
2345 sprintf(loop_name, "/dev/pty%c%x", 'p' + i / 16, i % 16);
2346 master_fd = open(loop_name, O_RDWR | O_NOCTTY, 0);
2350 if (master_fd < 0) {
2351 syslog(LOG_ERR, "No free pty for loopback");
2354 SYSDEBUG((LOG_DEBUG, "using %s for loopback", loop_name));
2356 slave_fd = open(loop_name, O_RDWR | O_NOCTTY, 0);
2358 syslog(LOG_ERR, "Couldn't open %s for loopback: %m", loop_name);
2362 set_ppp_fd(slave_fd);
2364 if (tcgetattr(ppp_fd, &tios) == 0)
2366 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2367 tios.c_cflag |= CS8 | CREAD;
2368 tios.c_iflag = IGNPAR | CLOCAL;
2371 if (tcsetattr(ppp_fd, TCSAFLUSH, &tios) < 0)
2373 syslog(LOG_WARNING, "couldn't set attributes on loopback: %m(%d)", errno);
2377 flags = fcntl(master_fd, F_GETFL);
2379 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2381 syslog(LOG_WARNING, "couldn't set master loopback to nonblock: %m(%d)", errno);
2384 flags = fcntl(ppp_fd, F_GETFL);
2386 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2388 syslog(LOG_WARNING, "couldn't set slave loopback to nonblock: %m(%d)", errno);
2391 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2393 syslog(LOG_ERR, "ioctl(TIOCSETD): %m(%d)", errno);
2397 * Find out which interface we were given.
2399 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2401 syslog(LOG_ERR, "ioctl(PPPIOCGUNIT): %m(%d)", errno);
2405 * Enable debug in the driver if requested.
2407 set_kdebugflag (kdebugflag);
2410 /********************************************************************
2412 * restore_loop - reattach the ppp unit to the loopback.
2414 * The kernel ppp driver automatically reattaches the ppp unit to
2415 * the loopback if the serial port is set to a line discipline other
2416 * than ppp, or if it detects a modem hangup. The former will happen
2417 * in disestablish_ppp if the latter hasn't already happened, so we
2418 * shouldn't need to do anything.
2420 * Just to be sure, set the real serial port to the normal discipline.
2426 if (ppp_fd != slave_fd)
2428 (void) ioctl(ppp_fd, TIOCSETD, &tty_disc);
2429 set_ppp_fd(slave_fd);
2433 /********************************************************************
2435 * sifnpmode - Set the mode for handling packets for a given NP.
2439 sifnpmode(u, proto, mode)
2446 npi.protocol = proto;
2448 if (ioctl(ppp_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0)
2450 if (! ok_error (errno))
2452 syslog(LOG_ERR, "ioctl(PPPIOCSNPMODE, %d, %d): %m(%d)",
2453 proto, mode, errno);
2454 syslog(LOG_ERR, "ppp_fd=%d slave_fd=%d\n", ppp_fd, slave_fd);
2462 /********************************************************************
2464 * sipxfaddr - Config the interface IPX networknumber
2467 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2474 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2476 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2479 if (! ok_error (errno))
2481 syslog (LOG_DEBUG, "socket(AF_IPX): %m(%d)", errno);
2487 memset (&ifr, '\0', sizeof (ifr));
2488 strcpy (ifr.ifr_name, ifname);
2490 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2491 sipx->sipx_family = AF_IPX;
2492 sipx->sipx_port = 0;
2493 sipx->sipx_network = htonl (network);
2494 sipx->sipx_type = IPX_FRAME_ETHERII;
2495 sipx->sipx_action = IPX_CRTITF;
2497 * Set the IPX device
2499 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0)
2502 if (errno != EEXIST)
2504 if (! ok_error (errno))
2507 "ioctl(SIOCAIFADDR, CRTITF): %m(%d)", errno);
2512 syslog (LOG_WARNING,
2513 "ioctl(SIOCAIFADDR, CRTITF): Address already exists");
2522 /********************************************************************
2524 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2525 * are removed and the device is no longer able to pass IPX
2529 int cipxfaddr (int unit)
2536 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2538 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2541 if (! ok_error (errno))
2543 syslog (LOG_DEBUG, "socket(AF_IPX): %m(%d)", errno);
2549 memset (&ifr, '\0', sizeof (ifr));
2550 strcpy (ifr.ifr_name, ifname);
2552 sipx->sipx_type = IPX_FRAME_ETHERII;
2553 sipx->sipx_action = IPX_DLTITF;
2554 sipx->sipx_family = AF_IPX;
2556 * Set the IPX device
2558 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0)
2560 if (! ok_error (errno))
2563 "ioctl(SIOCAIFADDR, IPX_DLTITF): %m(%d)", errno);
2574 * daemon - Detach us from controlling terminal session.
2577 daemon(nochdir, noclose)
2578 int nochdir, noclose;
2582 if ((pid = fork()) < 0)
2585 exit(0); /* parent dies */
2590 fclose(stdin); /* don't need stdin, stdout, stderr */
2598 * Use the hostname as part of the random number seed.
2607 for (p = hostname; *p != 0; ++p)
2612 /********************************************************************
2614 * sys_check_options - check the options that the user specified
2618 sys_check_options(void)
2621 struct stat stat_buf;
2623 * Disable the IPX protocol if the support is not present in the kernel.
2624 * If we disable it then ensure that IP support is enabled.
2626 while (ipxcp_protent.enabled_flag)
2628 if (path_to_procfs())
2630 strcat (route_buffer, "/net/ipx_interface");
2631 if (lstat (route_buffer, &stat_buf) >= 0)
2636 syslog (LOG_ERR, "IPX support is not present in the kernel\n");
2637 ipxcp_protent.enabled_flag = 0;
2638 ipcp_protent.enabled_flag = 1;
2642 if (demand && driver_is_old) {
2643 option_error("demand dialling is not supported by kernel driver version "
2644 "%d.%d.%d", driver_version, driver_modification,