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>
29 #include <sys/sysmacros.h>
45 /* This is in netdevice.h. However, this compile will fail miserably if
46 you attempt to include netdevice.h because it has so many references
47 to __memcpy functions which it should not attempt to do. So, since I
48 really don't use it, but it must be defined, define it now. */
51 #define MAX_ADDR_LEN 7
55 #include <asm/types.h> /* glibc 2 conflicts with linux/types.h */
57 #include <net/if_arp.h>
58 #include <net/route.h>
59 #include <netinet/if_ether.h>
61 #include <linux/types.h>
63 #include <linux/if_arp.h>
64 #include <linux/route.h>
65 #include <linux/if_ether.h>
67 #include <netinet/in.h>
68 #include <arpa/inet.h>
70 #include <linux/ppp_defs.h>
71 #include <linux/if_ppp.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 */
89 #include <linux/filter.h>
90 #endif /* PPP_FILTER */
93 #include <sys/locks.h>
99 * This is in linux/include/net/ipv6.h.
103 struct in6_addr ifr6_addr
;
104 __u32 ifr6_prefixlen
;
105 unsigned int ifr6_ifindex
;
109 #define IN6_LLADDR_FROM_EUI64(sin6, eui64) do { \
110 memset(&sin6.s6_addr, 0, sizeof(struct in6_addr)); \
111 sin6.s6_addr16[0] = htons(0xfe80); \
112 eui64_copy(eui64, sin6.s6_addr32[2]); \
117 /* We can get an EIO error on an ioctl if the modem has hung up */
118 #define ok_error(num) ((num)==EIO)
120 static int tty_disc
= N_TTY
; /* The TTY discipline */
121 static int ppp_disc
= N_PPP
; /* The PPP discpline */
122 static int initfdflags
= -1; /* Initial file descriptor flags for fd */
123 static int ppp_fd
= -1; /* fd which is set to PPP discipline */
124 static int sock_fd
= -1; /* socket for doing interface ioctls */
125 static int slave_fd
= -1;
126 static int master_fd
= -1;
128 static int sock6_fd
= -1;
130 static int ppp_dev_fd
= -1; /* fd for /dev/ppp (new style driver) */
131 static int chindex
; /* channel index (new style driver) */
133 static fd_set in_fds
; /* set of fds that wait_input waits for */
134 static int max_in_fd
; /* highest fd set in in_fds */
136 static int has_proxy_arp
= 0;
137 static int driver_version
= 0;
138 static int driver_modification
= 0;
139 static int driver_patch
= 0;
140 static int driver_is_old
= 0;
141 static int restore_term
= 0; /* 1 => we've munged the terminal */
142 static struct termios inittermios
; /* Initial TTY termios */
144 int new_style_driver
= 0;
146 static char loop_name
[20];
147 static unsigned char inbuf
[512]; /* buffer for chars read from loopback */
149 static int if_is_up
; /* Interface has been marked up */
150 static u_int32_t default_route_gateway
; /* Gateway for default route added */
151 static u_int32_t proxy_arp_addr
; /* Addr for proxy arp entry added */
152 static char proxy_arp_dev
[16]; /* Device for proxy arp entry */
153 static u_int32_t our_old_addr
; /* for detecting address changes */
154 static int dynaddr_set
; /* 1 if ip_dynaddr set */
155 static int looped
; /* 1 if using loop */
156 static int link_mtu
; /* mtu for the link (not bundle) */
158 static struct utsname utsname
; /* for the kernel version */
159 static int kernel_version
;
160 #define KVERSION(j,n,p) ((j)*1000000 + (n)*1000 + (p))
164 #define FLAGS_GOOD (IFF_UP | IFF_BROADCAST)
165 #define FLAGS_MASK (IFF_UP | IFF_BROADCAST | \
166 IFF_POINTOPOINT | IFF_LOOPBACK | IFF_NOARP)
168 #define SIN_ADDR(x) (((struct sockaddr_in *) (&(x)))->sin_addr.s_addr)
170 /* Prototypes for procedures local to this file. */
171 static int get_flags (int fd
);
172 static void set_flags (int fd
, int flags
);
173 static int translate_speed (int bps
);
174 static int baud_rate_of (int speed
);
175 static void close_route_table (void);
176 static int open_route_table (void);
177 static int read_route_table (struct rtentry
*rt
);
178 static int defaultroute_exists (struct rtentry
*rt
);
179 static int get_ether_addr (u_int32_t ipaddr
, struct sockaddr
*hwaddr
,
180 char *name
, int namelen
);
181 static void decode_version (char *buf
, int *version
, int *mod
, int *patch
);
182 static int set_kdebugflag(int level
);
183 static int ppp_registered(void);
184 static int make_ppp_unit(void);
185 static void restore_loop(void); /* Transfer ppp unit back to loopback */
187 extern u_char inpacket_buf
[]; /* borrowed from main.c */
190 * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
194 #define SET_SA_FAMILY(addr, family) \
195 memset ((char *) &(addr), '\0', sizeof(addr)); \
196 addr.sa_family = (family);
199 * Determine if the PPP connection should still be present.
204 /* new_fd is the fd of a tty */
205 static void set_ppp_fd (int new_fd
)
207 SYSDEBUG ((LOG_DEBUG
, "setting ppp_fd to %d\n", new_fd
));
209 if (!new_style_driver
)
213 static int still_ppp(void)
215 if (new_style_driver
)
216 return !hungup
&& ppp_fd
>= 0;
217 if (!hungup
|| ppp_fd
== slave_fd
)
220 set_ppp_fd(slave_fd
);
226 /********************************************************************
228 * Functions to read and set the flags value in the device driver
231 static int get_flags (int fd
)
235 if (ioctl(fd
, PPPIOCGFLAGS
, (caddr_t
) &flags
) < 0) {
236 if ( ok_error (errno
) )
239 fatal("ioctl(PPPIOCGFLAGS): %m");
242 SYSDEBUG ((LOG_DEBUG
, "get flags = %x\n", flags
));
246 /********************************************************************/
248 static void set_flags (int fd
, int flags
)
250 SYSDEBUG ((LOG_DEBUG
, "set flags = %x\n", flags
));
252 if (ioctl(fd
, PPPIOCSFLAGS
, (caddr_t
) &flags
) < 0) {
253 if (! ok_error (errno
) )
254 fatal("ioctl(PPPIOCSFLAGS, %x): %m", flags
, errno
);
258 /********************************************************************
260 * sys_init - System-dependent initialization.
267 if (new_style_driver
) {
268 ppp_dev_fd
= open("/dev/ppp", O_RDWR
);
270 fatal("Couldn't open /dev/ppp: %m");
271 flags
= fcntl(ppp_dev_fd
, F_GETFL
);
273 || fcntl(ppp_dev_fd
, F_SETFL
, flags
| O_NONBLOCK
) == -1)
274 warn("Couldn't set /dev/ppp to nonblock: %m");
277 /* Get an internet socket for doing socket ioctls. */
278 sock_fd
= socket(AF_INET
, SOCK_DGRAM
, 0);
280 fatal("Couldn't create IP socket: %m(%d)", errno
);
283 sock6_fd
= socket(AF_INET6
, SOCK_DGRAM
, 0);
285 sock6_fd
= -errno
; /* save errno for later */
292 /********************************************************************
294 * sys_cleanup - restore any system state we modified before exiting:
295 * mark the interface down, delete default route and/or proxy arp entry.
296 * This shouldn't call die() because it's called from die().
299 void sys_cleanup(void)
302 * Take down the device
309 * Delete any routes through the device.
311 if (default_route_gateway
!= 0)
312 cifdefaultroute(0, 0, default_route_gateway
);
315 cifproxyarp(0, proxy_arp_addr
);
318 /********************************************************************
320 * sys_close - Clean up in a child process before execing.
325 if (new_style_driver
)
336 /********************************************************************
338 * set_kdebugflag - Define the debugging level for the kernel
341 static int set_kdebugflag (int requested_level
)
343 if (new_style_driver
&& ifunit
< 0)
345 if (ioctl(ppp_dev_fd
, PPPIOCSDEBUG
, &requested_level
) < 0) {
346 if ( ! ok_error (errno
) )
347 error("ioctl(PPPIOCSDEBUG): %m");
350 SYSDEBUG ((LOG_INFO
, "set kernel debugging level to %d",
356 /********************************************************************
358 * generic_establish_ppp - Turn the fd into a ppp interface.
360 int generic_establish_ppp (int fd
)
364 * Demand mode - prime the old ppp device to relinquish the unit.
366 if (!new_style_driver
&& looped
367 && ioctl(slave_fd
, PPPIOCXFERUNIT
, 0) < 0) {
368 error("ioctl(transfer ppp unit): %m");
373 if (new_style_driver
) {
374 /* Open another instance of /dev/ppp and connect the channel to it */
377 if (ioctl(fd
, PPPIOCGCHAN
, &chindex
) == -1) {
378 error("Couldn't get channel number: %m");
381 dbglog("using channel %d", chindex
);
382 fd
= open("/dev/ppp", O_RDWR
);
384 error("Couldn't reopen /dev/ppp: %m");
387 if (ioctl(fd
, PPPIOCATTCHAN
, &chindex
) < 0) {
388 error("Couldn't attach to channel %d: %m", chindex
);
391 flags
= fcntl(fd
, F_GETFL
);
392 if (flags
== -1 || fcntl(fd
, F_SETFL
, flags
| O_NONBLOCK
) == -1)
393 warn("Couldn't set /dev/ppp (channel) to nonblock: %m");
398 if (!looped
&& !multilink
) {
400 * Create a new PPP unit.
402 if (make_ppp_unit() < 0)
407 set_flags(ppp_dev_fd
, get_flags(ppp_dev_fd
) & ~SC_LOOP_TRAFFIC
);
411 if (ioctl(fd
, PPPIOCCONNECT
, &ifunit
) < 0) {
412 error("Couldn't attach to PPP unit %d: %m", ifunit
);
420 * Old-style driver: find out which interface we were given.
423 if (ioctl(fd
, PPPIOCGUNIT
, &x
) < 0) {
424 if (ok_error (errno
))
426 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno
);
428 /* Check that we got the same unit again. */
429 if (looped
&& x
!= ifunit
)
430 fatal("transfer_ppp failed: wanted unit %d, got %d", ifunit
, x
);
434 * Fetch the initial file flags and reset blocking mode on the file.
436 initfdflags
= fcntl(fd
, F_GETFL
);
437 if (initfdflags
== -1 ||
438 fcntl(fd
, F_SETFL
, initfdflags
| O_NONBLOCK
) == -1) {
439 if ( ! ok_error (errno
))
440 warn("Couldn't set device to non-blocking mode: %m");
448 * Enable debug in the driver if requested.
451 set_kdebugflag (kdebugflag
);
453 SYSDEBUG ((LOG_NOTICE
, "Using version %d.%d.%d of PPP driver",
454 driver_version
, driver_modification
, driver_patch
));
461 if (ioctl(fd
, TIOCSETD
, &tty_disc
) < 0 && !ok_error(errno
))
462 warn("Couldn't reset tty to normal line discipline: %m");
466 /********************************************************************
468 * tty_establish_ppp - Turn the serial port into a ppp interface.
471 int tty_establish_ppp (int tty_fd
)
475 * Ensure that the tty device is in exclusive mode.
477 if (ioctl(tty_fd
, TIOCEXCL
, 0) < 0) {
478 if ( ! ok_error ( errno
))
479 warn("Couldn't make tty exclusive: %m");
482 * Set the current tty to the PPP discpline
486 #define N_SYNC_PPP 14
488 ppp_disc
= (new_style_driver
&& sync_serial
)? N_SYNC_PPP
: N_PPP
;
489 if (ioctl(tty_fd
, TIOCSETD
, &ppp_disc
) < 0) {
490 if ( ! ok_error (errno
) ) {
491 error("Couldn't set tty to PPP discipline: %m");
496 ret_fd
= generic_establish_ppp(tty_fd
);
497 #define SC_RCVB (SC_RCV_B7_0 | SC_RCV_B7_1 | SC_RCV_EVNP | SC_RCV_ODDP)
498 #define SC_LOGB (SC_DEBUG | SC_LOG_INPKT | SC_LOG_OUTPKT | SC_LOG_RAWIN \
501 set_flags(ppp_fd
, ((get_flags(ppp_fd
) & ~(SC_RCVB
| SC_LOGB
))
502 | ((kdebugflag
* SC_DEBUG
) & SC_LOGB
)));
507 /********************************************************************
509 * generic_disestablish_ppp - Restore device components to normal
510 * operation, and reconnect the ppp unit to the loopback if in demand
511 * mode. This shouldn't call die() because it's called from die().
513 void generic_disestablish_ppp(int dev_fd
){
514 /* Restore loop if needed */
518 /* Finally detach the device */
521 if (new_style_driver
) {
524 if (!looped
&& ifunit
>= 0 && ioctl(ppp_dev_fd
, PPPIOCDETACH
) < 0)
525 error("Couldn't release PPP unit: %m");
527 remove_fd(ppp_dev_fd
);
531 /********************************************************************
533 * tty_disestablish_ppp - Restore the serial port to normal operation.
534 * This shouldn't call die() because it's called from die().
537 void tty_disestablish_ppp(int tty_fd
)
539 generic_disestablish_ppp(tty_fd
);
543 * Flush the tty output buffer so that the TIOCSETD doesn't hang.
545 if (tcflush(tty_fd
, TCIOFLUSH
) < 0)
546 warn("tcflush failed: %m");
548 * Restore the previous line discipline
550 if (ioctl(tty_fd
, TIOCSETD
, &tty_disc
) < 0) {
551 if ( ! ok_error (errno
))
552 error("ioctl(TIOCSETD, N_TTY): %m");
555 if (ioctl(tty_fd
, TIOCNXCL
, 0) < 0) {
556 if ( ! ok_error (errno
))
557 warn("ioctl(TIOCNXCL): %m(%d)", errno
);
560 /* Reset non-blocking mode on fd. */
561 if (initfdflags
!= -1 && fcntl(tty_fd
, F_SETFL
, initfdflags
) < 0) {
562 if ( ! ok_error (errno
))
563 warn("Couldn't restore device fd flags: %m");
569 * make_ppp_unit - make a new ppp unit for ppp_dev_fd.
570 * Assumes new_style_driver.
572 static int make_ppp_unit()
577 x
= ioctl(ppp_dev_fd
, PPPIOCNEWUNIT
, &ifunit
);
578 if (x
< 0 && req_unit
>= 0 && errno
== EEXIST
) {
579 warn("Couldn't allocate PPP unit %d as it is already in use");
581 x
= ioctl(ppp_dev_fd
, PPPIOCNEWUNIT
, &ifunit
);
584 error("Couldn't create new ppp unit: %m");
589 * cfg_bundle - configure the existing bundle.
590 * Used in demand mode.
592 void cfg_bundle(int mrru
, int mtru
, int rssn
, int tssn
)
596 if (!new_style_driver
)
599 /* set the mrru, mtu and flags */
600 if (ioctl(ppp_dev_fd
, PPPIOCSMRRU
, &mrru
) < 0)
601 error("Couldn't set MRRU: %m");
602 flags
= get_flags(ppp_dev_fd
);
603 flags
&= ~(SC_MP_SHORTSEQ
| SC_MP_XSHORTSEQ
);
604 flags
|= (rssn
? SC_MP_SHORTSEQ
: 0) | (tssn
? SC_MP_XSHORTSEQ
: 0)
605 | (mrru
? SC_MULTILINK
: 0);
607 set_flags(ppp_dev_fd
, flags
);
609 /* connect up the channel */
610 if (ioctl(ppp_fd
, PPPIOCCONNECT
, &ifunit
) < 0)
611 fatal("Couldn't attach to PPP unit %d: %m", ifunit
);
616 * make_new_bundle - create a new PPP unit (i.e. a bundle)
617 * and connect our channel to it. This should only get called
618 * if `multilink' was set at the time establish_ppp was called.
619 * In demand mode this uses our existing bundle instead of making
622 void make_new_bundle(int mrru
, int mtru
, int rssn
, int tssn
)
624 if (!new_style_driver
)
627 /* make us a ppp unit */
628 if (make_ppp_unit() < 0)
631 /* set the mrru and flags */
632 cfg_bundle(mrru
, mtru
, rssn
, tssn
);
636 * bundle_attach - attach our link to a given PPP unit.
637 * We assume the unit is controlled by another pppd.
639 int bundle_attach(int ifnum
)
641 if (!new_style_driver
)
644 if (ioctl(ppp_dev_fd
, PPPIOCATTACH
, &ifnum
) < 0) {
646 return 0; /* doesn't still exist */
647 fatal("Couldn't attach to interface unit %d: %m\n", ifnum
);
649 if (ioctl(ppp_fd
, PPPIOCCONNECT
, &ifnum
) < 0)
650 fatal("Couldn't connect to interface unit %d: %m", ifnum
);
651 set_flags(ppp_dev_fd
, get_flags(ppp_dev_fd
) | SC_MULTILINK
);
657 /********************************************************************
659 * clean_check - Fetch the flags for the device and generate
660 * appropriate error messages.
662 void clean_check(void)
668 if (ioctl(ppp_fd
, PPPIOCGFLAGS
, (caddr_t
) &x
) == 0) {
670 switch (~x
& (SC_RCV_B7_0
|SC_RCV_B7_1
|SC_RCV_EVNP
|SC_RCV_ODDP
)) {
672 s
= "all had bit 7 set to 1";
676 s
= "all had bit 7 set to 0";
680 s
= "all had odd parity";
684 s
= "all had even parity";
689 warn("Receive serial link is not 8-bit clean:");
690 warn("Problem: %s", s
);
698 * List of valid speeds.
702 int speed_int
, speed_val
;
785 /********************************************************************
787 * Translate from bits/second to a speed_t.
790 static int translate_speed (int bps
)
792 struct speed
*speedp
;
795 for (speedp
= speeds
; speedp
->speed_int
; speedp
++) {
796 if (bps
== speedp
->speed_int
)
797 return speedp
->speed_val
;
799 warn("speed %d not supported", bps
);
804 /********************************************************************
806 * Translate from a speed_t to bits/second.
809 static int baud_rate_of (int speed
)
811 struct speed
*speedp
;
814 for (speedp
= speeds
; speedp
->speed_int
; speedp
++) {
815 if (speed
== speedp
->speed_val
)
816 return speedp
->speed_int
;
822 /********************************************************************
824 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
825 * at the requested speed, etc. If `local' is true, set CLOCAL
826 * regardless of whether the modem option was specified.
829 void set_up_tty(int tty_fd
, int local
)
835 if (tcgetattr(tty_fd
, &tios
) < 0) {
836 if (!ok_error(errno
))
837 fatal("tcgetattr: %m(%d)", errno
);
844 tios
.c_cflag
&= ~(CSIZE
| CSTOPB
| PARENB
| CLOCAL
);
845 tios
.c_cflag
|= CS8
| CREAD
| HUPCL
;
847 tios
.c_iflag
= IGNBRK
| IGNPAR
;
851 tios
.c_cc
[VTIME
] = 0;
854 tios
.c_cflag
^= (CLOCAL
| HUPCL
);
858 tios
.c_cflag
|= CRTSCTS
;
862 tios
.c_iflag
|= IXON
| IXOFF
;
863 tios
.c_cc
[VSTOP
] = 0x13; /* DC3 = XOFF = ^S */
864 tios
.c_cc
[VSTART
] = 0x11; /* DC1 = XON = ^Q */
868 tios
.c_cflag
&= ~CRTSCTS
;
875 speed
= translate_speed(inspeed
);
877 cfsetospeed (&tios
, speed
);
878 cfsetispeed (&tios
, speed
);
881 * We can't proceed if the serial port speed is B0,
882 * since that implies that the serial port is disabled.
885 speed
= cfgetospeed(&tios
);
887 fatal("Baud rate for %s is 0; need explicit baud rate", devnam
);
890 if (tcsetattr(tty_fd
, TCSAFLUSH
, &tios
) < 0)
891 if (!ok_error(errno
))
892 fatal("tcsetattr: %m");
894 baud_rate
= baud_rate_of(speed
);
898 /********************************************************************
900 * setdtr - control the DTR line on the serial port.
901 * This is called from die(), so it shouldn't call die().
904 void setdtr (int tty_fd
, int on
)
906 int modembits
= TIOCM_DTR
;
908 ioctl(tty_fd
, (on
? TIOCMBIS
: TIOCMBIC
), &modembits
);
911 /********************************************************************
913 * restore_tty - restore the terminal to the saved settings.
916 void restore_tty (int tty_fd
)
921 * Turn off echoing, because otherwise we can get into
922 * a loop with the tty and the modem echoing to each other.
923 * We presume we are the sole user of this tty device, so
924 * when we close it, it will revert to its defaults anyway.
927 inittermios
.c_lflag
&= ~(ECHO
| ECHONL
);
929 if (tcsetattr(tty_fd
, TCSAFLUSH
, &inittermios
) < 0) {
930 if (! ok_error (errno
))
931 warn("tcsetattr: %m");
936 /********************************************************************
938 * output - Output PPP packet.
941 void output (int unit
, unsigned char *p
, int len
)
947 dbglog("sent %P", p
, len
);
949 if (len
< PPP_HDRLEN
)
951 if (new_style_driver
) {
954 proto
= (p
[0] << 8) + p
[1];
955 if (ifunit
>= 0 && !(proto
>= 0xc000 || proto
== PPP_CCPFRAG
))
958 if (write(fd
, p
, len
) < 0) {
959 if (errno
== EWOULDBLOCK
|| errno
== ENOBUFS
960 || errno
== ENXIO
|| errno
== EIO
|| errno
== EINTR
)
961 warn("write: warning: %m (%d)", errno
);
963 error("write: %m (%d)", errno
);
967 /********************************************************************
969 * wait_input - wait until there is data available,
970 * for the length of time specified by *timo (indefinite
974 void wait_input(struct timeval
*timo
)
981 n
= select(max_in_fd
+ 1, &ready
, NULL
, &exc
, timo
);
982 if (n
< 0 && errno
!= EINTR
)
983 fatal("select: %m(%d)", errno
);
987 * add_fd - add an fd to the set that wait_input waits for.
997 * remove_fd - remove an fd from the set that wait_input waits for.
999 void remove_fd(int fd
)
1001 FD_CLR(fd
, &in_fds
);
1005 /********************************************************************
1007 * read_packet - get a PPP packet from the serial device.
1010 int read_packet (unsigned char *buf
)
1014 len
= PPP_MRU
+ PPP_HDRLEN
;
1015 if (new_style_driver
) {
1016 *buf
++ = PPP_ALLSTATIONS
;
1022 nr
= read(ppp_fd
, buf
, len
);
1023 if (nr
< 0 && errno
!= EWOULDBLOCK
&& errno
!= EIO
&& errno
!= EINTR
)
1025 if (nr
< 0 && errno
== ENXIO
)
1028 if (nr
< 0 && new_style_driver
&& ifunit
>= 0) {
1029 /* N.B. we read ppp_fd first since LCP packets come in there. */
1030 nr
= read(ppp_dev_fd
, buf
, len
);
1031 if (nr
< 0 && errno
!= EWOULDBLOCK
&& errno
!= EIO
&& errno
!= EINTR
)
1032 error("read /dev/ppp: %m");
1033 if (nr
< 0 && errno
== ENXIO
)
1036 return (new_style_driver
&& nr
> 0)? nr
+2: nr
;
1039 /********************************************************************
1041 * get_loop_output - get outgoing packets from the ppp device,
1042 * and detect when we want to bring the real link up.
1043 * Return value is 1 if we need to bring up the link, 0 otherwise.
1046 get_loop_output(void)
1051 if (new_style_driver
) {
1052 while ((n
= read_packet(inpacket_buf
)) > 0)
1053 if (loop_frame(inpacket_buf
, n
))
1058 while ((n
= read(master_fd
, inbuf
, sizeof(inbuf
))) > 0)
1059 if (loop_chars(inbuf
, n
))
1063 fatal("eof on loopback");
1065 if (errno
!= EWOULDBLOCK
)
1066 fatal("read from loopback: %m(%d)", errno
);
1072 * netif_set_mtu - set the MTU on the PPP network interface.
1075 netif_set_mtu(int unit
, int mtu
)
1079 SYSDEBUG ((LOG_DEBUG
, "netif_set_mtu: mtu = %d\n", mtu
));
1081 memset (&ifr
, '\0', sizeof (ifr
));
1082 strlcpy(ifr
.ifr_name
, ifname
, sizeof (ifr
.ifr_name
));
1085 if (ifunit
>= 0 && ioctl(sock_fd
, SIOCSIFMTU
, (caddr_t
) &ifr
) < 0)
1086 fatal("ioctl(SIOCSIFMTU): %m");
1089 /********************************************************************
1091 * tty_send_config - configure the transmit characteristics of
1092 * the ppp interface.
1095 void tty_send_config (int mtu
,u_int32_t asyncmap
,int pcomp
,int accomp
)
1100 * Set the asyncmap and other parameters for the ppp device
1105 SYSDEBUG ((LOG_DEBUG
, "send_config: asyncmap = %lx\n", asyncmap
));
1106 if (ioctl(ppp_fd
, PPPIOCSASYNCMAP
, (caddr_t
) &asyncmap
) < 0) {
1107 if (!ok_error(errno
))
1108 fatal("ioctl(PPPIOCSASYNCMAP): %m(%d)", errno
);
1112 x
= get_flags(ppp_fd
);
1113 x
= pcomp
? x
| SC_COMP_PROT
: x
& ~SC_COMP_PROT
;
1114 x
= accomp
? x
| SC_COMP_AC
: x
& ~SC_COMP_AC
;
1115 x
= sync_serial
? x
| SC_SYNC
: x
& ~SC_SYNC
;
1116 set_flags(ppp_fd
, x
);
1119 /********************************************************************
1121 * tty_set_xaccm - set the extended transmit ACCM for the interface.
1124 void tty_set_xaccm (ext_accm accm
)
1126 SYSDEBUG ((LOG_DEBUG
, "set_xaccm: %08lx %08lx %08lx %08lx\n",
1127 accm
[0], accm
[1], accm
[2], accm
[3]));
1131 if (ioctl(ppp_fd
, PPPIOCSXASYNCMAP
, accm
) < 0 && errno
!= ENOTTY
) {
1132 if ( ! ok_error (errno
))
1133 warn("ioctl(set extended ACCM): %m(%d)", errno
);
1137 /********************************************************************
1139 * tty_recv_config - configure the receive-side characteristics of
1140 * the ppp interface.
1143 void tty_recv_config (int mru
,u_int32_t asyncmap
,int pcomp
,int accomp
)
1145 SYSDEBUG ((LOG_DEBUG
, "recv_config: mru = %d\n", mru
));
1147 * If we were called because the link has gone down then there is nothing
1148 * which may be done. Just return without incident.
1153 * Set the receiver parameters
1155 if (ioctl(ppp_fd
, PPPIOCSMRU
, (caddr_t
) &mru
) < 0) {
1156 if ( ! ok_error (errno
))
1157 error("ioctl(PPPIOCSMRU): %m(%d)", errno
);
1159 if (new_style_driver
&& ifunit
>= 0
1160 && ioctl(ppp_dev_fd
, PPPIOCSMRU
, (caddr_t
) &mru
) < 0)
1161 error("Couldn't set MRU in generic PPP layer: %m");
1163 SYSDEBUG ((LOG_DEBUG
, "recv_config: asyncmap = %lx\n", asyncmap
));
1164 if (ioctl(ppp_fd
, PPPIOCSRASYNCMAP
, (caddr_t
) &asyncmap
) < 0) {
1165 if (!ok_error(errno
))
1166 error("ioctl(PPPIOCSRASYNCMAP): %m(%d)", errno
);
1170 /********************************************************************
1172 * ccp_test - ask kernel whether a given compression method
1173 * is acceptable for use.
1176 int ccp_test (int unit
, u_char
*opt_ptr
, int opt_len
, int for_transmit
)
1178 struct ppp_option_data data
;
1180 memset (&data
, '\0', sizeof (data
));
1182 data
.length
= opt_len
;
1183 data
.transmit
= for_transmit
;
1185 if (ioctl(ppp_dev_fd
, PPPIOCSCOMPRESS
, (caddr_t
) &data
) >= 0)
1188 return (errno
== ENOBUFS
)? 0: -1;
1191 /********************************************************************
1193 * ccp_flags_set - inform kernel about the current state of CCP.
1196 void ccp_flags_set (int unit
, int isopen
, int isup
)
1199 int x
= get_flags(ppp_dev_fd
);
1200 x
= isopen
? x
| SC_CCP_OPEN
: x
&~ SC_CCP_OPEN
;
1201 x
= isup
? x
| SC_CCP_UP
: x
&~ SC_CCP_UP
;
1202 set_flags (ppp_dev_fd
, x
);
1208 * set_filters - set the active and pass filters in the kernel driver.
1210 int set_filters(struct bpf_program
*pass
, struct bpf_program
*active
)
1212 struct sock_fprog fp
;
1214 fp
.len
= pass
->bf_len
;
1215 fp
.filter
= (struct sock_filter
*) pass
->bf_insns
;
1216 if (ioctl(ppp_dev_fd
, PPPIOCSPASS
, &fp
) < 0) {
1217 if (errno
== ENOTTY
)
1218 warn("kernel does not support PPP filtering");
1220 error("Couldn't set pass-filter in kernel: %m");
1223 fp
.len
= active
->bf_len
;
1224 fp
.filter
= (struct sock_filter
*) active
->bf_insns
;
1225 if (ioctl(ppp_dev_fd
, PPPIOCSACTIVE
, &fp
) < 0) {
1226 error("Couldn't set active-filter in kernel: %m");
1231 #endif /* PPP_FILTER */
1233 /********************************************************************
1235 * get_idle_time - return how long the link has been idle.
1238 get_idle_time(u
, ip
)
1240 struct ppp_idle
*ip
;
1242 return ioctl(ppp_dev_fd
, PPPIOCGIDLE
, ip
) >= 0;
1245 /********************************************************************
1247 * get_ppp_stats - return statistics for the link.
1250 get_ppp_stats(u
, stats
)
1252 struct pppd_stats
*stats
;
1254 struct ifpppstatsreq req
;
1256 memset (&req
, 0, sizeof (req
));
1258 req
.stats_ptr
= (caddr_t
) &req
.stats
;
1259 strlcpy(req
.ifr__name
, ifname
, sizeof(req
.ifr__name
));
1260 if (ioctl(sock_fd
, SIOCGPPPSTATS
, &req
) < 0) {
1261 error("Couldn't get PPP statistics: %m");
1264 stats
->bytes_in
= req
.stats
.p
.ppp_ibytes
;
1265 stats
->bytes_out
= req
.stats
.p
.ppp_obytes
;
1269 /********************************************************************
1271 * ccp_fatal_error - returns 1 if decompression was disabled as a
1272 * result of an error detected after decompression of a packet,
1273 * 0 otherwise. This is necessary because of patent nonsense.
1276 int ccp_fatal_error (int unit
)
1278 int x
= get_flags(ppp_dev_fd
);
1280 return x
& SC_DC_FERROR
;
1283 /********************************************************************
1285 * path_to_procfs - find the path to the proc file system mount point
1287 static char proc_path
[MAXPATHLEN
];
1288 static int proc_path_len
;
1290 static char *path_to_procfs(const char *tail
)
1292 struct mntent
*mntent
;
1295 if (proc_path_len
== 0) {
1296 /* Default the mount location of /proc */
1297 strlcpy (proc_path
, "/proc", sizeof(proc_path
));
1299 fp
= fopen(MOUNTED
, "r");
1301 while ((mntent
= getmntent(fp
)) != NULL
) {
1302 if (strcmp(mntent
->mnt_type
, MNTTYPE_IGNORE
) == 0)
1304 if (strcmp(mntent
->mnt_type
, "proc") == 0) {
1305 strlcpy(proc_path
, mntent
->mnt_dir
, sizeof(proc_path
));
1306 proc_path_len
= strlen(proc_path
);
1314 strlcpy(proc_path
+ proc_path_len
, tail
,
1315 sizeof(proc_path
) - proc_path_len
);
1320 * /proc/net/route parsing stuff.
1322 #define ROUTE_MAX_COLS 12
1323 FILE *route_fd
= (FILE *) 0;
1324 static char route_buffer
[512];
1325 static int route_dev_col
, route_dest_col
, route_gw_col
;
1326 static int route_flags_col
, route_mask_col
;
1327 static int route_num_cols
;
1329 static int open_route_table (void);
1330 static void close_route_table (void);
1331 static int read_route_table (struct rtentry
*rt
);
1333 /********************************************************************
1335 * close_route_table - close the interface to the route table
1338 static void close_route_table (void)
1340 if (route_fd
!= (FILE *) 0) {
1342 route_fd
= (FILE *) 0;
1346 /********************************************************************
1348 * open_route_table - open the interface to the route table
1350 static char route_delims
[] = " \t\n";
1352 static int open_route_table (void)
1356 close_route_table();
1358 path
= path_to_procfs("/net/route");
1359 route_fd
= fopen (path
, "r");
1360 if (route_fd
== NULL
) {
1361 error("can't open routing table %s: %m", path
);
1365 route_dev_col
= 0; /* default to usual columns */
1368 route_flags_col
= 3;
1372 /* parse header line */
1373 if (fgets(route_buffer
, sizeof(route_buffer
), route_fd
) != 0) {
1374 char *p
= route_buffer
, *q
;
1376 for (col
= 0; col
< ROUTE_MAX_COLS
; ++col
) {
1378 if ((q
= strtok(p
, route_delims
)) == 0)
1380 if (strcasecmp(q
, "iface") == 0)
1381 route_dev_col
= col
;
1382 else if (strcasecmp(q
, "destination") == 0)
1383 route_dest_col
= col
;
1384 else if (strcasecmp(q
, "gateway") == 0)
1386 else if (strcasecmp(q
, "flags") == 0)
1387 route_flags_col
= col
;
1388 else if (strcasecmp(q
, "mask") == 0)
1389 route_mask_col
= col
;
1392 if (used
&& col
>= route_num_cols
)
1393 route_num_cols
= col
+ 1;
1401 /********************************************************************
1403 * read_route_table - read the next entry from the route table
1406 static int read_route_table(struct rtentry
*rt
)
1408 char *cols
[ROUTE_MAX_COLS
], *p
;
1411 memset (rt
, '\0', sizeof (struct rtentry
));
1413 if (fgets (route_buffer
, sizeof (route_buffer
), route_fd
) == (char *) 0)
1417 for (col
= 0; col
< route_num_cols
; ++col
) {
1418 cols
[col
] = strtok(p
, route_delims
);
1419 if (cols
[col
] == NULL
)
1420 return 0; /* didn't get enough columns */
1424 SIN_ADDR(rt
->rt_dst
) = strtoul(cols
[route_dest_col
], NULL
, 16);
1425 SIN_ADDR(rt
->rt_gateway
) = strtoul(cols
[route_gw_col
], NULL
, 16);
1426 SIN_ADDR(rt
->rt_genmask
) = strtoul(cols
[route_mask_col
], NULL
, 16);
1428 rt
->rt_flags
= (short) strtoul(cols
[route_flags_col
], NULL
, 16);
1429 rt
->rt_dev
= cols
[route_dev_col
];
1434 /********************************************************************
1436 * defaultroute_exists - determine if there is a default route
1439 static int defaultroute_exists (struct rtentry
*rt
)
1443 if (!open_route_table())
1446 while (read_route_table(rt
) != 0) {
1447 if ((rt
->rt_flags
& RTF_UP
) == 0)
1450 if (kernel_version
> KVERSION(2,1,0) && SIN_ADDR(rt
->rt_genmask
) != 0)
1452 if (SIN_ADDR(rt
->rt_dst
) == 0L) {
1458 close_route_table();
1463 * have_route_to - determine if the system has any route to
1464 * a given IP address. `addr' is in network byte order.
1465 * Return value is 1 if yes, 0 if no, -1 if don't know.
1466 * For demand mode to work properly, we have to ignore routes
1467 * through our own interface.
1469 int have_route_to(u_int32_t addr
)
1474 if (!open_route_table())
1475 return -1; /* don't know */
1477 while (read_route_table(&rt
)) {
1478 if ((rt
.rt_flags
& RTF_UP
) == 0 || strcmp(rt
.rt_dev
, ifname
) == 0)
1480 if ((addr
& SIN_ADDR(rt
.rt_genmask
)) == SIN_ADDR(rt
.rt_dst
)) {
1486 close_route_table();
1490 /********************************************************************
1492 * sifdefaultroute - assign a default route through the address given.
1495 int sifdefaultroute (int unit
, u_int32_t ouraddr
, u_int32_t gateway
)
1499 if (defaultroute_exists(&rt
) && strcmp(rt
.rt_dev
, ifname
) != 0) {
1500 u_int32_t old_gateway
= SIN_ADDR(rt
.rt_gateway
);
1502 if (old_gateway
!= gateway
)
1503 error("not replacing existing default route to %s [%I]",
1504 rt
.rt_dev
, old_gateway
);
1508 memset (&rt
, '\0', sizeof (rt
));
1509 SET_SA_FAMILY (rt
.rt_dst
, AF_INET
);
1510 SET_SA_FAMILY (rt
.rt_gateway
, AF_INET
);
1512 if (kernel_version
> KVERSION(2,1,0)) {
1513 SET_SA_FAMILY (rt
.rt_genmask
, AF_INET
);
1514 SIN_ADDR(rt
.rt_genmask
) = 0L;
1517 SIN_ADDR(rt
.rt_gateway
) = gateway
;
1519 rt
.rt_flags
= RTF_UP
| RTF_GATEWAY
;
1520 if (ioctl(sock_fd
, SIOCADDRT
, &rt
) < 0) {
1521 if ( ! ok_error ( errno
))
1522 error("default route ioctl(SIOCADDRT): %m(%d)", errno
);
1526 default_route_gateway
= gateway
;
1530 /********************************************************************
1532 * cifdefaultroute - delete a default route through the address given.
1535 int cifdefaultroute (int unit
, u_int32_t ouraddr
, u_int32_t gateway
)
1539 default_route_gateway
= 0;
1541 memset (&rt
, '\0', sizeof (rt
));
1542 SET_SA_FAMILY (rt
.rt_dst
, AF_INET
);
1543 SET_SA_FAMILY (rt
.rt_gateway
, AF_INET
);
1545 if (kernel_version
> KVERSION(2,1,0)) {
1546 SET_SA_FAMILY (rt
.rt_genmask
, AF_INET
);
1547 SIN_ADDR(rt
.rt_genmask
) = 0L;
1550 SIN_ADDR(rt
.rt_gateway
) = gateway
;
1552 rt
.rt_flags
= RTF_UP
| RTF_GATEWAY
;
1553 if (ioctl(sock_fd
, SIOCDELRT
, &rt
) < 0 && errno
!= ESRCH
) {
1555 if ( ! ok_error ( errno
))
1556 error("default route ioctl(SIOCDELRT): %m (%d)", errno
);
1564 /********************************************************************
1566 * sifproxyarp - Make a proxy ARP entry for the peer.
1569 int sifproxyarp (int unit
, u_int32_t his_adr
)
1571 struct arpreq arpreq
;
1574 if (has_proxy_arp
== 0) {
1575 memset (&arpreq
, '\0', sizeof(arpreq
));
1577 SET_SA_FAMILY(arpreq
.arp_pa
, AF_INET
);
1578 SIN_ADDR(arpreq
.arp_pa
) = his_adr
;
1579 arpreq
.arp_flags
= ATF_PERM
| ATF_PUBL
;
1581 * Get the hardware address of an interface on the same subnet
1582 * as our local address.
1584 if (!get_ether_addr(his_adr
, &arpreq
.arp_ha
, proxy_arp_dev
,
1585 sizeof(proxy_arp_dev
))) {
1586 error("Cannot determine ethernet address for proxy ARP");
1589 strlcpy(arpreq
.arp_dev
, proxy_arp_dev
, sizeof(arpreq
.arp_dev
));
1591 if (ioctl(sock_fd
, SIOCSARP
, (caddr_t
)&arpreq
) < 0) {
1592 if ( ! ok_error ( errno
))
1593 error("ioctl(SIOCSARP): %m(%d)", errno
);
1596 proxy_arp_addr
= his_adr
;
1600 forw_path
= path_to_procfs("/sys/net/ipv4/ip_forward");
1601 if (forw_path
!= 0) {
1602 int fd
= open(forw_path
, O_WRONLY
);
1604 if (write(fd
, "1", 1) != 1)
1605 error("Couldn't enable IP forwarding: %m");
1615 /********************************************************************
1617 * cifproxyarp - Delete the proxy ARP entry for the peer.
1620 int cifproxyarp (int unit
, u_int32_t his_adr
)
1622 struct arpreq arpreq
;
1624 if (has_proxy_arp
) {
1626 memset (&arpreq
, '\0', sizeof(arpreq
));
1627 SET_SA_FAMILY(arpreq
.arp_pa
, AF_INET
);
1628 SIN_ADDR(arpreq
.arp_pa
) = his_adr
;
1629 arpreq
.arp_flags
= ATF_PERM
| ATF_PUBL
;
1630 strlcpy(arpreq
.arp_dev
, proxy_arp_dev
, sizeof(arpreq
.arp_dev
));
1632 if (ioctl(sock_fd
, SIOCDARP
, (caddr_t
)&arpreq
) < 0) {
1633 if ( ! ok_error ( errno
))
1634 warn("ioctl(SIOCDARP): %m(%d)", errno
);
1641 /********************************************************************
1643 * get_ether_addr - get the hardware address of an interface on the
1644 * the same subnet as ipaddr.
1647 static int get_ether_addr (u_int32_t ipaddr
,
1648 struct sockaddr
*hwaddr
,
1649 char *name
, int namelen
)
1651 struct ifreq
*ifr
, *ifend
;
1652 u_int32_t ina
, mask
;
1656 struct ifreq ifs
[MAX_IFS
];
1658 ifc
.ifc_len
= sizeof(ifs
);
1660 if (ioctl(sock_fd
, SIOCGIFCONF
, &ifc
) < 0) {
1661 if ( ! ok_error ( errno
))
1662 error("ioctl(SIOCGIFCONF): %m(%d)", errno
);
1666 SYSDEBUG ((LOG_DEBUG
, "proxy arp: scanning %d interfaces for IP %s",
1667 ifc
.ifc_len
/ sizeof(struct ifreq
), ip_ntoa(ipaddr
)));
1669 * Scan through looking for an interface with an Internet
1670 * address on the same subnet as `ipaddr'.
1672 ifend
= ifs
+ (ifc
.ifc_len
/ sizeof(struct ifreq
));
1673 for (ifr
= ifc
.ifc_req
; ifr
< ifend
; ifr
++) {
1674 if (ifr
->ifr_addr
.sa_family
== AF_INET
) {
1675 ina
= SIN_ADDR(ifr
->ifr_addr
);
1676 strlcpy(ifreq
.ifr_name
, ifr
->ifr_name
, sizeof(ifreq
.ifr_name
));
1677 SYSDEBUG ((LOG_DEBUG
, "proxy arp: examining interface %s",
1680 * Check that the interface is up, and not point-to-point
1683 if (ioctl(sock_fd
, SIOCGIFFLAGS
, &ifreq
) < 0)
1686 if (((ifreq
.ifr_flags
^ FLAGS_GOOD
) & FLAGS_MASK
) != 0)
1689 * Get its netmask and check that it's on the right subnet.
1691 if (ioctl(sock_fd
, SIOCGIFNETMASK
, &ifreq
) < 0)
1694 mask
= SIN_ADDR(ifreq
.ifr_addr
);
1695 SYSDEBUG ((LOG_DEBUG
, "proxy arp: interface addr %s mask %lx",
1696 ip_ntoa(ina
), ntohl(mask
)));
1698 if (((ipaddr
^ ina
) & mask
) != 0)
1707 strlcpy(name
, ifreq
.ifr_name
, namelen
);
1709 /* trim off the :1 in eth0:1 */
1710 aliasp
= strchr(name
, ':');
1714 info("found interface %s for proxy arp", name
);
1716 * Now get the hardware address.
1718 memset (&ifreq
.ifr_hwaddr
, 0, sizeof (struct sockaddr
));
1719 if (ioctl (sock_fd
, SIOCGIFHWADDR
, &ifreq
) < 0) {
1720 error("SIOCGIFHWADDR(%s): %m(%d)", ifreq
.ifr_name
, errno
);
1726 sizeof (struct sockaddr
));
1728 SYSDEBUG ((LOG_DEBUG
,
1729 "proxy arp: found hwaddr %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
1730 (int) ((unsigned char *) &hwaddr
->sa_data
)[0],
1731 (int) ((unsigned char *) &hwaddr
->sa_data
)[1],
1732 (int) ((unsigned char *) &hwaddr
->sa_data
)[2],
1733 (int) ((unsigned char *) &hwaddr
->sa_data
)[3],
1734 (int) ((unsigned char *) &hwaddr
->sa_data
)[4],
1735 (int) ((unsigned char *) &hwaddr
->sa_data
)[5],
1736 (int) ((unsigned char *) &hwaddr
->sa_data
)[6],
1737 (int) ((unsigned char *) &hwaddr
->sa_data
)[7]));
1742 * get_if_hwaddr - get the hardware address for the specified
1743 * network interface device.
1746 get_if_hwaddr(u_char
*addr
, char *name
)
1751 sock_fd
= socket(AF_INET
, SOCK_DGRAM
, 0);
1754 memset(&ifreq
.ifr_hwaddr
, 0, sizeof(struct sockaddr
));
1755 strlcpy(ifreq
.ifr_name
, name
, sizeof(ifreq
.ifr_name
));
1756 ret
= ioctl(sock_fd
, SIOCGIFHWADDR
, &ifreq
);
1759 memcpy(addr
, ifreq
.ifr_hwaddr
.sa_data
, 6);
1764 * get_first_ethernet - return the name of the first ethernet-style
1765 * interface on this system.
1768 get_first_ethernet()
1773 /********************************************************************
1775 * Return user specified netmask, modified by any mask we might determine
1776 * for address `addr' (in network byte order).
1777 * Here we scan through the system's list of interfaces, looking for
1778 * any non-point-to-point interfaces which might appear to be on the same
1779 * network as `addr'. If we find any, we OR in their netmask to the
1780 * user-specified netmask.
1783 u_int32_t
GetMask (u_int32_t addr
)
1785 u_int32_t mask
, nmask
, ina
;
1786 struct ifreq
*ifr
, *ifend
, ifreq
;
1788 struct ifreq ifs
[MAX_IFS
];
1792 if (IN_CLASSA(addr
)) /* determine network mask for address class */
1793 nmask
= IN_CLASSA_NET
;
1794 else if (IN_CLASSB(addr
))
1795 nmask
= IN_CLASSB_NET
;
1797 nmask
= IN_CLASSC_NET
;
1799 /* class D nets are disallowed by bad_ip_adrs */
1800 mask
= netmask
| htonl(nmask
);
1802 * Scan through the system's network interfaces.
1804 ifc
.ifc_len
= sizeof(ifs
);
1806 if (ioctl(sock_fd
, SIOCGIFCONF
, &ifc
) < 0) {
1807 if ( ! ok_error ( errno
))
1808 warn("ioctl(SIOCGIFCONF): %m(%d)", errno
);
1812 ifend
= (struct ifreq
*) (ifc
.ifc_buf
+ ifc
.ifc_len
);
1813 for (ifr
= ifc
.ifc_req
; ifr
< ifend
; ifr
++) {
1815 * Check the interface's internet address.
1817 if (ifr
->ifr_addr
.sa_family
!= AF_INET
)
1819 ina
= SIN_ADDR(ifr
->ifr_addr
);
1820 if (((ntohl(ina
) ^ addr
) & nmask
) != 0)
1823 * Check that the interface is up, and not point-to-point nor loopback.
1825 strlcpy(ifreq
.ifr_name
, ifr
->ifr_name
, sizeof(ifreq
.ifr_name
));
1826 if (ioctl(sock_fd
, SIOCGIFFLAGS
, &ifreq
) < 0)
1829 if (((ifreq
.ifr_flags
^ FLAGS_GOOD
) & FLAGS_MASK
) != 0)
1832 * Get its netmask and OR it into our mask.
1834 if (ioctl(sock_fd
, SIOCGIFNETMASK
, &ifreq
) < 0)
1836 mask
|= SIN_ADDR(ifreq
.ifr_addr
);
1842 /********************************************************************
1844 * Internal routine to decode the version.modification.patch level
1847 static void decode_version (char *buf
, int *version
,
1848 int *modification
, int *patch
)
1852 *version
= (int) strtoul (buf
, &endp
, 10);
1856 if (endp
!= buf
&& *endp
== '.') {
1858 *modification
= (int) strtoul (buf
, &endp
, 10);
1859 if (endp
!= buf
&& *endp
== '.') {
1861 *patch
= (int) strtoul (buf
, &buf
, 10);
1866 /********************************************************************
1868 * Procedure to determine if the PPP line discipline is registered.
1872 ppp_registered(void)
1880 * We used to open the serial device and set it to the ppp line
1881 * discipline here, in order to create a ppp unit. But that is
1882 * not a good idea - the user might have specified a device that
1883 * they can't open (permission, or maybe it doesn't really exist).
1884 * So we grab a pty master/slave pair and use that.
1886 if (!get_pty(&mfd
, &local_fd
, slave
, 0)) {
1887 no_ppp_msg
= "Couldn't determine if PPP is supported (no free ptys)";
1892 * Try to put the device into the PPP discipline.
1894 if (ioctl(local_fd
, TIOCSETD
, &ppp_disc
) < 0) {
1895 error("ioctl(TIOCSETD(PPP)): %m(%d)", errno
);
1904 /********************************************************************
1906 * ppp_available - check whether the system has any ppp interfaces
1907 * (in fact we check whether we can do an ioctl on ppp0).
1910 int ppp_available(void)
1915 int my_version
, my_modification
, my_patch
;
1916 int osmaj
, osmin
, ospatch
;
1919 "This system lacks kernel support for PPP. This could be because\n"
1920 "the PPP kernel module could not be loaded, or because PPP was not\n"
1921 "included in the kernel configuration. If PPP was included as a\n"
1922 "module, try `/sbin/modprobe -v ppp'. If that fails, check that\n"
1923 "ppp.o exists in /lib/modules/`uname -r`/net.\n"
1924 "See README.linux file in the ppp distribution for more details.\n";
1926 /* get the kernel version now, since we are called before sys_init */
1928 osmaj
= osmin
= ospatch
= 0;
1929 sscanf(utsname
.release
, "%d.%d.%d", &osmaj
, &osmin
, &ospatch
);
1930 kernel_version
= KVERSION(osmaj
, osmin
, ospatch
);
1932 fd
= open("/dev/ppp", O_RDWR
);
1934 new_style_driver
= 1;
1937 driver_modification
= 4;
1942 if (kernel_version
>= KVERSION(2,3,13)) {
1943 if (errno
== ENOENT
)
1945 "pppd is unable to open the /dev/ppp device.\n"
1946 "You need to create the /dev/ppp device node by\n"
1947 "executing the following command as root:\n"
1948 " mknod /dev/ppp c 108 0\n";
1953 * Open a socket for doing the ioctl operations.
1955 s
= socket(AF_INET
, SOCK_DGRAM
, 0);
1959 strlcpy (ifr
.ifr_name
, "ppp0", sizeof (ifr
.ifr_name
));
1960 ok
= ioctl(s
, SIOCGIFFLAGS
, (caddr_t
) &ifr
) >= 0;
1962 * If the device did not exist then attempt to create one by putting the
1963 * current tty into the PPP discipline. If this works then obtain the
1964 * flags for the device again.
1967 if (ppp_registered()) {
1968 strlcpy (ifr
.ifr_name
, "ppp0", sizeof (ifr
.ifr_name
));
1969 ok
= ioctl(s
, SIOCGIFFLAGS
, (caddr_t
) &ifr
) >= 0;
1973 * Ensure that the hardware address is for PPP and not something else
1976 ok
= ioctl (s
, SIOCGIFHWADDR
, (caddr_t
) &ifr
) >= 0;
1978 if (ok
&& ((ifr
.ifr_hwaddr
.sa_family
& ~0xFF) != ARPHRD_PPP
))
1982 * This is the PPP device. Validate the version of the driver at this
1983 * point to ensure that this program will work with the driver.
1986 char abBuffer
[1024];
1988 ifr
.ifr_data
= abBuffer
;
1989 size
= ioctl (s
, SIOCGPPPVER
, (caddr_t
) &ifr
);
1991 error("Couldn't read driver version: %m");
1993 no_ppp_msg
= "Sorry, couldn't verify kernel driver version\n";
1996 decode_version(abBuffer
,
1998 &driver_modification
,
2001 * Validate the version of the driver against the version that we used.
2003 decode_version(VERSION
,
2008 /* The version numbers must match */
2009 if (driver_version
!= my_version
)
2012 /* The modification levels must be legal */
2013 if (driver_modification
< 3) {
2014 if (driver_modification
>= 2) {
2015 /* we can cope with 2.2.0 and above */
2024 slprintf(route_buffer
, sizeof(route_buffer
),
2025 "Sorry - PPP driver version %d.%d.%d is out of date\n",
2026 driver_version
, driver_modification
, driver_patch
);
2028 no_ppp_msg
= route_buffer
;
2035 /********************************************************************
2037 * Update the wtmp file with the appropriate user name and tty device.
2040 void logwtmp (const char *line
, const char *name
, const char *host
)
2042 struct utmp ut
, *utp
;
2043 pid_t mypid
= getpid();
2049 * Update the signon database for users.
2050 * Christoph Lameter: Copied from poeigl-1.36 Jan 3, 1996
2052 utmpname(_PATH_UTMP
);
2054 while ((utp
= getutent()) && (utp
->ut_pid
!= mypid
))
2057 /* Is this call really necessary? There is another one after the 'put' */
2061 memcpy(&ut
, utp
, sizeof(ut
));
2063 /* some gettys/telnetds don't initialize utmp... */
2064 memset(&ut
, 0, sizeof(ut
));
2066 if (ut
.ut_id
[0] == 0)
2067 strncpy(ut
.ut_id
, line
+ 3, sizeof(ut
.ut_id
));
2069 strncpy(ut
.ut_user
, name
, sizeof(ut
.ut_user
));
2070 strncpy(ut
.ut_line
, line
, sizeof(ut
.ut_line
));
2074 ut
.ut_type
= USER_PROCESS
;
2077 /* Insert the host name if one is supplied */
2079 strncpy (ut
.ut_host
, host
, sizeof(ut
.ut_host
));
2081 /* Insert the IP address of the remote system if IP is enabled */
2082 if (ipcp_protent
.enabled_flag
&& ipcp_hisoptions
[0].neg_addr
)
2083 memcpy(&ut
.ut_addr
, (char *) &ipcp_hisoptions
[0].hisaddr
,
2084 sizeof(ut
.ut_addr
));
2086 /* CL: Makes sure that the logout works */
2087 if (*host
== 0 && *name
==0)
2093 * Update the wtmp file.
2096 updwtmp(_PATH_WTMP
, &ut
);
2098 wtmp
= open(_PATH_WTMP
, O_APPEND
|O_WRONLY
);
2100 flock(wtmp
, LOCK_EX
);
2102 if (write (wtmp
, (char *)&ut
, sizeof(ut
)) != sizeof(ut
))
2103 warn("error writing %s: %m", _PATH_WTMP
);
2105 flock(wtmp
, LOCK_UN
);
2113 /********************************************************************
2115 * sifvjcomp - config tcp header compression
2118 int sifvjcomp (int u
, int vjcomp
, int cidcomp
, int maxcid
)
2120 u_int x
= get_flags(ppp_dev_fd
);
2123 if (ioctl (ppp_dev_fd
, PPPIOCSMAXCID
, (caddr_t
) &maxcid
) < 0) {
2124 if (! ok_error (errno
))
2125 error("ioctl(PPPIOCSMAXCID): %m(%d)", errno
);
2130 x
= vjcomp
? x
| SC_COMP_TCP
: x
&~ SC_COMP_TCP
;
2131 x
= cidcomp
? x
& ~SC_NO_TCP_CCID
: x
| SC_NO_TCP_CCID
;
2132 set_flags (ppp_dev_fd
, x
);
2137 /********************************************************************
2139 * sifup - Config the interface up and enable IP packets to pass.
2146 memset (&ifr
, '\0', sizeof (ifr
));
2147 strlcpy(ifr
.ifr_name
, ifname
, sizeof (ifr
.ifr_name
));
2148 if (ioctl(sock_fd
, SIOCGIFFLAGS
, (caddr_t
) &ifr
) < 0) {
2149 if (! ok_error (errno
))
2150 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno
);
2154 ifr
.ifr_flags
|= (IFF_UP
| IFF_POINTOPOINT
);
2155 if (ioctl(sock_fd
, SIOCSIFFLAGS
, (caddr_t
) &ifr
) < 0) {
2156 if (! ok_error (errno
))
2157 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno
);
2165 /********************************************************************
2167 * sifdown - Disable the indicated protocol and config the interface
2168 * down if there are no remaining protocols.
2175 if (if_is_up
&& --if_is_up
> 0)
2178 memset (&ifr
, '\0', sizeof (ifr
));
2179 strlcpy(ifr
.ifr_name
, ifname
, sizeof (ifr
.ifr_name
));
2180 if (ioctl(sock_fd
, SIOCGIFFLAGS
, (caddr_t
) &ifr
) < 0) {
2181 if (! ok_error (errno
))
2182 error("ioctl (SIOCGIFFLAGS): %m(%d)", errno
);
2186 ifr
.ifr_flags
&= ~IFF_UP
;
2187 ifr
.ifr_flags
|= IFF_POINTOPOINT
;
2188 if (ioctl(sock_fd
, SIOCSIFFLAGS
, (caddr_t
) &ifr
) < 0) {
2189 if (! ok_error (errno
))
2190 error("ioctl(SIOCSIFFLAGS): %m(%d)", errno
);
2196 /********************************************************************
2198 * sifaddr - Config the interface IP addresses and netmask.
2201 int sifaddr (int unit
, u_int32_t our_adr
, u_int32_t his_adr
,
2207 memset (&ifr
, '\0', sizeof (ifr
));
2208 memset (&rt
, '\0', sizeof (rt
));
2210 SET_SA_FAMILY (ifr
.ifr_addr
, AF_INET
);
2211 SET_SA_FAMILY (ifr
.ifr_dstaddr
, AF_INET
);
2212 SET_SA_FAMILY (ifr
.ifr_netmask
, AF_INET
);
2214 strlcpy (ifr
.ifr_name
, ifname
, sizeof (ifr
.ifr_name
));
2216 * Set our IP address
2218 SIN_ADDR(ifr
.ifr_addr
) = our_adr
;
2219 if (ioctl(sock_fd
, SIOCSIFADDR
, (caddr_t
) &ifr
) < 0) {
2220 if (errno
!= EEXIST
) {
2221 if (! ok_error (errno
))
2222 error("ioctl(SIOCSIFADDR): %m(%d)", errno
);
2225 warn("ioctl(SIOCSIFADDR): Address already exists");
2230 * Set the gateway address
2232 SIN_ADDR(ifr
.ifr_dstaddr
) = his_adr
;
2233 if (ioctl(sock_fd
, SIOCSIFDSTADDR
, (caddr_t
) &ifr
) < 0) {
2234 if (! ok_error (errno
))
2235 error("ioctl(SIOCSIFDSTADDR): %m(%d)", errno
);
2240 * For recent kernels, force the netmask to 255.255.255.255.
2242 if (kernel_version
>= KVERSION(2,1,16))
2244 if (net_mask
!= 0) {
2245 SIN_ADDR(ifr
.ifr_netmask
) = net_mask
;
2246 if (ioctl(sock_fd
, SIOCSIFNETMASK
, (caddr_t
) &ifr
) < 0) {
2247 if (! ok_error (errno
))
2248 error("ioctl(SIOCSIFNETMASK): %m(%d)", errno
);
2253 * Add the device route
2255 if (kernel_version
< KVERSION(2,1,16)) {
2256 SET_SA_FAMILY (rt
.rt_dst
, AF_INET
);
2257 SET_SA_FAMILY (rt
.rt_gateway
, AF_INET
);
2260 SIN_ADDR(rt
.rt_gateway
) = 0L;
2261 SIN_ADDR(rt
.rt_dst
) = his_adr
;
2262 rt
.rt_flags
= RTF_UP
| RTF_HOST
;
2264 if (kernel_version
> KVERSION(2,1,0)) {
2265 SET_SA_FAMILY (rt
.rt_genmask
, AF_INET
);
2266 SIN_ADDR(rt
.rt_genmask
) = -1L;
2269 if (ioctl(sock_fd
, SIOCADDRT
, &rt
) < 0) {
2270 if (! ok_error (errno
))
2271 error("ioctl(SIOCADDRT) device route: %m(%d)", errno
);
2276 /* set ip_dynaddr in demand mode if address changes */
2277 if (demand
&& tune_kernel
&& !dynaddr_set
2278 && our_old_addr
&& our_old_addr
!= our_adr
) {
2279 /* set ip_dynaddr if possible */
2283 path
= path_to_procfs("/sys/net/ipv4/ip_dynaddr");
2284 if (path
!= 0 && (fd
= open(path
, O_WRONLY
)) >= 0) {
2285 if (write(fd
, "1", 1) != 1)
2286 error("Couldn't enable dynamic IP addressing: %m");
2289 dynaddr_set
= 1; /* only 1 attempt */
2296 /********************************************************************
2298 * cifaddr - Clear the interface IP addresses, and delete routes
2299 * through the interface if possible.
2302 int cifaddr (int unit
, u_int32_t our_adr
, u_int32_t his_adr
)
2306 if (kernel_version
< KVERSION(2,1,16)) {
2308 * Delete the route through the device
2311 memset (&rt
, '\0', sizeof (rt
));
2313 SET_SA_FAMILY (rt
.rt_dst
, AF_INET
);
2314 SET_SA_FAMILY (rt
.rt_gateway
, AF_INET
);
2317 SIN_ADDR(rt
.rt_gateway
) = 0;
2318 SIN_ADDR(rt
.rt_dst
) = his_adr
;
2319 rt
.rt_flags
= RTF_UP
| RTF_HOST
;
2321 if (kernel_version
> KVERSION(2,1,0)) {
2322 SET_SA_FAMILY (rt
.rt_genmask
, AF_INET
);
2323 SIN_ADDR(rt
.rt_genmask
) = -1L;
2326 if (ioctl(sock_fd
, SIOCDELRT
, &rt
) < 0 && errno
!= ESRCH
) {
2327 if (still_ppp() && ! ok_error (errno
))
2328 error("ioctl(SIOCDELRT) device route: %m(%d)", errno
);
2333 /* This way it is possible to have an IPX-only or IPv6-only interface */
2334 memset(&ifr
, 0, sizeof(ifr
));
2335 SET_SA_FAMILY(ifr
.ifr_addr
, AF_INET
);
2336 strlcpy(ifr
.ifr_name
, ifname
, sizeof(ifr
.ifr_name
));
2338 if (ioctl(sock_fd
, SIOCSIFADDR
, (caddr_t
) &ifr
) < 0) {
2339 if (! ok_error (errno
)) {
2340 error("ioctl(SIOCSIFADDR): %m(%d)", errno
);
2345 our_old_addr
= our_adr
;
2351 /********************************************************************
2353 * sif6addr - Config the interface with an IPv6 link-local address
2355 int sif6addr (int unit
, eui64_t our_eui64
, eui64_t his_eui64
)
2357 struct in6_ifreq ifr6
;
2359 struct in6_rtmsg rt6
;
2363 error("IPv6 socket creation failed: %m");
2366 memset(&ifr
, 0, sizeof (ifr
));
2367 strlcpy(ifr
.ifr_name
, ifname
, sizeof(ifr
.ifr_name
));
2368 if (ioctl(sock6_fd
, SIOCGIFINDEX
, (caddr_t
) &ifr
) < 0) {
2369 error("sif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno
);
2373 /* Local interface */
2374 memset(&ifr6
, 0, sizeof(ifr6
));
2375 IN6_LLADDR_FROM_EUI64(ifr6
.ifr6_addr
, our_eui64
);
2376 ifr6
.ifr6_ifindex
= ifr
.ifr_ifindex
;
2377 ifr6
.ifr6_prefixlen
= 10;
2379 if (ioctl(sock6_fd
, SIOCSIFADDR
, &ifr6
) < 0) {
2380 error("sif6addr: ioctl(SIOCSIFADDR): %m (%d)", errno
);
2384 /* Route to remote host */
2385 memset(&rt6
, 0, sizeof(rt6
));
2386 IN6_LLADDR_FROM_EUI64(rt6
.rtmsg_dst
, his_eui64
);
2387 rt6
.rtmsg_flags
= RTF_UP
;
2388 rt6
.rtmsg_dst_len
= 10;
2389 rt6
.rtmsg_ifindex
= ifr
.ifr_ifindex
;
2390 rt6
.rtmsg_metric
= 1;
2392 if (ioctl(sock6_fd
, SIOCADDRT
, &rt6
) < 0) {
2393 error("sif6addr: ioctl(SIOCADDRT): %m (%d)", errno
);
2401 /********************************************************************
2403 * cif6addr - Remove IPv6 address from interface
2405 int cif6addr (int unit
, eui64_t our_eui64
, eui64_t his_eui64
)
2408 struct in6_ifreq ifr6
;
2412 error("IPv6 socket creation failed: %m");
2415 memset(&ifr
, 0, sizeof(ifr
));
2416 strlcpy(ifr
.ifr_name
, ifname
, sizeof(ifr
.ifr_name
));
2417 if (ioctl(sock6_fd
, SIOCGIFINDEX
, (caddr_t
) &ifr
) < 0) {
2418 error("cif6addr: ioctl(SIOCGIFINDEX): %m (%d)", errno
);
2422 memset(&ifr6
, 0, sizeof(ifr6
));
2423 IN6_LLADDR_FROM_EUI64(ifr6
.ifr6_addr
, our_eui64
);
2424 ifr6
.ifr6_ifindex
= ifr
.ifr_ifindex
;
2425 ifr6
.ifr6_prefixlen
= 10;
2427 if (ioctl(sock6_fd
, SIOCDIFADDR
, &ifr6
) < 0) {
2428 if (errno
!= EADDRNOTAVAIL
) {
2429 if (! ok_error (errno
))
2430 error("cif6addr: ioctl(SIOCDIFADDR): %m (%d)", errno
);
2433 warn("cif6addr: ioctl(SIOCDIFADDR): No such address");
2442 * get_pty - get a pty master/slave pair and chown the slave side
2443 * to the uid given. Assumes slave_name points to >= 16 bytes of space.
2446 get_pty(master_fdp
, slave_fdp
, slave_name
, uid
)
2452 int i
, mfd
, sfd
= -1;
2454 struct termios tios
;
2458 * Try the unix98 way first.
2460 mfd
= open("/dev/ptmx", O_RDWR
);
2463 if (ioctl(mfd
, TIOCGPTN
, &ptn
) >= 0) {
2464 slprintf(pty_name
, sizeof(pty_name
), "/dev/pts/%d", ptn
);
2465 chmod(pty_name
, S_IRUSR
| S_IWUSR
);
2468 if (ioctl(mfd
, TIOCSPTLCK
, &ptn
) < 0)
2469 warn("Couldn't unlock pty slave %s: %m", pty_name
);
2471 if ((sfd
= open(pty_name
, O_RDWR
| O_NOCTTY
)) < 0)
2472 warn("Couldn't open pty slave %s: %m", pty_name
);
2475 #endif /* TIOCGPTN */
2478 /* the old way - scan through the pty name space */
2479 for (i
= 0; i
< 64; ++i
) {
2480 slprintf(pty_name
, sizeof(pty_name
), "/dev/pty%c%x",
2481 'p' + i
/ 16, i
% 16);
2482 mfd
= open(pty_name
, O_RDWR
, 0);
2485 sfd
= open(pty_name
, O_RDWR
| O_NOCTTY
, 0);
2487 fchown(sfd
, uid
, -1);
2488 fchmod(sfd
, S_IRUSR
| S_IWUSR
);
2499 strlcpy(slave_name
, pty_name
, 16);
2502 if (tcgetattr(sfd
, &tios
) == 0) {
2503 tios
.c_cflag
&= ~(CSIZE
| CSTOPB
| PARENB
);
2504 tios
.c_cflag
|= CS8
| CREAD
| CLOCAL
;
2505 tios
.c_iflag
= IGNPAR
;
2508 if (tcsetattr(sfd
, TCSAFLUSH
, &tios
) < 0)
2509 warn("couldn't set attributes on pty: %m");
2511 warn("couldn't get attributes on pty: %m");
2516 /********************************************************************
2518 * open_loopback - open the device we use for getting packets
2519 * in demand mode. Under Linux, we use a pty master/slave pair.
2522 open_ppp_loopback(void)
2527 if (new_style_driver
) {
2528 /* allocate ourselves a ppp unit */
2529 if (make_ppp_unit() < 0)
2531 set_flags(ppp_dev_fd
, SC_LOOP_TRAFFIC
);
2532 set_kdebugflag(kdebugflag
);
2537 if (!get_pty(&master_fd
, &slave_fd
, loop_name
, 0))
2538 fatal("No free pty for loopback");
2539 SYSDEBUG(("using %s for loopback", loop_name
));
2541 set_ppp_fd(slave_fd
);
2543 flags
= fcntl(master_fd
, F_GETFL
);
2545 fcntl(master_fd
, F_SETFL
, flags
| O_NONBLOCK
) == -1)
2546 warn("couldn't set master loopback to nonblock: %m(%d)", errno
);
2548 flags
= fcntl(ppp_fd
, F_GETFL
);
2550 fcntl(ppp_fd
, F_SETFL
, flags
| O_NONBLOCK
) == -1)
2551 warn("couldn't set slave loopback to nonblock: %m(%d)", errno
);
2553 if (ioctl(ppp_fd
, TIOCSETD
, &ppp_disc
) < 0)
2554 fatal("ioctl(TIOCSETD): %m(%d)", errno
);
2556 * Find out which interface we were given.
2558 if (ioctl(ppp_fd
, PPPIOCGUNIT
, &ifunit
) < 0)
2559 fatal("ioctl(PPPIOCGUNIT): %m(%d)", errno
);
2561 * Enable debug in the driver if requested.
2563 set_kdebugflag (kdebugflag
);
2568 /********************************************************************
2570 * restore_loop - reattach the ppp unit to the loopback.
2572 * The kernel ppp driver automatically reattaches the ppp unit to
2573 * the loopback if the serial port is set to a line discipline other
2574 * than ppp, or if it detects a modem hangup. The former will happen
2575 * in disestablish_ppp if the latter hasn't already happened, so we
2576 * shouldn't need to do anything.
2578 * Just to be sure, set the real serial port to the normal discipline.
2585 if (new_style_driver
) {
2586 set_flags(ppp_dev_fd
, get_flags(ppp_dev_fd
) | SC_LOOP_TRAFFIC
);
2589 if (ppp_fd
!= slave_fd
) {
2590 (void) ioctl(ppp_fd
, TIOCSETD
, &tty_disc
);
2591 set_ppp_fd(slave_fd
);
2595 /********************************************************************
2597 * sifnpmode - Set the mode for handling packets for a given NP.
2601 sifnpmode(u
, proto
, mode
)
2608 npi
.protocol
= proto
;
2610 if (ioctl(ppp_dev_fd
, PPPIOCSNPMODE
, (caddr_t
) &npi
) < 0) {
2611 if (! ok_error (errno
))
2612 error("ioctl(PPPIOCSNPMODE, %d, %d): %m (%d)",
2613 proto
, mode
, errno
);
2620 /********************************************************************
2622 * sipxfaddr - Config the interface IPX networknumber
2625 int sipxfaddr (int unit
, unsigned long int network
, unsigned char * node
)
2632 struct sockaddr_ipx
*sipx
= (struct sockaddr_ipx
*) &ifr
.ifr_addr
;
2634 skfd
= socket (AF_IPX
, SOCK_DGRAM
, 0);
2636 if (! ok_error (errno
))
2637 dbglog("socket(AF_IPX): %m (%d)", errno
);
2641 memset (&ifr
, '\0', sizeof (ifr
));
2642 strlcpy (ifr
.ifr_name
, ifname
, sizeof(ifr
.ifr_name
));
2644 memcpy (sipx
->sipx_node
, node
, IPX_NODE_LEN
);
2645 sipx
->sipx_family
= AF_IPX
;
2646 sipx
->sipx_port
= 0;
2647 sipx
->sipx_network
= htonl (network
);
2648 sipx
->sipx_type
= IPX_FRAME_ETHERII
;
2649 sipx
->sipx_action
= IPX_CRTITF
;
2651 * Set the IPX device
2653 if (ioctl(skfd
, SIOCSIFADDR
, (caddr_t
) &ifr
) < 0) {
2655 if (errno
!= EEXIST
) {
2656 if (! ok_error (errno
))
2657 dbglog("ioctl(SIOCSIFADDR, CRTITF): %m (%d)", errno
);
2660 warn("ioctl(SIOCSIFADDR, CRTITF): Address already exists");
2669 /********************************************************************
2671 * cipxfaddr - Clear the information for the IPX network. The IPX routes
2672 * are removed and the device is no longer able to pass IPX
2676 int cipxfaddr (int unit
)
2683 struct sockaddr_ipx
*sipx
= (struct sockaddr_ipx
*) &ifr
.ifr_addr
;
2685 skfd
= socket (AF_IPX
, SOCK_DGRAM
, 0);
2687 if (! ok_error (errno
))
2688 dbglog("socket(AF_IPX): %m (%d)", errno
);
2692 memset (&ifr
, '\0', sizeof (ifr
));
2693 strlcpy (ifr
.ifr_name
, ifname
, sizeof(ifr
.ifr_name
));
2695 sipx
->sipx_type
= IPX_FRAME_ETHERII
;
2696 sipx
->sipx_action
= IPX_DLTITF
;
2697 sipx
->sipx_family
= AF_IPX
;
2699 * Set the IPX device
2701 if (ioctl(skfd
, SIOCSIFADDR
, (caddr_t
) &ifr
) < 0) {
2702 if (! ok_error (errno
))
2703 info("ioctl(SIOCSIFADDR, IPX_DLTITF): %m (%d)", errno
);
2713 * Use the hostname as part of the random number seed.
2722 for (p
= hostname
; *p
!= 0; ++p
)
2727 /********************************************************************
2729 * sys_check_options - check the options that the user specified
2733 sys_check_options(void)
2737 * Disable the IPX protocol if the support is not present in the kernel.
2741 if (ipxcp_protent
.enabled_flag
) {
2742 struct stat stat_buf
;
2743 if ((path
= path_to_procfs("/net/ipx_interface")) == 0
2744 || lstat(path
, &stat_buf
) < 0) {
2745 error("IPX support is not present in the kernel\n");
2746 ipxcp_protent
.enabled_flag
= 0;
2750 if (demand
&& driver_is_old
) {
2751 option_error("demand dialling is not supported by kernel driver "
2752 "version %d.%d.%d", driver_version
, driver_modification
,
2756 if (multilink
&& !new_style_driver
) {
2757 warn("Warning: multilink is not supported by the kernel driver");