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
53 #include <linux/ppp_defs.h>
54 #include <linux/if_ppp.h>
57 #include <net/if_arp.h>
58 #include <net/route.h>
59 #include <netinet/if_ether.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>
72 #include "patchlevel.h"
76 #include <linux/ipx.h>
77 #endif /* IPX_CHANGE */
80 #include <sys/locks.h>
83 #ifndef RTF_DEFAULT /* Normally in <linux/route.h> from <net/route.h> */
87 #define ok_error(num) ((num)==EIO)
89 static int tty_disc = N_TTY; /* The TTY discipline */
90 static int ppp_disc = N_PPP; /* The PPP discpline */
91 static int initfdflags = -1; /* Initial file descriptor flags for fd */
92 static int ppp_fd = -1; /* fd which is set to PPP discipline */
93 static int sock_fd = -1; /* socket for doing interface ioctls */
94 static int slave_fd = -1;
95 static int master_fd = -1;
97 static int has_proxy_arp = 0;
98 static int driver_version = 0;
99 static int driver_modification = 0;
100 static int driver_patch = 0;
101 static int driver_is_old = 0;
102 static int restore_term = 0; /* 1 => we've munged the terminal */
103 static struct termios inittermios; /* Initial TTY termios */
105 static char loop_name[20];
106 static unsigned char inbuf[512]; /* buffer for chars read from loopback */
108 static int if_is_up; /* Interface has been marked up */
109 static u_int32_t default_route_gateway; /* Gateway for default route added */
110 static u_int32_t proxy_arp_addr; /* Addr for proxy arp entry added */
112 static char *lock_file;
114 static struct utsname utsname; /* for the kernel version */
118 #define FLAGS_GOOD (IFF_UP | IFF_BROADCAST)
119 #define FLAGS_MASK (IFF_UP | IFF_BROADCAST | \
120 IFF_POINTOPOINT | IFF_LOOPBACK | IFF_NOARP)
122 /* Prototypes for procedures local to this file. */
123 static int get_flags (void);
124 static void set_flags (int flags);
125 static int translate_speed (int bps);
126 static int baud_rate_of (int speed);
127 static char *path_to_route (void);
128 static void close_route_table (void);
129 static int open_route_table (void);
130 static int read_route_table (struct rtentry *rt);
131 static int defaultroute_exists (struct rtentry *rt);
132 static int get_ether_addr (u_int32_t ipaddr, struct sockaddr *hwaddr,
134 static void decode_version (char *buf, int *version, int *mod, int *patch);
136 extern u_char inpacket_buf[]; /* borrowed from main.c */
139 * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
143 #define SET_SA_FAMILY(addr, family) \
144 memset ((char *) &(addr), '\0', sizeof(addr)); \
145 addr.sa_family = (family);
148 * Determine if the PPP connection should still be present.
154 #define LOCK_PREFIX "/var/lock/LCK.."
157 static void set_ppp_fd (int new_fd)
159 SYSDEBUG ((LOG_DEBUG, "setting ppp_fd to %d\n", ppp_fd));
163 static int still_ppp(void)
165 if (!hungup || ppp_fd == slave_fd)
168 set_ppp_fd(slave_fd);
174 /********************************************************************
176 * Functions to read and set the flags value in the device driver
179 static int get_flags (void)
183 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &flags) < 0)
185 if ( ok_error (errno) )
191 syslog(LOG_ERR, "ioctl(PPPIOCGFLAGS): %m");
196 SYSDEBUG ((LOG_DEBUG, "get flags = %x\n", flags));
200 /********************************************************************/
202 static void set_flags (int flags)
204 SYSDEBUG ((LOG_DEBUG, "set flags = %x\n", flags));
206 if (ioctl(ppp_fd, PPPIOCSFLAGS, (caddr_t) &flags) < 0)
208 if (! ok_error (errno) )
210 syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS, %x): %m(%d)", flags, errno);
216 /********************************************************************
218 * sys_init - System-dependent initialization.
223 openlog("pppd", LOG_PID | LOG_NDELAY, LOG_PPP);
224 setlogmask(LOG_UPTO(LOG_INFO));
227 setlogmask(LOG_UPTO(LOG_DEBUG));
230 /* Get an internet socket for doing socket ioctls. */
231 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
234 if ( ! ok_error ( errno ))
236 syslog(LOG_ERR, "Couldn't create IP socket: %m(%d)", errno);
244 /********************************************************************
246 * sys_cleanup - restore any system state we modified before exiting:
247 * mark the interface down, delete default route and/or proxy arp entry.
248 * This should call die() because it's called from die().
251 void sys_cleanup(void)
254 * Take down the device
261 * Delete any routes through the device.
263 if (default_route_gateway != 0)
265 cifdefaultroute(0, 0, default_route_gateway);
270 cifproxyarp(0, proxy_arp_addr);
274 /********************************************************************
276 * sys_close - Clean up in a child process before execing.
286 /********************************************************************
288 * note_debug_level - note a change in the debug level.
291 void note_debug_level (void)
295 SYSDEBUG ((LOG_INFO, "Debug turned ON, Level %d", debug));
296 setlogmask(LOG_UPTO(LOG_DEBUG));
300 setlogmask(LOG_UPTO(LOG_WARNING));
304 /********************************************************************
306 * set_kdebugflag - Define the debugging level for the kernel
309 int set_kdebugflag (int requested_level)
311 if (ioctl(ppp_fd, PPPIOCSDEBUG, &requested_level) < 0)
313 if ( ! ok_error (errno) )
315 syslog (LOG_ERR, "ioctl(PPPIOCSDEBUG): %m");
319 SYSDEBUG ((LOG_INFO, "set kernel debugging level to %d",
324 /********************************************************************
326 * establish_ppp - Turn the serial port into a ppp interface.
329 void establish_ppp (int tty_fd)
333 * The current PPP device will be the tty file.
337 * Ensure that the tty device is in exclusive mode.
339 if (ioctl(tty_fd, TIOCEXCL, 0) < 0)
341 if ( ! ok_error ( errno ))
343 syslog (LOG_WARNING, "ioctl(TIOCEXCL): %m");
347 * Demand mode - prime the old ppp device to relinquish the unit.
349 if (demand && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0)
351 syslog(LOG_ERR, "ioctl(transfer ppp unit): %m(%d)", errno);
355 * Set the current tty to the PPP discpline
357 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
359 if ( ! ok_error (errno) )
361 syslog(LOG_ERR, "ioctl(TIOCSETD): %m(%d)", errno);
366 * Find out which interface we were given.
368 if (ioctl(ppp_fd, PPPIOCGUNIT, &x) < 0)
370 if ( ! ok_error (errno))
372 syslog(LOG_ERR, "ioctl(PPPIOCGUNIT): %m(%d)", errno);
377 * Check that we got the same unit again.
383 syslog(LOG_ERR, "transfer_ppp failed: wanted unit %d, got %d",
391 * Enable debug in the driver if requested.
394 set_kdebugflag (kdebugflag);
396 set_flags (get_flags() & ~(SC_RCV_B7_0 | SC_RCV_B7_1 |
397 SC_RCV_EVNP | SC_RCV_ODDP));
399 SYSDEBUG ((LOG_NOTICE, "Using version %d.%d.%d of PPP driver",
400 driver_version, driver_modification, driver_patch));
402 * Fetch the initial file flags and reset blocking mode on the file.
404 initfdflags = fcntl(ppp_fd, F_GETFL);
406 if (initfdflags == -1 ||
407 fcntl(ppp_fd, F_SETFL, initfdflags | O_NONBLOCK) == -1)
409 if ( ! ok_error (errno))
412 "Couldn't set device to non-blocking mode: %m");
417 /********************************************************************
419 * disestablish_ppp - Restore the serial port to normal operation.
420 * This shouldn't call die() because it's called from die().
423 void disestablish_ppp(int tty_fd)
426 * Attempt to restore the previous tty settings
431 * Restore the previous line discipline
433 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0)
435 if ( ! ok_error (errno))
437 syslog(LOG_ERR, "ioctl(TIOCSETD, N_TTY): %m");
441 if (ioctl(tty_fd, TIOCNXCL, 0) < 0)
443 if ( ! ok_error (errno))
445 syslog (LOG_WARNING, "ioctl(TIOCNXCL): %m(%d)", errno);
449 /* Reset non-blocking mode on fd. */
450 if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0)
452 if ( ! ok_error (errno))
455 "Couldn't restore device fd flags: %m");
462 /********************************************************************
464 * clean_check - Fetch the flags for the device and generate
465 * appropriate error messages.
467 void clean_check(void)
474 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0)
477 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP))
480 case SC_RCV_B7_0 | SC_RCV_EVNP:
481 case SC_RCV_B7_0 | SC_RCV_ODDP:
482 case SC_RCV_B7_0 | SC_RCV_ODDP | SC_RCV_EVNP:
483 s = "all had bit 7 set to 1";
487 case SC_RCV_B7_1 | SC_RCV_EVNP:
488 case SC_RCV_B7_1 | SC_RCV_ODDP:
489 case SC_RCV_B7_1 | SC_RCV_ODDP | SC_RCV_EVNP:
490 s = "all had bit 7 set to 0";
494 s = "all had odd parity";
498 s = "all had even parity";
504 syslog(LOG_WARNING, "Receive serial link is not"
506 syslog(LOG_WARNING, "Problem: %s", s);
514 * List of valid speeds.
518 int speed_int, speed_val;
595 /********************************************************************
597 * Translate from bits/second to a speed_t.
600 static int translate_speed (int bps)
602 struct speed *speedp;
606 for (speedp = speeds; speedp->speed_int; speedp++)
608 if (bps == speedp->speed_int)
610 return speedp->speed_val;
613 syslog(LOG_WARNING, "speed %d not supported", bps);
618 /********************************************************************
620 * Translate from a speed_t to bits/second.
623 static int baud_rate_of (int speed)
625 struct speed *speedp;
629 for (speedp = speeds; speedp->speed_int; speedp++)
631 if (speed == speedp->speed_val)
633 return speedp->speed_int;
640 /********************************************************************
642 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
643 * at the requested speed, etc. If `local' is true, set CLOCAL
644 * regardless of whether the modem option was specified.
647 void set_up_tty (int tty_fd, int local)
652 if (tcgetattr(tty_fd, &tios) < 0)
654 syslog(LOG_ERR, "tcgetattr: %m(%d)", errno);
663 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
664 tios.c_cflag |= CS8 | CREAD | HUPCL;
666 tios.c_iflag = IGNBRK | IGNPAR;
670 tios.c_cc[VTIME] = 0;
674 tios.c_cflag ^= (CLOCAL | HUPCL);
680 tios.c_cflag |= CRTSCTS;
684 tios.c_iflag |= IXON | IXOFF;
685 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
686 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
690 tios.c_cflag &= ~CRTSCTS;
697 speed = translate_speed(inspeed);
700 cfsetospeed (&tios, speed);
701 cfsetispeed (&tios, speed);
704 * We can't proceed if the serial port speed is B0,
705 * since that implies that the serial port is disabled.
709 speed = cfgetospeed(&tios);
712 syslog(LOG_ERR, "Baud rate for %s is 0; need explicit baud rate",
718 if (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0)
720 syslog(LOG_ERR, "tcsetattr: %m");
724 baud_rate = baud_rate_of(speed);
728 /********************************************************************
730 * setdtr - control the DTR line on the serial port.
731 * This is called from die(), so it shouldn't call die().
734 void setdtr (int tty_fd, int on)
736 int modembits = TIOCM_DTR;
738 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
741 /********************************************************************
743 * restore_tty - restore the terminal to the saved settings.
746 void restore_tty (int tty_fd)
752 * Turn off echoing, because otherwise we can get into
753 * a loop with the tty and the modem echoing to each other.
754 * We presume we are the sole user of this tty device, so
755 * when we close it, it will revert to its defaults anyway.
759 inittermios.c_lflag &= ~(ECHO | ECHONL);
762 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0)
764 if (! ok_error (errno))
766 syslog(LOG_WARNING, "tcsetattr: %m");
772 /********************************************************************
774 * output - Output PPP packet.
777 void output (int unit, unsigned char *p, int len)
781 log_packet(p, len, "sent ", LOG_DEBUG);
784 if (write(ppp_fd, p, len) < 0)
786 if (errno == EWOULDBLOCK || errno == ENOBUFS
787 || errno == ENXIO || errno == EIO)
789 syslog(LOG_WARNING, "write: warning: %m(%d)", errno);
793 syslog(LOG_ERR, "write: %m(%d)", errno);
799 /********************************************************************
801 * wait_input - wait until there is data available on ppp_fd,
802 * for the length of time specified by *timo (indefinite
806 void wait_input (struct timeval *timo)
812 FD_SET(ppp_fd, &ready);
814 n = select(ppp_fd + 1, &ready, NULL, &ready, timo);
815 if (n < 0 && errno != EINTR)
817 syslog(LOG_ERR, "select: %m(%d)", errno);
822 /********************************************************************
824 * wait_loop_output - wait until there is data available on the
825 * loopback, for the length of time specified by *timo (indefinite
828 void wait_loop_output(timo)
829 struct timeval *timo;
835 FD_SET(master_fd, &ready);
836 n = select(master_fd + 1, &ready, NULL, &ready, timo);
837 if (n < 0 && errno != EINTR)
839 syslog(LOG_ERR, "select: %m(%d)", errno);
844 /********************************************************************
846 * wait_time - wait for a given length of time or until a
847 * signal is received.
851 struct timeval *timo;
855 n = select(0, NULL, NULL, NULL, timo);
856 if (n < 0 && errno != EINTR) {
857 syslog(LOG_ERR, "select: %m(%d)", errno);
862 /********************************************************************
864 * read_packet - get a PPP packet from the serial device.
867 int read_packet (unsigned char *buf)
871 len = read(ppp_fd, buf, PPP_MTU + PPP_HDRLEN);
874 if (errno == EWOULDBLOCK)
878 syslog(LOG_ERR, "read: %m(%d)", errno);
884 /********************************************************************
886 * get_loop_output - get outgoing packets from the ppp device,
887 * and detect when we want to bring the real link up.
888 * Return value is 1 if we need to bring up the link, 0 otherwise.
891 get_loop_output(void)
894 int n = read(master_fd, inbuf, sizeof(inbuf));
898 if (loop_chars(inbuf, n))
902 n = read(master_fd, inbuf, sizeof(inbuf));
907 syslog(LOG_ERR, "eof on loopback");
911 if (errno != EWOULDBLOCK)
913 syslog(LOG_ERR, "read from loopback: %m(%d)", errno);
920 /********************************************************************
922 * ppp_send_config - configure the transmit characteristics of
926 void ppp_send_config (int unit,int mtu,u_int32_t asyncmap,int pcomp,int accomp)
931 SYSDEBUG ((LOG_DEBUG, "send_config: mtu = %d\n", mtu));
933 * Ensure that the link is still up.
938 * Set the MTU and other parameters for the ppp device
940 memset (&ifr, '\0', sizeof (ifr));
941 strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
944 if (ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
946 syslog(LOG_ERR, "ioctl(SIOCSIFMTU): %m(%d)", errno);
950 SYSDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
951 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0)
953 syslog(LOG_ERR, "ioctl(PPPIOCSASYNCMAP): %m(%d)", errno);
958 x = pcomp ? x | SC_COMP_PROT : x & ~SC_COMP_PROT;
959 x = accomp ? x | SC_COMP_AC : x & ~SC_COMP_AC;
964 /********************************************************************
966 * ppp_set_xaccm - set the extended transmit ACCM for the interface.
969 void ppp_set_xaccm (int unit, ext_accm accm)
971 SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
972 accm[0], accm[1], accm[2], accm[3]));
974 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY)
976 if ( ! ok_error (errno))
978 syslog(LOG_WARNING, "ioctl(set extended ACCM): %m(%d)", errno);
983 /********************************************************************
985 * ppp_recv_config - configure the receive-side characteristics of
989 void ppp_recv_config (int unit,int mru,u_int32_t asyncmap,int pcomp,int accomp)
993 SYSDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
995 * If we were called because the link has gone down then there is nothing
996 * which may be done. Just return without incident.
1003 * Set the receiver parameters
1005 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0)
1007 if ( ! ok_error (errno))
1009 syslog(LOG_ERR, "ioctl(PPPIOCSMRU): %m(%d)", errno);
1013 SYSDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
1014 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0)
1016 syslog(LOG_ERR, "ioctl(PPPIOCSRASYNCMAP): %m(%d)", errno);
1021 x = !accomp? x | SC_REJ_COMP_AC: x &~ SC_REJ_COMP_AC;
1025 /********************************************************************
1027 * ccp_test - ask kernel whether a given compression method
1028 * is acceptable for use.
1031 int ccp_test (int unit, u_char *opt_ptr, int opt_len, int for_transmit)
1033 struct ppp_option_data data;
1035 memset (&data, '\0', sizeof (data));
1037 data.length = opt_len;
1038 data.transmit = for_transmit;
1040 if (ioctl(ppp_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
1045 return (errno == ENOBUFS)? 0: -1;
1048 /********************************************************************
1050 * ccp_flags_set - inform kernel about the current state of CCP.
1053 void ccp_flags_set (int unit, int isopen, int isup)
1057 int x = get_flags();
1058 x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
1059 x = isup? x | SC_CCP_UP : x &~ SC_CCP_UP;
1064 /********************************************************************
1066 * get_idle_time - return how long the link has been idle.
1069 get_idle_time(u, ip)
1071 struct ppp_idle *ip;
1073 return ioctl(ppp_fd, PPPIOCGIDLE, ip) >= 0;
1076 /********************************************************************
1078 * ccp_fatal_error - returns 1 if decompression was disabled as a
1079 * result of an error detected after decompression of a packet,
1080 * 0 otherwise. This is necessary because of patent nonsense.
1083 int ccp_fatal_error (int unit)
1085 int x = get_flags();
1087 return x & SC_DC_FERROR;
1091 * path_to_route - determine the path to the proc file system data
1094 FILE *route_fd = (FILE *) 0;
1095 static char route_buffer [512];
1097 static char *path_to_route (void);
1098 static int open_route_table (void);
1099 static void close_route_table (void);
1100 static int read_route_table (struct rtentry *rt);
1102 /********************************************************************
1104 * path_to_procfs - find the path to the proc file system mount point
1107 static int path_to_procfs (void)
1109 struct mntent *mntent;
1112 fp = fopen (MOUNTED, "r");
1115 mntent = getmntent (fp);
1116 while (mntent != (struct mntent *) 0)
1118 if (strcmp (mntent->mnt_type, MNTTYPE_IGNORE) != 0)
1120 if (strcmp (mntent->mnt_type, "proc") == 0)
1122 strncpy (route_buffer, mntent->mnt_dir,
1123 sizeof (route_buffer)-10);
1124 route_buffer [sizeof (route_buffer)-10] = '\0';
1129 mntent = getmntent (fp);
1134 /* Default the mount location of /proc */
1135 strncpy (route_buffer, "/proc", sizeof (route_buffer)-10);
1139 /********************************************************************
1141 * path_to_route - find the path to the route tables in the proc file system
1144 static char *path_to_route (void)
1146 if (! path_to_procfs())
1148 syslog (LOG_ERR, "proc file system not mounted");
1151 strcat (route_buffer, "/net/route");
1152 return (route_buffer);
1155 /********************************************************************
1157 * close_route_table - close the interface to the route table
1160 static void close_route_table (void)
1162 if (route_fd != (FILE *) 0)
1165 route_fd = (FILE *) 0;
1169 /********************************************************************
1171 * open_route_table - open the interface to the route table
1174 static int open_route_table (void)
1178 close_route_table();
1180 path = path_to_route();
1186 route_fd = fopen (path, "r");
1187 if (route_fd == (FILE *) 0)
1189 syslog (LOG_ERR, "can not open %s: %m(%d)", path, errno);
1195 /********************************************************************
1197 * read_route_table - read the next entry from the route table
1200 static int read_route_table (struct rtentry *rt)
1202 static char delims[] = " \t\n";
1203 char *dev_ptr, *dst_ptr, *gw_ptr, *flag_ptr;
1205 memset (rt, '\0', sizeof (struct rtentry));
1209 if (fgets (route_buffer, sizeof (route_buffer), route_fd) ==
1215 dev_ptr = strtok (route_buffer, delims); /* interface name */
1216 dst_ptr = strtok (NULL, delims); /* destination address */
1217 gw_ptr = strtok (NULL, delims); /* gateway */
1218 flag_ptr = strtok (NULL, delims); /* flags */
1220 if (flag_ptr == (char *) 0) /* assume that we failed, somewhere. */
1225 /* Discard that stupid header line which should never
1226 * have been there in the first place !! */
1227 if (isxdigit (*dst_ptr) && isxdigit (*gw_ptr) && isxdigit (*flag_ptr))
1233 ((struct sockaddr_in *) &rt->rt_dst)->sin_addr.s_addr =
1234 strtoul (dst_ptr, NULL, 16);
1236 ((struct sockaddr_in *) &rt->rt_gateway)->sin_addr.s_addr =
1237 strtoul (gw_ptr, NULL, 16);
1239 rt->rt_flags = (short) strtoul (flag_ptr, NULL, 16);
1240 rt->rt_dev = dev_ptr;
1245 /********************************************************************
1247 * defaultroute_exists - determine if there is a default route
1250 static int defaultroute_exists (struct rtentry *rt)
1254 if (!open_route_table())
1259 while (read_route_table(rt) != 0)
1261 if ((rt->rt_flags & RTF_UP) == 0)
1266 if (((struct sockaddr_in *) (&rt->rt_dst))->sin_addr.s_addr == 0L)
1273 close_route_table();
1277 /********************************************************************
1279 * sifdefaultroute - assign a default route through the address given.
1282 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1286 if (defaultroute_exists(&rt))
1288 struct in_addr old_gateway =
1289 ((struct sockaddr_in *) (&rt.rt_gateway))-> sin_addr;
1291 if (old_gateway.s_addr != gateway)
1294 "not replacing existing default route to %s [%s]",
1296 inet_ntoa (old_gateway));
1301 memset (&rt, '\0', sizeof (rt));
1302 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1303 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1305 if (strcmp(utsname.release, "2.1.0") > 0) {
1306 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1307 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = 0L;
1310 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = gateway;
1312 rt.rt_flags = RTF_UP | RTF_GATEWAY | RTF_DEFAULT;
1313 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0)
1315 if ( ! ok_error ( errno ))
1317 syslog (LOG_ERR, "default route ioctl(SIOCADDRT): %m(%d)", errno);
1322 default_route_gateway = gateway;
1326 /********************************************************************
1328 * cifdefaultroute - delete a default route through the address given.
1331 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1335 default_route_gateway = 0;
1337 memset (&rt, '\0', sizeof (rt));
1338 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1339 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1341 if (strcmp(utsname.release, "2.1.0") > 0) {
1342 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1343 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = 0L;
1346 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = gateway;
1348 rt.rt_flags = RTF_UP | RTF_GATEWAY | RTF_DEFAULT;
1349 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH)
1353 if ( ! ok_error ( errno ))
1356 "default route ioctl(SIOCDELRT): %m(%d)", errno);
1365 /********************************************************************
1367 * sifproxyarp - Make a proxy ARP entry for the peer.
1370 int sifproxyarp (int unit, u_int32_t his_adr)
1372 struct arpreq arpreq;
1374 if (has_proxy_arp == 0)
1376 memset (&arpreq, '\0', sizeof(arpreq));
1378 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1379 ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = his_adr;
1380 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1382 * Get the hardware address of an interface on the same subnet
1383 * as our local address.
1385 if (!get_ether_addr(his_adr, &arpreq.arp_ha, arpreq.arp_dev))
1387 syslog(LOG_ERR, "Cannot determine ethernet address for proxy ARP");
1391 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0)
1393 if ( ! ok_error ( errno ))
1395 syslog(LOG_ERR, "ioctl(SIOCSARP): %m(%d)", errno);
1401 proxy_arp_addr = his_adr;
1406 /********************************************************************
1408 * cifproxyarp - Delete the proxy ARP entry for the peer.
1411 int cifproxyarp (int unit, u_int32_t his_adr)
1413 struct arpreq arpreq;
1415 if (has_proxy_arp == 1)
1417 memset (&arpreq, '\0', sizeof(arpreq));
1418 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1419 ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = his_adr;
1420 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1422 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0)
1424 if ( ! ok_error ( errno ))
1426 syslog(LOG_WARNING, "ioctl(SIOCDARP): %m(%d)", errno);
1435 /********************************************************************
1437 * get_ether_addr - get the hardware address of an interface on the
1438 * the same subnet as ipaddr.
1441 static int get_ether_addr (u_int32_t ipaddr,
1442 struct sockaddr *hwaddr,
1445 struct ifreq *ifr, *ifend;
1446 u_int32_t ina, mask;
1449 struct ifreq ifs[MAX_IFS];
1451 ifc.ifc_len = sizeof(ifs);
1453 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0)
1455 if ( ! ok_error ( errno ))
1457 syslog(LOG_ERR, "ioctl(SIOCGIFCONF): %m(%d)", errno);
1462 SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1463 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1465 * Scan through looking for an interface with an Internet
1466 * address on the same subnet as `ipaddr'.
1468 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1469 for (ifr = ifc.ifc_req; ifr < ifend; ifr++)
1471 if (ifr->ifr_addr.sa_family == AF_INET)
1473 ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
1474 strncpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1475 SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1478 * Check that the interface is up, and not point-to-point
1481 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1486 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1491 * Get its netmask and check that it's on the right subnet.
1493 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1498 mask = ((struct sockaddr_in *) &ifreq.ifr_addr)->sin_addr.s_addr;
1499 SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1500 ip_ntoa(ina), ntohl(mask)));
1502 if (((ipaddr ^ ina) & mask) != 0)
1515 memcpy (name, ifreq.ifr_name, sizeof(ifreq.ifr_name));
1516 syslog(LOG_INFO, "found interface %s for proxy arp", name);
1518 * Now get the hardware address.
1520 memset (&ifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1521 if (ioctl (sock_fd, SIOCGIFHWADDR, &ifreq) < 0)
1523 syslog(LOG_ERR, "SIOCGIFHWADDR(%s): %m(%d)", ifreq.ifr_name, errno);
1529 sizeof (struct sockaddr));
1531 SYSDEBUG ((LOG_DEBUG,
1532 "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1533 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1534 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1535 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1536 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1537 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1538 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1539 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1540 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1544 /********************************************************************
1546 * Return user specified netmask, modified by any mask we might determine
1547 * for address `addr' (in network byte order).
1548 * Here we scan through the system's list of interfaces, looking for
1549 * any non-point-to-point interfaces which might appear to be on the same
1550 * network as `addr'. If we find any, we OR in their netmask to the
1551 * user-specified netmask.
1554 u_int32_t GetMask (u_int32_t addr)
1556 u_int32_t mask, nmask, ina;
1557 struct ifreq *ifr, *ifend, ifreq;
1559 struct ifreq ifs[MAX_IFS];
1563 if (IN_CLASSA(addr)) /* determine network mask for address class */
1565 nmask = IN_CLASSA_NET;
1569 if (IN_CLASSB(addr))
1571 nmask = IN_CLASSB_NET;
1575 nmask = IN_CLASSC_NET;
1579 /* class D nets are disallowed by bad_ip_adrs */
1580 mask = netmask | htonl(nmask);
1582 * Scan through the system's network interfaces.
1584 ifc.ifc_len = sizeof(ifs);
1586 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0)
1588 if ( ! ok_error ( errno ))
1590 syslog(LOG_WARNING, "ioctl(SIOCGIFCONF): %m(%d)", errno);
1595 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1596 for (ifr = ifc.ifc_req; ifr < ifend; ifr++)
1599 * Check the interface's internet address.
1601 if (ifr->ifr_addr.sa_family != AF_INET)
1605 ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
1606 if (((ntohl(ina) ^ addr) & nmask) != 0)
1611 * Check that the interface is up, and not point-to-point nor loopback.
1613 strncpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1614 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1619 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1624 * Get its netmask and OR it into our mask.
1626 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1630 mask |= ((struct sockaddr_in *)&ifreq.ifr_addr)->sin_addr.s_addr;
1636 /********************************************************************
1638 * Internal routine to decode the version.modification.patch level
1641 static void decode_version (char *buf, int *version,
1642 int *modification, int *patch)
1644 *version = (int) strtoul (buf, &buf, 10);
1651 *modification = (int) strtoul (buf, &buf, 10);
1655 *patch = (int) strtoul (buf, &buf, 10);
1667 /********************************************************************
1669 * Procedure to determine if the PPP line discipline is registered.
1673 ppp_registered(void)
1679 local_fd = open(devnam, O_NONBLOCK | O_RDWR, 0);
1682 syslog(LOG_ERR, "Failed to open %s: %m(%d)", devnam, errno);
1686 initfdflags = fcntl(local_fd, F_GETFL);
1687 if (initfdflags == -1)
1689 syslog(LOG_ERR, "Couldn't get device fd flags: %m(%d)", errno);
1694 initfdflags &= ~O_NONBLOCK;
1695 fcntl(local_fd, F_SETFL, initfdflags);
1697 * Read the initial line dicipline and try to put the device into the
1700 if (ioctl(local_fd, TIOCGETD, &init_disc) < 0)
1702 syslog(LOG_ERR, "ioctl(TIOCGETD): %m(%d)", errno);
1707 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0)
1709 syslog(LOG_ERR, "ioctl(TIOCSETD): %m(%d)", errno);
1714 if (ioctl(local_fd, TIOCSETD, &init_disc) < 0)
1716 syslog(LOG_ERR, "ioctl(TIOCSETD): %m(%d)", errno);
1725 /********************************************************************
1727 * ppp_available - check whether the system has any ppp interfaces
1728 * (in fact we check whether we can do an ioctl on ppp0).
1731 int ppp_available(void)
1736 int my_version, my_modification, my_patch;
1737 extern char *no_ppp_msg;
1739 * Open a socket for doing the ioctl operations.
1741 s = socket(AF_INET, SOCK_DGRAM, 0);
1747 strncpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1748 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1750 * If the device did not exist then attempt to create one by putting the
1751 * current tty into the PPP discipline. If this works then obtain the
1752 * flags for the device again.
1756 if (ppp_registered())
1758 strncpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1759 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1763 * Ensure that the hardware address is for PPP and not something else
1767 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
1770 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
1778 "This system lacks kernel support for PPP. This could be because\n"
1779 "the PPP kernel module is not loaded, or because the kernel is\n"
1780 "not configured for PPP. See the README.linux file in the\n"
1781 "ppp-2.3.3 distribution.\n";
1784 * This is the PPP device. Validate the version of the driver at this
1785 * point to ensure that this program will work with the driver.
1789 char abBuffer [1024];
1791 ifr.ifr_data = abBuffer;
1792 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
1797 decode_version (abBuffer,
1799 &driver_modification,
1806 driver_modification =
1810 * Validate the version of the driver against the version that we used.
1812 decode_version (VERSION,
1817 /* The version numbers must match */
1818 if (driver_version != my_version)
1823 /* The modification levels must be legal */
1824 if (driver_modification < my_modification)
1826 if (driver_modification >= 2) {
1827 /* we can cope with 2.2.0 and above */
1837 sprintf (route_buffer,
1838 "Sorry - PPP driver version %d.%d.%d is out of date\n",
1839 driver_version, driver_modification, driver_patch);
1841 no_ppp_msg = route_buffer;
1847 /********************************************************************
1849 * Update the wtmp file with the appropriate user name and tty device.
1852 void logwtmp (const char *line, const char *name, const char *host)
1855 struct utmp ut, *utp;
1856 pid_t mypid = getpid();
1858 * Update the signon database for users.
1859 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
1861 utmpname(_PATH_UTMP);
1863 while ((utp = getutent()) && (utp->ut_pid != mypid))
1866 /* Is this call really necessary? There is another one after the 'put' */
1871 memcpy(&ut, utp, sizeof(ut));
1875 /* some gettys/telnetds don't initialize utmp... */
1876 memset(&ut, 0, sizeof(ut));
1879 if (ut.ut_id[0] == 0)
1881 strncpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
1884 strncpy(ut.ut_user, name, sizeof(ut.ut_user));
1885 strncpy(ut.ut_line, line, sizeof(ut.ut_line));
1889 ut.ut_type = USER_PROCESS;
1892 /* Insert the host name if one is supplied */
1895 strncpy (ut.ut_host, host, sizeof(ut.ut_host));
1898 /* Insert the IP address of the remote system if IP is enabled */
1899 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
1901 memcpy (&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
1902 sizeof(ut.ut_addr));
1905 /* CL: Makes sure that the logout works */
1906 if (*host == 0 && *name==0)
1914 * Update the wtmp file.
1916 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
1919 flock(wtmp, LOCK_EX);
1921 /* we really should check for error on the write for a full disk! */
1922 write (wtmp, (char *)&ut, sizeof(ut));
1925 flock(wtmp, LOCK_UN);
1929 /********************************************************************
1930 * Code for locking/unlocking the serial device.
1931 * This code is derived from chat.c.
1935 * lock - create a lock file for the named device
1938 int lock (char *dev)
1942 lock_file = malloc(strlen(dev) + 1);
1943 if (lock_file == NULL)
1945 novm("lock file name");
1947 strcpy (lock_file, dev);
1948 result = mklock (dev, (void *) 0);
1952 syslog (LOG_NOTICE, "Device %s is locked by pid %d", dev, result);
1961 syslog (LOG_ERR, "Can't create lock file %s", lock_file);
1969 char hdb_lock_buffer[12];
1974 p = strrchr(dev, '/');
1980 lock_file = malloc(strlen(LOCK_PREFIX) + strlen(dev) + 1);
1981 if (lock_file == NULL)
1983 novm("lock file name");
1986 strcpy (lock_file, LOCK_PREFIX);
1987 strcat (lock_file, dev);
1989 * Attempt to create the lock file at this point.
1993 fd = open(lock_file, O_EXCL | O_CREAT | O_RDWR, 0644);
1998 sprintf (hdb_lock_buffer, "%010d\n", pid);
1999 write (fd, hdb_lock_buffer, 11);
2001 write(fd, &pid, sizeof (pid));
2007 * If the file exists then check to see if the pid is stale
2009 if (errno == EEXIST)
2011 fd = open(lock_file, O_RDONLY, 0);
2014 if (errno == ENOENT) /* This is just a timing problem. */
2021 /* Read the lock file to find out who has the device locked */
2022 n = read (fd, hdb_lock_buffer, 11);
2026 syslog(LOG_ERR, "Can't read pid from lock file %s", lock_file);
2030 /* See the process still exists. */
2034 hdb_lock_buffer[n] = '\0';
2035 sscanf (hdb_lock_buffer, " %d", &pid);
2037 pid = ((int *) hdb_lock_buffer)[0];
2039 if (pid == 0 || pid == getpid()
2040 || (kill(pid, 0) == -1 && errno == ESRCH))
2046 /* If the process does not exist then try to remove the lock */
2047 if (n == 0 && unlink (lock_file) == 0)
2049 syslog (LOG_NOTICE, "Removed stale lock on %s (pid %d)",
2054 syslog (LOG_NOTICE, "Device %s is locked by pid %d", dev, pid);
2058 syslog(LOG_ERR, "Can't create lock file %s: %m(%d)", lock_file, errno);
2069 /********************************************************************
2071 * unlock - remove our lockfile
2079 (void) rmlock (lock_file, (void *) 0);
2088 /********************************************************************
2090 * sifvjcomp - config tcp header compression
2093 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
2095 u_int x = get_flags();
2099 if (ioctl (ppp_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0)
2101 if (! ok_error (errno))
2103 syslog (LOG_ERR, "ioctl(PPPIOCSMAXCID): %m(%d)", errno);
2109 x = vjcomp ? x | SC_COMP_TCP : x &~ SC_COMP_TCP;
2110 x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
2116 /********************************************************************
2118 * sifup - Config the interface up and enable IP packets to pass.
2125 memset (&ifr, '\0', sizeof (ifr));
2126 strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2127 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0)
2129 if (! ok_error (errno))
2131 syslog(LOG_ERR, "ioctl (SIOCGIFFLAGS): %m(%d)", errno);
2136 ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
2137 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0)
2139 if (! ok_error (errno))
2141 syslog(LOG_ERR, "ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2149 /********************************************************************
2151 * sifdown - Config the interface down and disable IP.
2160 memset (&ifr, '\0', sizeof (ifr));
2161 strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2162 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0)
2164 if (! ok_error (errno))
2166 syslog(LOG_ERR, "ioctl (SIOCGIFFLAGS): %m(%d)", errno);
2171 ifr.ifr_flags &= ~IFF_UP;
2172 ifr.ifr_flags |= IFF_POINTOPOINT;
2173 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0)
2175 if (! ok_error (errno))
2177 syslog(LOG_ERR, "ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2184 /********************************************************************
2186 * sifaddr - Config the interface IP addresses and netmask.
2189 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2195 memset (&ifr, '\0', sizeof (ifr));
2196 memset (&rt, '\0', sizeof (rt));
2198 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
2199 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2200 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2202 strncpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2204 * Set our IP address
2206 ((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr.s_addr = our_adr;
2207 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0)
2209 if (errno != EEXIST)
2211 if (! ok_error (errno))
2213 syslog (LOG_ERR, "ioctl(SIOCAIFADDR): %m(%d)", errno);
2218 syslog (LOG_WARNING, "ioctl(SIOCAIFADDR): Address already exists");
2223 * Set the gateway address
2225 ((struct sockaddr_in *) &ifr.ifr_dstaddr)->sin_addr.s_addr = his_adr;
2226 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0)
2228 if (! ok_error (errno))
2230 syslog (LOG_ERR, "ioctl(SIOCSIFDSTADDR): %m(%d)", errno);
2236 * For recent kernels, force the netmask to 255.255.255.255.
2238 if (strcmp(utsname.release, "2.1.16") >= 0)
2242 ((struct sockaddr_in *) &ifr.ifr_netmask)->sin_addr.s_addr = net_mask;
2243 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0)
2245 if (! ok_error (errno))
2247 syslog (LOG_ERR, "ioctl(SIOCSIFNETMASK): %m(%d)", errno);
2253 * Add the device route
2255 if (strcmp(utsname.release, "2.1.16") < 0) {
2256 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2257 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2260 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = 0L;
2261 ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr = his_adr;
2262 rt.rt_flags = RTF_UP | RTF_HOST;
2264 if (strcmp(utsname.release, "2.1.0") > 0) {
2265 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2266 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = -1L;
2269 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0)
2271 if (! ok_error (errno))
2273 syslog (LOG_ERR, "ioctl(SIOCADDRT) device route: %m(%d)", errno);
2281 /********************************************************************
2283 * cifaddr - Clear the interface IP addresses, and delete routes
2284 * through the interface if possible.
2287 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2291 if (strcmp(utsname.release, "2.1.16") < 0) {
2293 * Delete the route through the device
2295 memset (&rt, '\0', sizeof (rt));
2297 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2298 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2301 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = 0;
2302 ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr = his_adr;
2303 rt.rt_flags = RTF_UP | RTF_HOST;
2305 if (strcmp(utsname.release, "2.1.0") > 0) {
2306 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2307 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = -1L;
2310 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH)
2312 if (still_ppp() && ! ok_error (errno))
2314 syslog (LOG_ERR, "ioctl(SIOCDELRT) device route: %m(%d)", errno);
2322 /********************************************************************
2324 * open_loopback - open the device we use for getting packets
2325 * in demand mode. Under Linux, we use our existing fd
2326 * to the ppp driver.
2329 open_ppp_loopback(void)
2332 struct termios tios;
2335 for (i = 0; i < 64; ++i) {
2336 sprintf(loop_name, "/dev/pty%c%x", 'p' + i / 16, i % 16);
2337 master_fd = open(loop_name, O_RDWR | O_NOCTTY, 0);
2341 if (master_fd < 0) {
2342 syslog(LOG_ERR, "No free pty for loopback");
2345 SYSDEBUG((LOG_DEBUG, "using %s for loopback", loop_name));
2347 slave_fd = open(loop_name, O_RDWR | O_NOCTTY, 0);
2349 syslog(LOG_ERR, "Couldn't open %s for loopback: %m", loop_name);
2353 set_ppp_fd(slave_fd);
2355 if (tcgetattr(ppp_fd, &tios) == 0)
2357 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2358 tios.c_cflag |= CS8 | CREAD;
2359 tios.c_iflag = IGNPAR | CLOCAL;
2362 if (tcsetattr(ppp_fd, TCSAFLUSH, &tios) < 0)
2364 syslog(LOG_WARNING, "couldn't set attributes on loopback: %m(%d)", errno);
2368 flags = fcntl(master_fd, F_GETFL);
2370 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2372 syslog(LOG_WARNING, "couldn't set master loopback to nonblock: %m(%d)", errno);
2375 flags = fcntl(ppp_fd, F_GETFL);
2377 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2379 syslog(LOG_WARNING, "couldn't set slave loopback to nonblock: %m(%d)", errno);
2382 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2384 syslog(LOG_ERR, "ioctl(TIOCSETD): %m(%d)", errno);
2388 * Find out which interface we were given.
2390 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2392 syslog(LOG_ERR, "ioctl(PPPIOCGUNIT): %m(%d)", errno);
2396 * Enable debug in the driver if requested.
2398 set_kdebugflag (kdebugflag);
2401 /********************************************************************
2403 * restore_loop - reattach the ppp unit to the loopback.
2405 * The kernel ppp driver automatically reattaches the ppp unit to
2406 * the loopback if the serial port is set to a line discipline other
2407 * than ppp, or if it detects a modem hangup. The former will happen
2408 * in disestablish_ppp if the latter hasn't already happened, so we
2409 * shouldn't need to do anything.
2411 * Just to be sure, set the real serial port to the normal discipline.
2417 if (ppp_fd != slave_fd)
2419 (void) ioctl(ppp_fd, TIOCSETD, &tty_disc);
2420 set_ppp_fd(slave_fd);
2424 /********************************************************************
2426 * sifnpmode - Set the mode for handling packets for a given NP.
2430 sifnpmode(u, proto, mode)
2437 npi.protocol = proto;
2439 if (ioctl(ppp_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0)
2441 if (! ok_error (errno))
2443 syslog(LOG_ERR, "ioctl(PPPIOCSNPMODE, %d, %d): %m(%d)",
2444 proto, mode, errno);
2445 syslog(LOG_ERR, "ppp_fd=%d slave_fd=%d\n", ppp_fd, slave_fd);
2453 /********************************************************************
2455 * sipxfaddr - Config the interface IPX networknumber
2458 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2465 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2467 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2470 if (! ok_error (errno))
2472 syslog (LOG_DEBUG, "socket(AF_IPX): %m(%d)", errno);
2478 memset (&ifr, '\0', sizeof (ifr));
2479 strcpy (ifr.ifr_name, ifname);
2481 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2482 sipx->sipx_family = AF_IPX;
2483 sipx->sipx_port = 0;
2484 sipx->sipx_network = htonl (network);
2485 sipx->sipx_type = IPX_FRAME_ETHERII;
2486 sipx->sipx_action = IPX_CRTITF;
2488 * Set the IPX device
2490 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0)
2493 if (errno != EEXIST)
2495 if (! ok_error (errno))
2498 "ioctl(SIOCAIFADDR, CRTITF): %m(%d)", errno);
2503 syslog (LOG_WARNING,
2504 "ioctl(SIOCAIFADDR, CRTITF): Address already exists");
2513 /********************************************************************
2515 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2516 * are removed and the device is no longer able to pass IPX
2520 int cipxfaddr (int unit)
2527 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2529 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2532 if (! ok_error (errno))
2534 syslog (LOG_DEBUG, "socket(AF_IPX): %m(%d)", errno);
2540 memset (&ifr, '\0', sizeof (ifr));
2541 strcpy (ifr.ifr_name, ifname);
2543 sipx->sipx_type = IPX_FRAME_ETHERII;
2544 sipx->sipx_action = IPX_DLTITF;
2545 sipx->sipx_family = AF_IPX;
2547 * Set the IPX device
2549 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0)
2551 if (! ok_error (errno))
2554 "ioctl(SIOCAIFADDR, IPX_DLTITF): %m(%d)", errno);
2565 * daemon - Detach us from controlling terminal session.
2568 daemon(nochdir, noclose)
2569 int nochdir, noclose;
2573 if ((pid = fork()) < 0)
2576 exit(0); /* parent dies */
2581 fclose(stdin); /* don't need stdin, stdout, stderr */
2589 * Use the hostname as part of the random number seed.
2598 for (p = hostname; *p != 0; ++p)
2603 /********************************************************************
2605 * sys_check_options - check the options that the user specified
2609 sys_check_options(void)
2612 struct stat stat_buf;
2614 * Disable the IPX protocol if the support is not present in the kernel.
2615 * If we disable it then ensure that IP support is enabled.
2617 while (ipxcp_protent.enabled_flag)
2619 if (path_to_procfs())
2621 strcat (route_buffer, "/net/ipx_interface");
2622 if (lstat (route_buffer, &stat_buf) >= 0)
2627 syslog (LOG_ERR, "IPX support is not present in the kernel\n");
2628 ipxcp_protent.enabled_flag = 0;
2629 ipcp_protent.enabled_flag = 1;
2633 if (demand && driver_is_old) {
2634 option_error("demand dialling is not supported by kernel driver version "
2635 "%d.%d.%d", driver_version, driver_modification,