2 * sys-linux.c - System-dependent procedures for setting up
3 * PPP interfaces on Linux systems
5 * Copyright (c) 1989 Carnegie Mellon University.
8 * Redistribution and use in source and binary forms are permitted
9 * provided that the above copyright notice and this paragraph are
10 * duplicated in all such forms and that any documentation,
11 * advertising materials, and other materials related to such
12 * distribution and use acknowledge that the software was developed
13 * by Carnegie Mellon University. The name of the
14 * University may not be used to endorse or promote products derived
15 * from this software without specific prior written permission.
16 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
18 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
21 #include <sys/ioctl.h>
22 #include <sys/types.h>
23 #include <sys/socket.h>
25 #include <sys/errno.h>
28 #include <sys/utsname.h>
44 /* This is in netdevice.h. However, this compile will fail miserably if
45 you attempt to include netdevice.h because it has so many references
46 to __memcpy functions which it should not attempt to do. So, since I
47 really don't use it, but it must be defined, define it now. */
50 #define MAX_ADDR_LEN 7
54 #include <asm/types.h> /* glibc 2 conflicts with linux/types.h */
56 #include <net/if_arp.h>
57 #include <net/route.h>
58 #include <netinet/if_ether.h>
60 #include <linux/types.h>
62 #include <linux/if_arp.h>
63 #include <linux/route.h>
64 #include <linux/if_ether.h>
66 #include <netinet/in.h>
67 #include <arpa/inet.h>
69 #include <linux/ppp_defs.h>
70 #include <linux/if_ppp.h>
75 #include "patchlevel.h"
79 #if __GLIBC__ >= 2 && \
80 !(defined(__powerpc__) && __GLIBC__ == 2 && __GLIBC_MINOR__ == 0)
81 #include <netipx/ipx.h>
83 #include <linux/ipx.h>
85 #endif /* IPX_CHANGE */
88 #include <sys/locks.h>
91 #ifndef RTF_DEFAULT /* Normally in <linux/route.h> from <net/route.h> */
95 /* We can get an EIO error on an ioctl if the modem has hung up */
96 #define ok_error(num) ((num)==EIO)
98 static int tty_disc = N_TTY; /* The TTY discipline */
99 static int ppp_disc = N_PPP; /* The PPP discpline */
100 static int initfdflags = -1; /* Initial file descriptor flags for fd */
101 static int ppp_fd = -1; /* fd which is set to PPP discipline */
102 static int sock_fd = -1; /* socket for doing interface ioctls */
103 static int slave_fd = -1;
104 static int master_fd = -1;
106 static fd_set in_fds; /* set of fds that wait_input waits for */
107 static int max_in_fd; /* highest fd set in in_fds */
109 static int has_proxy_arp = 0;
110 static int driver_version = 0;
111 static int driver_modification = 0;
112 static int driver_patch = 0;
113 static int driver_is_old = 0;
114 static int restore_term = 0; /* 1 => we've munged the terminal */
115 static struct termios inittermios; /* Initial TTY termios */
117 static char loop_name[20];
118 static unsigned char inbuf[512]; /* buffer for chars read from loopback */
120 static int if_is_up; /* Interface has been marked up */
121 static u_int32_t default_route_gateway; /* Gateway for default route added */
122 static u_int32_t proxy_arp_addr; /* Addr for proxy arp entry added */
123 static char proxy_arp_dev[16]; /* Device for proxy arp entry */
125 static char *lock_file;
127 static struct utsname utsname; /* for the kernel version */
128 static int kernel_version;
129 #define KVERSION(j,n,p) ((j)*1000000 + (n)*1000 + (p))
133 #define FLAGS_GOOD (IFF_UP | IFF_BROADCAST)
134 #define FLAGS_MASK (IFF_UP | IFF_BROADCAST | \
135 IFF_POINTOPOINT | IFF_LOOPBACK | IFF_NOARP)
137 /* Prototypes for procedures local to this file. */
138 static int get_flags (void);
139 static void set_flags (int flags);
140 static int translate_speed (int bps);
141 static int baud_rate_of (int speed);
142 static char *path_to_route (void);
143 static void close_route_table (void);
144 static int open_route_table (void);
145 static int read_route_table (struct rtentry *rt);
146 static int defaultroute_exists (struct rtentry *rt);
147 static int get_ether_addr (u_int32_t ipaddr, struct sockaddr *hwaddr,
148 char *name, int namelen);
149 static void decode_version (char *buf, int *version, int *mod, int *patch);
150 static int set_kdebugflag(int level);
151 static int ppp_registered(void);
153 extern u_char inpacket_buf[]; /* borrowed from main.c */
156 * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
160 #define SET_SA_FAMILY(addr, family) \
161 memset ((char *) &(addr), '\0', sizeof(addr)); \
162 addr.sa_family = (family);
165 * Determine if the PPP connection should still be present.
171 #define LOCK_PREFIX "/var/lock/LCK.."
174 static void set_ppp_fd (int new_fd)
176 SYSDEBUG ((LOG_DEBUG, "setting ppp_fd to %d\n", new_fd));
180 static int still_ppp(void)
182 if (!hungup || ppp_fd == slave_fd)
185 set_ppp_fd(slave_fd);
191 /********************************************************************
193 * Functions to read and set the flags value in the device driver
196 static int get_flags (void)
200 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &flags) < 0) {
201 if ( ok_error (errno) )
204 fatal("ioctl(PPPIOCGFLAGS): %m");
207 SYSDEBUG ((LOG_DEBUG, "get flags = %x\n", flags));
211 /********************************************************************/
213 static void set_flags (int flags)
215 SYSDEBUG ((LOG_DEBUG, "set flags = %x\n", flags));
217 if (ioctl(ppp_fd, PPPIOCSFLAGS, (caddr_t) &flags) < 0) {
218 if (! ok_error (errno) )
219 fatal("ioctl(PPPIOCSFLAGS, %x): %m(%d)", flags, errno);
223 /********************************************************************
225 * sys_init - System-dependent initialization.
230 int osmaj, osmin, ospatch;
232 openlog("pppd", LOG_PID | LOG_NDELAY, LOG_PPP);
233 setlogmask(LOG_UPTO(LOG_INFO));
235 setlogmask(LOG_UPTO(LOG_DEBUG));
237 /* Get an internet socket for doing socket ioctls. */
238 sock_fd = socket(AF_INET, SOCK_DGRAM, 0);
240 if ( ! ok_error ( errno ))
241 fatal("Couldn't create IP socket: %m(%d)", errno);
248 osmaj = osmin = ospatch = 0;
249 sscanf(utsname.release, "%d.%d.%d", &osmaj, &osmin, &ospatch);
250 kernel_version = KVERSION(osmaj, osmin, ospatch);
253 /********************************************************************
255 * sys_cleanup - restore any system state we modified before exiting:
256 * mark the interface down, delete default route and/or proxy arp entry.
257 * This shouldn't call die() because it's called from die().
260 void sys_cleanup(void)
263 * Take down the device
268 * Delete any routes through the device.
270 if (default_route_gateway != 0)
271 cifdefaultroute(0, 0, default_route_gateway);
274 cifproxyarp(0, proxy_arp_addr);
277 /********************************************************************
279 * sys_close - Clean up in a child process before execing.
289 /********************************************************************
291 * set_kdebugflag - Define the debugging level for the kernel
294 static int set_kdebugflag (int requested_level)
296 if (ioctl(ppp_fd, PPPIOCSDEBUG, &requested_level) < 0) {
297 if ( ! ok_error (errno) )
298 error("ioctl(PPPIOCSDEBUG): %m");
301 SYSDEBUG ((LOG_INFO, "set kernel debugging level to %d",
306 /********************************************************************
308 * establish_ppp - Turn the serial port into a ppp interface.
311 int establish_ppp (int tty_fd)
315 * The current PPP device will be the tty file.
319 * Ensure that the tty device is in exclusive mode.
321 if (ioctl(tty_fd, TIOCEXCL, 0) < 0) {
322 if ( ! ok_error ( errno ))
323 warn("ioctl(TIOCEXCL): %m");
326 * Demand mode - prime the old ppp device to relinquish the unit.
328 if (demand && ioctl(slave_fd, PPPIOCXFERUNIT, 0) < 0)
329 fatal("ioctl(transfer ppp unit): %m(%d)", errno);
331 * Set the current tty to the PPP discpline
333 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0) {
334 if ( ! ok_error (errno) )
335 fatal("ioctl(TIOCSETD): %m(%d)", errno);
338 * Find out which interface we were given.
340 if (ioctl(ppp_fd, PPPIOCGUNIT, &x) < 0) {
341 if ( ! ok_error (errno))
342 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
345 * Check that we got the same unit again.
349 fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit, x);
354 * Enable debug in the driver if requested.
357 set_kdebugflag (kdebugflag);
359 set_flags (get_flags() & ~(SC_RCV_B7_0 | SC_RCV_B7_1 |
360 SC_RCV_EVNP | SC_RCV_ODDP));
362 SYSDEBUG ((LOG_NOTICE, "Using version %d.%d.%d of PPP driver",
363 driver_version, driver_modification, driver_patch));
365 * Fetch the initial file flags and reset blocking mode on the file.
367 initfdflags = fcntl(ppp_fd, F_GETFL);
369 if (initfdflags == -1 ||
370 fcntl(ppp_fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
371 if ( ! ok_error (errno))
372 warn("Couldn't set device to non-blocking mode: %m");
378 /********************************************************************
380 * disestablish_ppp - Restore the serial port to normal operation.
381 * This shouldn't call die() because it's called from die().
384 void disestablish_ppp(int tty_fd)
387 * Attempt to restore the previous tty settings
391 * Restore the previous line discipline
393 if (ioctl(tty_fd, TIOCSETD, &tty_disc) < 0) {
394 if ( ! ok_error (errno))
395 error("ioctl(TIOCSETD, N_TTY): %m");
398 if (ioctl(tty_fd, TIOCNXCL, 0) < 0) {
399 if ( ! ok_error (errno))
400 warn("ioctl(TIOCNXCL): %m(%d)", errno);
403 /* Reset non-blocking mode on fd. */
404 if (initfdflags != -1 && fcntl(tty_fd, F_SETFL, initfdflags) < 0) {
405 if ( ! ok_error (errno))
406 warn("Couldn't restore device fd flags: %m");
412 /********************************************************************
414 * clean_check - Fetch the flags for the device and generate
415 * appropriate error messages.
417 void clean_check(void)
423 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
425 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
427 case SC_RCV_B7_0 | SC_RCV_EVNP:
428 case SC_RCV_B7_0 | SC_RCV_ODDP:
429 case SC_RCV_B7_0 | SC_RCV_ODDP | SC_RCV_EVNP:
430 s = "all had bit 7 set to 1";
434 case SC_RCV_B7_1 | SC_RCV_EVNP:
435 case SC_RCV_B7_1 | SC_RCV_ODDP:
436 case SC_RCV_B7_1 | SC_RCV_ODDP | SC_RCV_EVNP:
437 s = "all had bit 7 set to 0";
441 s = "all had odd parity";
445 s = "all had even parity";
450 warn("Receive serial link is not 8-bit clean:");
451 warn("Problem: %s", s);
459 * List of valid speeds.
463 int speed_int, speed_val;
540 /********************************************************************
542 * Translate from bits/second to a speed_t.
545 static int translate_speed (int bps)
547 struct speed *speedp;
550 for (speedp = speeds; speedp->speed_int; speedp++) {
551 if (bps == speedp->speed_int)
552 return speedp->speed_val;
554 warn("speed %d not supported", bps);
559 /********************************************************************
561 * Translate from a speed_t to bits/second.
564 static int baud_rate_of (int speed)
566 struct speed *speedp;
569 for (speedp = speeds; speedp->speed_int; speedp++) {
570 if (speed == speedp->speed_val)
571 return speedp->speed_int;
577 /********************************************************************
579 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
580 * at the requested speed, etc. If `local' is true, set CLOCAL
581 * regardless of whether the modem option was specified.
584 void set_up_tty(int tty_fd, int local)
590 if (tcgetattr(tty_fd, &tios) < 0) {
591 if (!ok_error(errno))
592 fatal("tcgetattr: %m(%d)", errno);
599 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
600 tios.c_cflag |= CS8 | CREAD | HUPCL;
602 tios.c_iflag = IGNBRK | IGNPAR;
606 tios.c_cc[VTIME] = 0;
609 tios.c_cflag ^= (CLOCAL | HUPCL);
613 tios.c_cflag |= CRTSCTS;
617 tios.c_iflag |= IXON | IXOFF;
618 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
619 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
623 tios.c_cflag &= ~CRTSCTS;
630 speed = translate_speed(inspeed);
632 cfsetospeed (&tios, speed);
633 cfsetispeed (&tios, speed);
636 * We can't proceed if the serial port speed is B0,
637 * since that implies that the serial port is disabled.
640 speed = cfgetospeed(&tios);
642 fatal("Baud rate for %s is 0; need explicit baud rate", devnam);
645 if (tcsetattr(tty_fd, TCSAFLUSH, &tios) < 0)
646 if (!ok_error(errno))
647 fatal("tcsetattr: %m");
649 baud_rate = baud_rate_of(speed);
653 /********************************************************************
655 * setdtr - control the DTR line on the serial port.
656 * This is called from die(), so it shouldn't call die().
659 void setdtr (int tty_fd, int on)
661 int modembits = TIOCM_DTR;
663 ioctl(tty_fd, (on ? TIOCMBIS : TIOCMBIC), &modembits);
666 /********************************************************************
668 * restore_tty - restore the terminal to the saved settings.
671 void restore_tty (int tty_fd)
676 * Turn off echoing, because otherwise we can get into
677 * a loop with the tty and the modem echoing to each other.
678 * We presume we are the sole user of this tty device, so
679 * when we close it, it will revert to its defaults anyway.
682 inittermios.c_lflag &= ~(ECHO | ECHONL);
684 if (tcsetattr(tty_fd, TCSAFLUSH, &inittermios) < 0) {
685 if (! ok_error (errno))
686 warn("tcsetattr: %m");
691 /********************************************************************
693 * output - Output PPP packet.
696 void output (int unit, unsigned char *p, int len)
699 dbglog("sent %P", p, len);
701 if (write(ppp_fd, p, len) < 0) {
702 if (errno == EWOULDBLOCK || errno == ENOBUFS
703 || errno == ENXIO || errno == EIO || errno == EINTR)
704 warn("write: warning: %m (%d)", errno);
706 error("write: %m (%d)", errno);
710 /********************************************************************
712 * wait_input - wait until there is data available,
713 * for the length of time specified by *timo (indefinite
717 void wait_input(struct timeval *timo)
723 n = select(max_in_fd + 1, &ready, NULL, &ready, timo);
724 if (n < 0 && errno != EINTR)
725 fatal("select: %m(%d)", errno);
729 * add_fd - add an fd to the set that wait_input waits for.
739 * remove_fd - remove an fd from the set that wait_input waits for.
741 void remove_fd(int fd)
747 /********************************************************************
749 * wait_loop_output - wait until there is data available on the
750 * loopback, for the length of time specified by *timo (indefinite
753 void wait_loop_output(timo)
754 struct timeval *timo;
760 FD_SET(master_fd, &ready);
761 n = select(master_fd + 1, &ready, NULL, &ready, timo);
762 if (n < 0 && errno != EINTR)
763 fatal("select: %m(%d)", errno);
766 /********************************************************************
768 * wait_time - wait for a given length of time or until a
769 * signal is received.
773 struct timeval *timo;
777 n = select(0, NULL, NULL, NULL, timo);
778 if (n < 0 && errno != EINTR)
779 fatal("select: %m(%d)", errno);
783 /********************************************************************
785 * read_packet - get a PPP packet from the serial device.
788 int read_packet (unsigned char *buf)
792 len = read(ppp_fd, buf, PPP_MTU + PPP_HDRLEN);
794 if (errno == EWOULDBLOCK || errno == EIO)
796 fatal("read: %m(%d)", errno);
801 /********************************************************************
803 * get_loop_output - get outgoing packets from the ppp device,
804 * and detect when we want to bring the real link up.
805 * Return value is 1 if we need to bring up the link, 0 otherwise.
808 get_loop_output(void)
811 int n = read(master_fd, inbuf, sizeof(inbuf));
814 if (loop_chars(inbuf, n))
816 n = read(master_fd, inbuf, sizeof(inbuf));
820 fatal("eof on loopback");
822 if (errno != EWOULDBLOCK)
823 fatal("read from loopback: %m(%d)", errno);
828 /********************************************************************
830 * ppp_send_config - configure the transmit characteristics of
834 void ppp_send_config (int unit,int mtu,u_int32_t asyncmap,int pcomp,int accomp)
839 SYSDEBUG ((LOG_DEBUG, "send_config: mtu = %d\n", mtu));
841 * Ensure that the link is still up.
846 * Set the MTU and other parameters for the ppp device
848 memset (&ifr, '\0', sizeof (ifr));
849 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
852 if (ioctl(sock_fd, SIOCSIFMTU, (caddr_t) &ifr) < 0)
853 fatal("ioctl(SIOCSIFMTU): %m(%d)", errno);
855 SYSDEBUG ((LOG_DEBUG, "send_config: asyncmap = %lx\n", asyncmap));
856 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
857 if (!ok_error(errno))
858 fatal("ioctl(PPPIOCSASYNCMAP): %m(%d)", errno);
863 x = pcomp ? x | SC_COMP_PROT : x & ~SC_COMP_PROT;
864 x = accomp ? x | SC_COMP_AC : x & ~SC_COMP_AC;
868 /********************************************************************
870 * ppp_set_xaccm - set the extended transmit ACCM for the interface.
873 void ppp_set_xaccm (int unit, ext_accm accm)
875 SYSDEBUG ((LOG_DEBUG, "set_xaccm: %08lx %08lx %08lx %08lx\n",
876 accm[0], accm[1], accm[2], accm[3]));
878 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY) {
879 if ( ! ok_error (errno))
880 warn("ioctl(set extended ACCM): %m(%d)", errno);
884 /********************************************************************
886 * ppp_recv_config - configure the receive-side characteristics of
890 void ppp_recv_config (int unit,int mru,u_int32_t asyncmap,int pcomp,int accomp)
894 SYSDEBUG ((LOG_DEBUG, "recv_config: mru = %d\n", mru));
896 * If we were called because the link has gone down then there is nothing
897 * which may be done. Just return without incident.
902 * Set the receiver parameters
904 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
905 if ( ! ok_error (errno))
906 error("ioctl(PPPIOCSMRU): %m(%d)", errno);
909 SYSDEBUG ((LOG_DEBUG, "recv_config: asyncmap = %lx\n", asyncmap));
910 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
911 if (!ok_error(errno))
912 error("ioctl(PPPIOCSRASYNCMAP): %m(%d)", errno);
916 x = !accomp? x | SC_REJ_COMP_AC: x &~ SC_REJ_COMP_AC;
920 /********************************************************************
922 * ccp_test - ask kernel whether a given compression method
923 * is acceptable for use.
926 int ccp_test (int unit, u_char *opt_ptr, int opt_len, int for_transmit)
928 struct ppp_option_data data;
930 memset (&data, '\0', sizeof (data));
932 data.length = opt_len;
933 data.transmit = for_transmit;
935 if (ioctl(ppp_fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
938 return (errno == ENOBUFS)? 0: -1;
941 /********************************************************************
943 * ccp_flags_set - inform kernel about the current state of CCP.
946 void ccp_flags_set (int unit, int isopen, int isup)
950 x = isopen? x | SC_CCP_OPEN : x &~ SC_CCP_OPEN;
951 x = isup? x | SC_CCP_UP : x &~ SC_CCP_UP;
956 /********************************************************************
958 * get_idle_time - return how long the link has been idle.
965 return ioctl(ppp_fd, PPPIOCGIDLE, ip) >= 0;
968 /********************************************************************
970 * get_ppp_stats - return statistics for the link.
973 get_ppp_stats(u, stats)
975 struct pppd_stats *stats;
977 struct ifpppstatsreq req;
979 memset (&req, 0, sizeof (req));
981 req.stats_ptr = (caddr_t) &req.stats;
982 strlcpy(req.ifr__name, ifname, sizeof(req.ifr__name));
983 if (ioctl(sock_fd, SIOCGPPPSTATS, &req) < 0) {
984 error("Couldn't get PPP statistics: %m");
987 stats->bytes_in = req.stats.p.ppp_ibytes;
988 stats->bytes_out = req.stats.p.ppp_obytes;
992 /********************************************************************
994 * ccp_fatal_error - returns 1 if decompression was disabled as a
995 * result of an error detected after decompression of a packet,
996 * 0 otherwise. This is necessary because of patent nonsense.
999 int ccp_fatal_error (int unit)
1001 int x = get_flags();
1003 return x & SC_DC_FERROR;
1007 * path_to_route - determine the path to the proc file system data
1009 #define ROUTE_MAX_COLS 12
1010 FILE *route_fd = (FILE *) 0;
1011 static char route_buffer [512];
1012 static int route_dev_col, route_dest_col, route_gw_col;
1013 static int route_flags_col, route_mask_col;
1014 static int route_num_cols;
1016 static char *path_to_route (void);
1017 static int open_route_table (void);
1018 static void close_route_table (void);
1019 static int read_route_table (struct rtentry *rt);
1021 /********************************************************************
1023 * path_to_procfs - find the path to the proc file system mount point
1026 static int path_to_procfs (void)
1028 struct mntent *mntent;
1031 fp = fopen(MOUNTED, "r");
1033 /* Default the mount location of /proc */
1034 strlcpy (route_buffer, "/proc", sizeof (route_buffer));
1038 while ((mntent = getmntent(fp)) != NULL) {
1039 if (strcmp(mntent->mnt_type, MNTTYPE_IGNORE) == 0)
1041 if (strcmp(mntent->mnt_type, "proc") == 0)
1048 strlcpy(route_buffer, mntent->mnt_dir, sizeof (route_buffer));
1052 /********************************************************************
1054 * path_to_route - find the path to the route tables in the proc file system
1057 static char *path_to_route (void)
1059 if (!path_to_procfs()) {
1060 error("proc file system not mounted");
1063 strlcat (route_buffer, "/net/route", sizeof(route_buffer));
1064 return (route_buffer);
1067 /********************************************************************
1069 * close_route_table - close the interface to the route table
1072 static void close_route_table (void)
1074 if (route_fd != (FILE *) 0) {
1076 route_fd = (FILE *) 0;
1080 /********************************************************************
1082 * open_route_table - open the interface to the route table
1084 static char route_delims[] = " \t\n";
1086 static int open_route_table (void)
1090 close_route_table();
1092 path = path_to_route();
1096 route_fd = fopen (path, "r");
1097 if (route_fd == NULL) {
1098 error("can't open %s: %m (%d)", path, errno);
1102 route_dev_col = 0; /* default to usual columns */
1105 route_flags_col = 3;
1109 /* parse header line */
1110 if (fgets(route_buffer, sizeof(route_buffer), route_fd) != 0) {
1111 char *p = route_buffer, *q;
1113 for (col = 0; col < ROUTE_MAX_COLS; ++col) {
1115 if ((q = strtok(p, route_delims)) == 0)
1117 if (strcasecmp(q, "iface") == 0)
1118 route_dev_col = col;
1119 else if (strcasecmp(q, "destination") == 0)
1120 route_dest_col = col;
1121 else if (strcasecmp(q, "gateway") == 0)
1123 else if (strcasecmp(q, "flags") == 0)
1124 route_flags_col = col;
1125 else if (strcasecmp(q, "mask") == 0)
1126 route_mask_col = col;
1129 if (used && col >= route_num_cols)
1130 route_num_cols = col + 1;
1138 /********************************************************************
1140 * read_route_table - read the next entry from the route table
1143 static int read_route_table(struct rtentry *rt)
1145 char *cols[ROUTE_MAX_COLS], *p;
1148 memset (rt, '\0', sizeof (struct rtentry));
1150 if (fgets (route_buffer, sizeof (route_buffer), route_fd) == (char *) 0)
1154 for (col = 0; col < route_num_cols; ++col) {
1155 cols[col] = strtok(p, route_delims);
1156 if (cols[col] == NULL)
1157 return 0; /* didn't get enough columns */
1160 ((struct sockaddr_in *) &rt->rt_dst)->sin_addr.s_addr =
1161 strtoul(cols[route_dest_col], NULL, 16);
1163 ((struct sockaddr_in *) &rt->rt_gateway)->sin_addr.s_addr =
1164 strtoul(cols[route_gw_col], NULL, 16);
1166 ((struct sockaddr_in *) &rt->rt_genmask)->sin_addr.s_addr =
1167 strtoul(cols[route_mask_col], NULL, 16);
1169 rt->rt_flags = (short) strtoul(cols[route_flags_col], NULL, 16);
1170 rt->rt_dev = cols[route_dev_col];
1175 /********************************************************************
1177 * defaultroute_exists - determine if there is a default route
1180 static int defaultroute_exists (struct rtentry *rt)
1184 if (!open_route_table())
1187 while (read_route_table(rt) != 0) {
1188 if ((rt->rt_flags & RTF_UP) == 0)
1191 if (((struct sockaddr_in *) (&rt->rt_dst))->sin_addr.s_addr == 0L) {
1197 close_route_table();
1202 * have_route_to - determine if the system has any route to
1203 * a given IP address. `addr' is in network byte order.
1204 * Return value is 1 if yes, 0 if no, -1 if don't know.
1205 * For demand mode to work properly, we have to ignore routes
1206 * through our own interface.
1208 int have_route_to(u_int32_t addr)
1213 if (!open_route_table())
1214 return -1; /* don't know */
1216 while (read_route_table(&rt)) {
1217 if ((rt.rt_flags & RTF_UP) == 0 || strcmp(rt.rt_dev, ifname) == 0)
1219 if ((addr & ((struct sockaddr_in *)&rt.rt_genmask)->sin_addr.s_addr)
1220 == ((struct sockaddr_in *)&rt.rt_dst)->sin_addr.s_addr) {
1226 close_route_table();
1230 /********************************************************************
1232 * sifdefaultroute - assign a default route through the address given.
1235 int sifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1239 if (defaultroute_exists(&rt) && strcmp(rt.rt_dev, ifname) != 0) {
1240 struct in_addr old_gateway =
1241 ((struct sockaddr_in *) (&rt.rt_gateway))-> sin_addr;
1243 if (old_gateway.s_addr != gateway)
1244 error("not replacing existing default route to %s [%I]",
1245 rt.rt_dev, old_gateway);
1249 memset (&rt, '\0', sizeof (rt));
1250 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1251 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1253 if (kernel_version > KVERSION(2,1,0)) {
1254 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1255 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = 0L;
1258 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = gateway;
1260 rt.rt_flags = RTF_UP | RTF_GATEWAY | RTF_DEFAULT;
1261 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
1262 if ( ! ok_error ( errno ))
1263 error("default route ioctl(SIOCADDRT): %m(%d)", errno);
1267 default_route_gateway = gateway;
1271 /********************************************************************
1273 * cifdefaultroute - delete a default route through the address given.
1276 int cifdefaultroute (int unit, u_int32_t ouraddr, u_int32_t gateway)
1280 default_route_gateway = 0;
1282 memset (&rt, '\0', sizeof (rt));
1283 SET_SA_FAMILY (rt.rt_dst, AF_INET);
1284 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
1286 if (kernel_version > KVERSION(2,1,0)) {
1287 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
1288 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = 0L;
1291 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = gateway;
1293 rt.rt_flags = RTF_UP | RTF_GATEWAY | RTF_DEFAULT;
1294 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
1296 if ( ! ok_error ( errno ))
1297 error("default route ioctl(SIOCDELRT): %m (%d)", errno);
1305 /********************************************************************
1307 * sifproxyarp - Make a proxy ARP entry for the peer.
1310 int sifproxyarp (int unit, u_int32_t his_adr)
1312 struct arpreq arpreq;
1314 if (has_proxy_arp == 0) {
1315 memset (&arpreq, '\0', sizeof(arpreq));
1317 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1318 ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = his_adr;
1319 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1321 * Get the hardware address of an interface on the same subnet
1322 * as our local address.
1324 if (!get_ether_addr(his_adr, &arpreq.arp_ha, proxy_arp_dev,
1325 sizeof(proxy_arp_dev))) {
1326 error("Cannot determine ethernet address for proxy ARP");
1329 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1331 if (ioctl(sock_fd, SIOCSARP, (caddr_t)&arpreq) < 0) {
1332 if ( ! ok_error ( errno ))
1333 error("ioctl(SIOCSARP): %m(%d)", errno);
1336 proxy_arp_addr = his_adr;
1343 /********************************************************************
1345 * cifproxyarp - Delete the proxy ARP entry for the peer.
1348 int cifproxyarp (int unit, u_int32_t his_adr)
1350 struct arpreq arpreq;
1352 if (has_proxy_arp) {
1354 memset (&arpreq, '\0', sizeof(arpreq));
1355 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1356 ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = his_adr;
1357 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1358 strlcpy(arpreq.arp_dev, proxy_arp_dev, sizeof(arpreq.arp_dev));
1360 if (ioctl(sock_fd, SIOCDARP, (caddr_t)&arpreq) < 0) {
1361 if ( ! ok_error ( errno ))
1362 warn("ioctl(SIOCDARP): %m(%d)", errno);
1369 /********************************************************************
1371 * get_ether_addr - get the hardware address of an interface on the
1372 * the same subnet as ipaddr.
1375 static int get_ether_addr (u_int32_t ipaddr,
1376 struct sockaddr *hwaddr,
1377 char *name, int namelen)
1379 struct ifreq *ifr, *ifend;
1380 u_int32_t ina, mask;
1383 struct ifreq ifs[MAX_IFS];
1385 ifc.ifc_len = sizeof(ifs);
1387 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1388 if ( ! ok_error ( errno ))
1389 error("ioctl(SIOCGIFCONF): %m(%d)", errno);
1393 SYSDEBUG ((LOG_DEBUG, "proxy arp: scanning %d interfaces for IP %s",
1394 ifc.ifc_len / sizeof(struct ifreq), ip_ntoa(ipaddr)));
1396 * Scan through looking for an interface with an Internet
1397 * address on the same subnet as `ipaddr'.
1399 ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq));
1400 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1401 if (ifr->ifr_addr.sa_family == AF_INET) {
1402 ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
1403 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1404 SYSDEBUG ((LOG_DEBUG, "proxy arp: examining interface %s",
1407 * Check that the interface is up, and not point-to-point
1410 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1413 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1416 * Get its netmask and check that it's on the right subnet.
1418 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1421 mask = ((struct sockaddr_in *) &ifreq.ifr_addr)->sin_addr.s_addr;
1422 SYSDEBUG ((LOG_DEBUG, "proxy arp: interface addr %s mask %lx",
1423 ip_ntoa(ina), ntohl(mask)));
1425 if (((ipaddr ^ ina) & mask) != 0)
1434 strlcpy(name, ifreq.ifr_name, namelen);
1435 info("found interface %s for proxy arp", name);
1437 * Now get the hardware address.
1439 memset (&ifreq.ifr_hwaddr, 0, sizeof (struct sockaddr));
1440 if (ioctl (sock_fd, SIOCGIFHWADDR, &ifreq) < 0) {
1441 error("SIOCGIFHWADDR(%s): %m(%d)", ifreq.ifr_name, errno);
1447 sizeof (struct sockaddr));
1449 SYSDEBUG ((LOG_DEBUG,
1450 "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1451 (int) ((unsigned char *) &hwaddr->sa_data)[0],
1452 (int) ((unsigned char *) &hwaddr->sa_data)[1],
1453 (int) ((unsigned char *) &hwaddr->sa_data)[2],
1454 (int) ((unsigned char *) &hwaddr->sa_data)[3],
1455 (int) ((unsigned char *) &hwaddr->sa_data)[4],
1456 (int) ((unsigned char *) &hwaddr->sa_data)[5],
1457 (int) ((unsigned char *) &hwaddr->sa_data)[6],
1458 (int) ((unsigned char *) &hwaddr->sa_data)[7]));
1462 /********************************************************************
1464 * Return user specified netmask, modified by any mask we might determine
1465 * for address `addr' (in network byte order).
1466 * Here we scan through the system's list of interfaces, looking for
1467 * any non-point-to-point interfaces which might appear to be on the same
1468 * network as `addr'. If we find any, we OR in their netmask to the
1469 * user-specified netmask.
1472 u_int32_t GetMask (u_int32_t addr)
1474 u_int32_t mask, nmask, ina;
1475 struct ifreq *ifr, *ifend, ifreq;
1477 struct ifreq ifs[MAX_IFS];
1481 if (IN_CLASSA(addr)) /* determine network mask for address class */
1482 nmask = IN_CLASSA_NET;
1483 else if (IN_CLASSB(addr))
1484 nmask = IN_CLASSB_NET;
1486 nmask = IN_CLASSC_NET;
1488 /* class D nets are disallowed by bad_ip_adrs */
1489 mask = netmask | htonl(nmask);
1491 * Scan through the system's network interfaces.
1493 ifc.ifc_len = sizeof(ifs);
1495 if (ioctl(sock_fd, SIOCGIFCONF, &ifc) < 0) {
1496 if ( ! ok_error ( errno ))
1497 warn("ioctl(SIOCGIFCONF): %m(%d)", errno);
1501 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1502 for (ifr = ifc.ifc_req; ifr < ifend; ifr++) {
1504 * Check the interface's internet address.
1506 if (ifr->ifr_addr.sa_family != AF_INET)
1508 ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
1509 if (((ntohl(ina) ^ addr) & nmask) != 0)
1512 * Check that the interface is up, and not point-to-point nor loopback.
1514 strlcpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1515 if (ioctl(sock_fd, SIOCGIFFLAGS, &ifreq) < 0)
1518 if (((ifreq.ifr_flags ^ FLAGS_GOOD) & FLAGS_MASK) != 0)
1521 * Get its netmask and OR it into our mask.
1523 if (ioctl(sock_fd, SIOCGIFNETMASK, &ifreq) < 0)
1525 mask |= ((struct sockaddr_in *)&ifreq.ifr_addr)->sin_addr.s_addr;
1531 /********************************************************************
1533 * Internal routine to decode the version.modification.patch level
1536 static void decode_version (char *buf, int *version,
1537 int *modification, int *patch)
1539 *version = (int) strtoul (buf, &buf, 10);
1545 *modification = (int) strtoul (buf, &buf, 10);
1548 *patch = (int) strtoul (buf, &buf, 10);
1559 /********************************************************************
1561 * Procedure to determine if the PPP line discipline is registered.
1565 ppp_registered(void)
1571 local_fd = open(devnam, O_NONBLOCK | O_RDWR, 0);
1573 error("Failed to open %s: %m(%d)", devnam, errno);
1577 initfdflags = fcntl(local_fd, F_GETFL);
1578 if (initfdflags == -1) {
1579 error("Couldn't get device fd flags: %m(%d)", errno);
1584 initfdflags &= ~O_NONBLOCK;
1585 fcntl(local_fd, F_SETFL, initfdflags);
1587 * Read the initial line dicipline and try to put the device into the
1590 if (ioctl(local_fd, TIOCGETD, &init_disc) < 0) {
1591 error("ioctl(TIOCGETD): %m(%d)", errno);
1596 if (ioctl(local_fd, TIOCSETD, &ppp_disc) < 0) {
1597 error("ioctl(TIOCSETD): %m(%d)", errno);
1602 if (ioctl(local_fd, TIOCSETD, &init_disc) < 0) {
1603 error("ioctl(TIOCSETD): %m(%d)", errno);
1612 /********************************************************************
1614 * ppp_available - check whether the system has any ppp interfaces
1615 * (in fact we check whether we can do an ioctl on ppp0).
1618 int ppp_available(void)
1623 int my_version, my_modification, my_patch;
1624 extern char *no_ppp_msg;
1626 * Open a socket for doing the ioctl operations.
1628 s = socket(AF_INET, SOCK_DGRAM, 0);
1632 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1633 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1635 * If the device did not exist then attempt to create one by putting the
1636 * current tty into the PPP discipline. If this works then obtain the
1637 * flags for the device again.
1640 if (ppp_registered()) {
1641 strlcpy (ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
1642 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
1646 * Ensure that the hardware address is for PPP and not something else
1649 ok = ioctl (s, SIOCGIFHWADDR, (caddr_t) &ifr) >= 0;
1651 if (ok && ((ifr.ifr_hwaddr.sa_family & ~0xFF) != ARPHRD_PPP))
1656 "This system lacks kernel support for PPP. This could be because\n"
1657 "the PPP kernel module is not loaded, or because the kernel is\n"
1658 "not configured for PPP. See the README.linux file in the\n"
1659 "ppp-2.3.6 distribution.\n";
1662 * This is the PPP device. Validate the version of the driver at this
1663 * point to ensure that this program will work with the driver.
1666 char abBuffer [1024];
1668 ifr.ifr_data = abBuffer;
1669 size = ioctl (s, SIOCGPPPVER, (caddr_t) &ifr);
1671 error("Couldn't read driver version: %m");
1673 no_ppp_msg = "Sorry, couldn't verify kernel driver version\n";
1676 decode_version(abBuffer,
1678 &driver_modification,
1681 * Validate the version of the driver against the version that we used.
1683 decode_version(VERSION,
1688 /* The version numbers must match */
1689 if (driver_version != my_version)
1692 /* The modification levels must be legal */
1693 if (driver_modification < 3) {
1694 if (driver_modification >= 2) {
1695 /* we can cope with 2.2.0 and above */
1704 slprintf(route_buffer, sizeof(route_buffer),
1705 "Sorry - PPP driver version %d.%d.%d is out of date\n",
1706 driver_version, driver_modification, driver_patch);
1708 no_ppp_msg = route_buffer;
1715 /********************************************************************
1717 * Update the wtmp file with the appropriate user name and tty device.
1720 void logwtmp (const char *line, const char *name, const char *host)
1723 struct utmp ut, *utp;
1724 pid_t mypid = getpid();
1726 * Update the signon database for users.
1727 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
1729 utmpname(_PATH_UTMP);
1731 while ((utp = getutent()) && (utp->ut_pid != mypid))
1734 /* Is this call really necessary? There is another one after the 'put' */
1738 memcpy(&ut, utp, sizeof(ut));
1740 /* some gettys/telnetds don't initialize utmp... */
1741 memset(&ut, 0, sizeof(ut));
1743 if (ut.ut_id[0] == 0)
1744 strlcpy(ut.ut_id, line + 3, sizeof(ut.ut_id));
1746 strlcpy(ut.ut_user, name, sizeof(ut.ut_user));
1747 strlcpy(ut.ut_line, line, sizeof(ut.ut_line));
1751 ut.ut_type = USER_PROCESS;
1754 /* Insert the host name if one is supplied */
1756 strlcpy (ut.ut_host, host, sizeof(ut.ut_host));
1758 /* Insert the IP address of the remote system if IP is enabled */
1759 if (ipcp_protent.enabled_flag && ipcp_hisoptions[0].neg_addr)
1760 memcpy(&ut.ut_addr, (char *) &ipcp_hisoptions[0].hisaddr,
1761 sizeof(ut.ut_addr));
1763 /* CL: Makes sure that the logout works */
1764 if (*host == 0 && *name==0)
1770 * Update the wtmp file.
1772 wtmp = open(_PATH_WTMP, O_APPEND|O_WRONLY);
1774 flock(wtmp, LOCK_EX);
1776 /* we really should check for error on the write for a full disk! */
1777 write (wtmp, (char *)&ut, sizeof(ut));
1780 flock(wtmp, LOCK_UN);
1784 /********************************************************************
1785 * Code for locking/unlocking the serial device.
1786 * This code is derived from chat.c.
1790 * lock - create a lock file for the named device
1793 int lock (char *dev)
1797 lock_file = strdup(dev);
1798 if (lock_file == NULL)
1799 novm("lock file name");
1800 result = mklock (dev, (void *) 0);
1803 notice("Device %s is locked by pid %d", dev, result);
1810 error("Can't create lock file %s", lock_file);
1818 char hdb_lock_buffer[12];
1824 p = strrchr(dev, '/');
1828 l = strlen(LOCK_PREFIX) + strlen(dev) + 1;
1829 lock_file = malloc(l);
1830 if (lock_file == NULL)
1831 novm("lock file name");
1833 slprintf(lock_file, l, "%s%s", LOCK_PREFIX, dev);
1835 * Attempt to create the lock file at this point.
1838 fd = open(lock_file, O_EXCL | O_CREAT | O_RDWR, 0644);
1842 slprintf(hdb_lock_buffer, sizeof(hdb_lock_buffer), "%010d\n", pid);
1843 write (fd, hdb_lock_buffer, 11);
1845 write(fd, &pid, sizeof (pid));
1851 * If the file exists then check to see if the pid is stale
1853 if (errno == EEXIST) {
1854 fd = open(lock_file, O_RDONLY, 0);
1856 if (errno == ENOENT) /* This is just a timing problem. */
1861 /* Read the lock file to find out who has the device locked */
1862 n = read (fd, hdb_lock_buffer, 11);
1865 error("Can't read pid from lock file %s", lock_file);
1869 /* See the process still exists. */
1872 hdb_lock_buffer[n] = '\0';
1873 sscanf (hdb_lock_buffer, " %d", &pid);
1875 pid = ((int *) hdb_lock_buffer)[0];
1877 if (pid == 0 || pid == getpid()
1878 || (kill(pid, 0) == -1 && errno == ESRCH))
1882 /* If the process does not exist then try to remove the lock */
1883 if (n == 0 && unlink (lock_file) == 0) {
1884 notice("Removed stale lock on %s (pid %d)",
1889 notice("Device %s is locked by pid %d", dev, pid);
1893 error("Can't create lock file %s: %m(%d)", lock_file, errno);
1904 /********************************************************************
1906 * unlock - remove our lockfile
1913 (void) rmlock (lock_file, (void *) 0);
1922 /********************************************************************
1924 * sifvjcomp - config tcp header compression
1927 int sifvjcomp (int u, int vjcomp, int cidcomp, int maxcid)
1929 u_int x = get_flags();
1932 if (ioctl (ppp_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
1933 if (! ok_error (errno))
1934 error("ioctl(PPPIOCSMAXCID): %m(%d)", errno);
1939 x = vjcomp ? x | SC_COMP_TCP : x &~ SC_COMP_TCP;
1940 x = cidcomp ? x & ~SC_NO_TCP_CCID : x | SC_NO_TCP_CCID;
1946 /********************************************************************
1948 * sifup - Config the interface up and enable IP packets to pass.
1955 memset (&ifr, '\0', sizeof (ifr));
1956 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1957 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
1958 if (! ok_error (errno))
1959 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
1963 ifr.ifr_flags |= (IFF_UP | IFF_POINTOPOINT);
1964 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
1965 if (! ok_error (errno))
1966 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
1973 /********************************************************************
1975 * sifdown - Config the interface down and disable IP.
1984 memset (&ifr, '\0', sizeof (ifr));
1985 strlcpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
1986 if (ioctl(sock_fd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
1987 if (! ok_error (errno))
1988 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno);
1992 ifr.ifr_flags &= ~IFF_UP;
1993 ifr.ifr_flags |= IFF_POINTOPOINT;
1994 if (ioctl(sock_fd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
1995 if (! ok_error (errno))
1996 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno);
2002 /********************************************************************
2004 * sifaddr - Config the interface IP addresses and netmask.
2007 int sifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr,
2013 memset (&ifr, '\0', sizeof (ifr));
2014 memset (&rt, '\0', sizeof (rt));
2016 SET_SA_FAMILY (ifr.ifr_addr, AF_INET);
2017 SET_SA_FAMILY (ifr.ifr_dstaddr, AF_INET);
2018 SET_SA_FAMILY (ifr.ifr_netmask, AF_INET);
2020 strlcpy (ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
2022 * Set our IP address
2024 ((struct sockaddr_in *) &ifr.ifr_addr)->sin_addr.s_addr = our_adr;
2025 if (ioctl(sock_fd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2026 if (errno != EEXIST) {
2027 if (! ok_error (errno))
2028 error("ioctl(SIOCAIFADDR): %m(%d)", errno);
2031 warn("ioctl(SIOCAIFADDR): Address already exists");
2036 * Set the gateway address
2038 ((struct sockaddr_in *) &ifr.ifr_dstaddr)->sin_addr.s_addr = his_adr;
2039 if (ioctl(sock_fd, SIOCSIFDSTADDR, (caddr_t) &ifr) < 0) {
2040 if (! ok_error (errno))
2041 error("ioctl(SIOCSIFDSTADDR): %m(%d)", errno);
2046 * For recent kernels, force the netmask to 255.255.255.255.
2048 if (kernel_version >= KVERSION(2,1,16))
2050 if (net_mask != 0) {
2051 ((struct sockaddr_in *) &ifr.ifr_netmask)->sin_addr.s_addr = net_mask;
2052 if (ioctl(sock_fd, SIOCSIFNETMASK, (caddr_t) &ifr) < 0) {
2053 if (! ok_error (errno))
2054 error("ioctl(SIOCSIFNETMASK): %m(%d)", errno);
2059 * Add the device route
2061 if (kernel_version < KVERSION(2,1,16)) {
2062 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2063 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2066 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = 0L;
2067 ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr = his_adr;
2068 rt.rt_flags = RTF_UP | RTF_HOST;
2070 if (kernel_version > KVERSION(2,1,0)) {
2071 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2072 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = -1L;
2075 if (ioctl(sock_fd, SIOCADDRT, &rt) < 0) {
2076 if (! ok_error (errno))
2077 error("ioctl(SIOCADDRT) device route: %m(%d)", errno);
2084 /********************************************************************
2086 * cifaddr - Clear the interface IP addresses, and delete routes
2087 * through the interface if possible.
2090 int cifaddr (int unit, u_int32_t our_adr, u_int32_t his_adr)
2094 if (kernel_version < KVERSION(2,1,16)) {
2096 * Delete the route through the device
2098 memset (&rt, '\0', sizeof (rt));
2100 SET_SA_FAMILY (rt.rt_dst, AF_INET);
2101 SET_SA_FAMILY (rt.rt_gateway, AF_INET);
2104 ((struct sockaddr_in *) &rt.rt_gateway)->sin_addr.s_addr = 0;
2105 ((struct sockaddr_in *) &rt.rt_dst)->sin_addr.s_addr = his_adr;
2106 rt.rt_flags = RTF_UP | RTF_HOST;
2108 if (kernel_version > KVERSION(2,1,0)) {
2109 SET_SA_FAMILY (rt.rt_genmask, AF_INET);
2110 ((struct sockaddr_in *) &rt.rt_genmask)->sin_addr.s_addr = -1L;
2113 if (ioctl(sock_fd, SIOCDELRT, &rt) < 0 && errno != ESRCH) {
2114 if (still_ppp() && ! ok_error (errno))
2115 error("ioctl(SIOCDELRT) device route: %m(%d)", errno);
2123 * get_pty - get a pty master/slave pair and chown the slave side
2124 * to the uid given. Assumes slave_name points to >= 12 bytes of space.
2127 get_pty(master_fdp, slave_fdp, slave_name, uid)
2135 struct termios tios;
2138 for (i = 0; i < 64; ++i) {
2139 slprintf(pty_name, sizeof(pty_name), "/dev/pty%c%x",
2140 'p' + i / 16, i % 16);
2141 mfd = open(pty_name, O_RDWR, 0);
2144 sfd = open(pty_name, O_RDWR | O_NOCTTY, 0);
2153 strlcpy(slave_name, pty_name, 12);
2156 fchown(sfd, uid, -1);
2157 fchmod(sfd, S_IRUSR | S_IWUSR);
2158 if (tcgetattr(sfd, &tios) == 0) {
2159 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
2160 tios.c_cflag |= CS8 | CREAD;
2161 tios.c_iflag = IGNPAR | CLOCAL;
2164 if (tcsetattr(sfd, TCSAFLUSH, &tios) < 0)
2165 warn("couldn't set attributes on pty: %m");
2167 warn("couldn't get attributes on pty: %m");
2172 /********************************************************************
2174 * open_loopback - open the device we use for getting packets
2175 * in demand mode. Under Linux, we use a pty master/slave pair.
2178 open_ppp_loopback(void)
2182 if (!get_pty(&master_fd, &slave_fd, loop_name, 0))
2183 fatal("No free pty for loopback");
2184 SYSDEBUG(("using %s for loopback", loop_name));
2186 set_ppp_fd(slave_fd);
2188 flags = fcntl(master_fd, F_GETFL);
2190 fcntl(master_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2191 warn("couldn't set master loopback to nonblock: %m(%d)", errno);
2193 flags = fcntl(ppp_fd, F_GETFL);
2195 fcntl(ppp_fd, F_SETFL, flags | O_NONBLOCK) == -1)
2196 warn("couldn't set slave loopback to nonblock: %m(%d)", errno);
2198 if (ioctl(ppp_fd, TIOCSETD, &ppp_disc) < 0)
2199 fatal("ioctl(TIOCSETD): %m(%d)", errno);
2201 * Find out which interface we were given.
2203 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0)
2204 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno);
2206 * Enable debug in the driver if requested.
2208 set_kdebugflag (kdebugflag);
2213 /********************************************************************
2215 * restore_loop - reattach the ppp unit to the loopback.
2217 * The kernel ppp driver automatically reattaches the ppp unit to
2218 * the loopback if the serial port is set to a line discipline other
2219 * than ppp, or if it detects a modem hangup. The former will happen
2220 * in disestablish_ppp if the latter hasn't already happened, so we
2221 * shouldn't need to do anything.
2223 * Just to be sure, set the real serial port to the normal discipline.
2229 if (ppp_fd != slave_fd) {
2230 (void) ioctl(ppp_fd, TIOCSETD, &tty_disc);
2231 set_ppp_fd(slave_fd);
2235 /********************************************************************
2237 * sifnpmode - Set the mode for handling packets for a given NP.
2241 sifnpmode(u, proto, mode)
2248 npi.protocol = proto;
2250 if (ioctl(ppp_fd, PPPIOCSNPMODE, (caddr_t) &npi) < 0) {
2251 if (! ok_error (errno)) {
2252 error("ioctl(PPPIOCSNPMODE, %d, %d): %m (%d)",
2253 proto, mode, errno);
2254 error("ppp_fd=%d slave_fd=%d\n", ppp_fd, slave_fd);
2262 /********************************************************************
2264 * sipxfaddr - Config the interface IPX networknumber
2267 int sipxfaddr (int unit, unsigned long int network, unsigned char * node )
2274 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2276 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2278 if (! ok_error (errno))
2279 dbglog("socket(AF_IPX): %m (%d)", errno);
2283 memset (&ifr, '\0', sizeof (ifr));
2284 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2286 memcpy (sipx->sipx_node, node, IPX_NODE_LEN);
2287 sipx->sipx_family = AF_IPX;
2288 sipx->sipx_port = 0;
2289 sipx->sipx_network = htonl (network);
2290 sipx->sipx_type = IPX_FRAME_ETHERII;
2291 sipx->sipx_action = IPX_CRTITF;
2293 * Set the IPX device
2295 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2297 if (errno != EEXIST) {
2298 if (! ok_error (errno))
2299 dbglog("ioctl(SIOCAIFADDR, CRTITF): %m (%d)", errno);
2302 warn("ioctl(SIOCAIFADDR, CRTITF): Address already exists");
2311 /********************************************************************
2313 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2314 * are removed and the device is no longer able to pass IPX
2318 int cipxfaddr (int unit)
2325 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
2327 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
2329 if (! ok_error (errno))
2330 dbglog("socket(AF_IPX): %m (%d)", errno);
2334 memset (&ifr, '\0', sizeof (ifr));
2335 strlcpy (ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
2337 sipx->sipx_type = IPX_FRAME_ETHERII;
2338 sipx->sipx_action = IPX_DLTITF;
2339 sipx->sipx_family = AF_IPX;
2341 * Set the IPX device
2343 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0) {
2344 if (! ok_error (errno))
2345 info("ioctl(SIOCAIFADDR, IPX_DLTITF): %m (%d)", errno);
2355 * daemon - Detach us from controlling terminal session.
2358 daemon(nochdir, noclose)
2359 int nochdir, noclose;
2363 if ((pid = fork()) < 0)
2366 exit(0); /* parent dies */
2371 fclose(stdin); /* don't need stdin, stdout, stderr */
2379 * Use the hostname as part of the random number seed.
2388 for (p = hostname; *p != 0; ++p)
2393 /********************************************************************
2395 * sys_check_options - check the options that the user specified
2399 sys_check_options(void)
2402 struct stat stat_buf;
2404 * Disable the IPX protocol if the support is not present in the kernel.
2405 * If we disable it then ensure that IP support is enabled.
2407 while (ipxcp_protent.enabled_flag) {
2408 if (path_to_procfs()) {
2409 strlcat (route_buffer, "/net/ipx_interface", sizeof(route_buffer));
2410 if (lstat (route_buffer, &stat_buf) >= 0)
2413 error("IPX support is not present in the kernel\n");
2414 ipxcp_protent.enabled_flag = 0;
2415 ipcp_protent.enabled_flag = 1;
2419 if (demand && driver_is_old) {
2420 option_error("demand dialling is not supported by kernel driver "
2421 "version %d.%d.%d", driver_version, driver_modification,