Generally use NULL instead of explicitly casting 0 to some pointer type (part2).
[dragonfly.git] / usr.sbin / pppd / sys-bsd.c
CommitLineData
984263bc
MD
1/*
2 * sys-bsd.c - System-dependent procedures for setting up
3 * PPP interfaces on bsd-4.4-ish systems (including 386BSD, NetBSD, etc.)
4 *
5 * Copyright (c) 1989 Carnegie Mellon University.
6 * Copyright (c) 1995 The Australian National University.
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms are permitted
10 * provided that the above copyright notice and this paragraph are
11 * duplicated in all such forms and that any documentation,
12 * advertising materials, and other materials related to such
13 * distribution and use acknowledge that the software was developed
14 * by Carnegie Mellon University and The Australian National University.
15 * The names of the Universities may not be used to endorse or promote
16 * products derived from this software without specific prior written
17 * permission.
18 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
19 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
20 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
1de703da
MD
21 *
22 * $FreeBSD: src/usr.sbin/pppd/sys-bsd.c,v 1.17.2.1 2002/09/17 16:53:55 nectar Exp $
21da1569 23 * $DragonFly: src/usr.sbin/pppd/sys-bsd.c,v 1.6 2005/11/24 23:42:54 swildner Exp $
984263bc
MD
24 */
25
984263bc
MD
26/* $NetBSD: sys-bsd.c,v 1.1.1.3 1997/09/26 18:53:04 christos Exp $ */
27
28/*
29 * TODO:
30 */
31
32#include <stdio.h>
33#include <syslog.h>
34#include <string.h>
35#include <stdlib.h>
36#include <unistd.h>
37#include <errno.h>
38#include <fcntl.h>
39#include <termios.h>
40#include <signal.h>
41#include <sys/ioctl.h>
42#include <sys/types.h>
43#include <sys/socket.h>
44#include <sys/time.h>
45#include <sys/stat.h>
46#include <sys/param.h>
47#ifdef NetBSD1_2
48#include <util.h>
49#endif
50#ifdef PPP_FILTER
51#include <net/bpf.h>
52#endif
53
54#include <net/if.h>
38a690d7
MD
55#include <net/ppp_layer/ppp_defs.h>
56#include <net/ppp/if_ppp.h>
984263bc
MD
57#include <net/route.h>
58#include <net/if_dl.h>
59#include <netinet/in.h>
60
61#ifdef IPX_CHANGE
62#include <netipx/ipx.h>
63#endif
64
65#if RTM_VERSION >= 3
66#include <sys/param.h>
67#if defined(NetBSD) && (NetBSD >= 199703)
68#include <netinet/if_inarp.h>
69#else /* NetBSD 1.2D or later */
3bdde06f 70#ifdef __DragonFly__
984263bc
MD
71#include <netinet/if_ether.h>
72#else
73#include <net/if_ether.h>
74#endif
75#endif
76#endif
77
78#include "pppd.h"
79#include "fsm.h"
80#include "ipcp.h"
81
82static int initdisc = -1; /* Initial TTY discipline for ppp_fd */
83static int initfdflags = -1; /* Initial file descriptor flags for ppp_fd */
84static int ppp_fd = -1; /* fd which is set to PPP discipline */
85static int rtm_seq;
86
87static int restore_term; /* 1 => we've munged the terminal */
88static struct termios inittermios; /* Initial TTY termios */
89static struct winsize wsinfo; /* Initial window size info */
90
91static char *lock_file; /* name of lock file created */
92
93static int loop_slave = -1;
94static int loop_master;
95static char loop_name[20];
96
97static unsigned char inbuf[512]; /* buffer for chars read from loopback */
98
99static int sockfd; /* socket for doing interface ioctls */
100
101static int if_is_up; /* the interface is currently up */
102static u_int32_t ifaddrs[2]; /* local and remote addresses we set */
103static u_int32_t default_route_gateway; /* gateway addr for default route */
104static u_int32_t proxy_arp_addr; /* remote addr for proxy arp */
105
106/* Prototypes for procedures local to this file. */
2d8a3be7
EN
107static int dodefaultroute(u_int32_t, int);
108static int get_ether_addr(u_int32_t, struct sockaddr_dl *);
984263bc
MD
109
110
111/*
112 * sys_init - System-dependent initialization.
113 */
114void
21da1569 115sys_init(void)
984263bc
MD
116{
117 /* Get an internet socket for doing socket ioctl's on. */
118 if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
119 syslog(LOG_ERR, "Couldn't create IP socket: %m");
120 die(1);
121 }
122}
123
124/*
125 * sys_cleanup - restore any system state we modified before exiting:
126 * mark the interface down, delete default route and/or proxy arp entry.
127 * This should call die() because it's called from die().
128 */
129void
21da1569 130sys_cleanup(void)
984263bc
MD
131{
132 struct ifreq ifr;
133
134 if (if_is_up) {
135 strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
136 if (ioctl(sockfd, SIOCGIFFLAGS, &ifr) >= 0
137 && ((ifr.ifr_flags & IFF_UP) != 0)) {
138 ifr.ifr_flags &= ~IFF_UP;
139 ioctl(sockfd, SIOCSIFFLAGS, &ifr);
140 }
141 }
142 if (ifaddrs[0] != 0)
143 cifaddr(0, ifaddrs[0], ifaddrs[1]);
144 if (default_route_gateway)
145 cifdefaultroute(0, 0, default_route_gateway);
146 if (proxy_arp_addr)
147 cifproxyarp(0, proxy_arp_addr);
148}
149
150/*
151 * sys_close - Clean up in a child process before execing.
152 */
153void
21da1569 154sys_close(void)
984263bc
MD
155{
156 close(sockfd);
157 if (loop_slave >= 0) {
158 close(loop_slave);
159 close(loop_master);
160 }
161}
162
163/*
164 * sys_check_options - check the options that the user specified
165 */
166void
21da1569 167sys_check_options(void)
984263bc
MD
168{
169}
170
171/*
172 * ppp_available - check whether the system has any ppp interfaces
173 * (in fact we check whether we can do an ioctl on ppp0).
174 */
175int
21da1569 176ppp_available(void)
984263bc
MD
177{
178 int s, ok;
179 struct ifreq ifr;
180 extern char *no_ppp_msg;
181
182 if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
183 return 1; /* can't tell */
184
185 strncpy(ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
186 ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
187 close(s);
188
189 no_ppp_msg = "\
190This system lacks kernel support for PPP. To include PPP support\n\
191in the kernel, please follow the steps detailed in the README.bsd\n\
192file in the ppp-2.2 distribution.\n";
193 return ok;
194}
195
196/*
197 * establish_ppp - Turn the serial port into a ppp interface.
198 */
199void
21da1569 200establish_ppp(int fd)
984263bc
MD
201{
202 int pppdisc = PPPDISC;
203 int x;
204
205 if (demand) {
206 /*
207 * Demand mode - prime the old ppp device to relinquish the unit.
208 */
209 if (ioctl(ppp_fd, PPPIOCXFERUNIT, 0) < 0) {
210 syslog(LOG_ERR, "ioctl(transfer ppp unit): %m");
211 die(1);
212 }
213 }
214
215 /*
216 * Save the old line discipline of fd, and set it to PPP.
217 */
218 if (ioctl(fd, TIOCGETD, &initdisc) < 0) {
219 syslog(LOG_ERR, "ioctl(TIOCGETD): %m");
220 die(1);
221 }
222 if (ioctl(fd, TIOCSETD, &pppdisc) < 0) {
223 syslog(LOG_ERR, "ioctl(TIOCSETD): %m");
224 die(1);
225 }
226
227 if (!demand) {
228 /*
229 * Find out which interface we were given.
230 */
231 if (ioctl(fd, PPPIOCGUNIT, &ifunit) < 0) {
232 syslog(LOG_ERR, "ioctl(PPPIOCGUNIT): %m");
233 die(1);
234 }
235 } else {
236 /*
237 * Check that we got the same unit again.
238 */
239 if (ioctl(fd, PPPIOCGUNIT, &x) < 0) {
240 syslog(LOG_ERR, "ioctl(PPPIOCGUNIT): %m");
241 die(1);
242 }
243 if (x != ifunit) {
244 syslog(LOG_ERR, "transfer_ppp failed: wanted unit %d, got %d",
245 ifunit, x);
246 die(1);
247 }
248 x = TTYDISC;
249 ioctl(loop_slave, TIOCSETD, &x);
250 }
251
252 ppp_fd = fd;
253
254 /*
255 * Enable debug in the driver if requested.
256 */
257 if (kdebugflag) {
258 if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
259 syslog(LOG_WARNING, "ioctl (PPPIOCGFLAGS): %m");
260 } else {
261 x |= (kdebugflag & 0xFF) * SC_DEBUG;
262 if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &x) < 0)
263 syslog(LOG_WARNING, "ioctl(PPPIOCSFLAGS): %m");
264 }
265 }
266
267 /*
268 * Set device for non-blocking reads.
269 */
270 if ((initfdflags = fcntl(fd, F_GETFL)) == -1
271 || fcntl(fd, F_SETFL, initfdflags | O_NONBLOCK) == -1) {
272 syslog(LOG_WARNING, "Couldn't set device to non-blocking mode: %m");
273 }
274}
275
276/*
277 * restore_loop - reattach the ppp unit to the loopback.
278 */
279void
21da1569 280restore_loop(void)
984263bc
MD
281{
282 int x;
283
284 /*
285 * Transfer the ppp interface back to the loopback.
286 */
287 if (ioctl(ppp_fd, PPPIOCXFERUNIT, 0) < 0) {
288 syslog(LOG_ERR, "ioctl(transfer ppp unit): %m");
289 die(1);
290 }
291 x = PPPDISC;
292 if (ioctl(loop_slave, TIOCSETD, &x) < 0) {
293 syslog(LOG_ERR, "ioctl(TIOCSETD): %m");
294 die(1);
295 }
296
297 /*
298 * Check that we got the same unit again.
299 */
300 if (ioctl(loop_slave, PPPIOCGUNIT, &x) < 0) {
301 syslog(LOG_ERR, "ioctl(PPPIOCGUNIT): %m");
302 die(1);
303 }
304 if (x != ifunit) {
305 syslog(LOG_ERR, "transfer_ppp failed: wanted unit %d, got %d",
306 ifunit, x);
307 die(1);
308 }
309 ppp_fd = loop_slave;
310}
311
312
313/*
314 * disestablish_ppp - Restore the serial port to normal operation.
315 * This shouldn't call die() because it's called from die().
316 */
317void
21da1569 318disestablish_ppp(int fd)
984263bc
MD
319{
320 /* Reset non-blocking mode on fd. */
321 if (initfdflags != -1 && fcntl(fd, F_SETFL, initfdflags) < 0)
322 syslog(LOG_WARNING, "Couldn't restore device fd flags: %m");
323 initfdflags = -1;
324
325 /* Restore old line discipline. */
326 if (initdisc >= 0 && ioctl(fd, TIOCSETD, &initdisc) < 0)
327 syslog(LOG_ERR, "ioctl(TIOCSETD): %m");
328 initdisc = -1;
329
330 if (fd == ppp_fd)
331 ppp_fd = -1;
332}
333
334/*
335 * Check whether the link seems not to be 8-bit clean.
336 */
337void
21da1569 338clean_check(void)
984263bc
MD
339{
340 int x;
341 char *s;
342
343 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
344 s = NULL;
345 switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
346 case SC_RCV_B7_0:
347 s = "bit 7 set to 1";
348 break;
349 case SC_RCV_B7_1:
350 s = "bit 7 set to 0";
351 break;
352 case SC_RCV_EVNP:
353 s = "odd parity";
354 break;
355 case SC_RCV_ODDP:
356 s = "even parity";
357 break;
358 }
359 if (s != NULL) {
360 syslog(LOG_WARNING, "Serial link is not 8-bit clean:");
361 syslog(LOG_WARNING, "All received characters had %s", s);
362 }
363 }
364}
365
366/*
367 * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
368 * at the requested speed, etc. If `local' is true, set CLOCAL
369 * regardless of whether the modem option was specified.
370 *
371 * For *BSD, we assume that speed_t values numerically equal bits/second.
372 */
373void
21da1569 374set_up_tty(int fd, int local)
984263bc
MD
375{
376 struct termios tios;
377
378 if (tcgetattr(fd, &tios) < 0) {
379 syslog(LOG_ERR, "tcgetattr: %m");
380 die(1);
381 }
382
383 if (!restore_term) {
384 inittermios = tios;
385 ioctl(fd, TIOCGWINSZ, &wsinfo);
386 }
387
388 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL);
389 if (crtscts > 0 && !local)
390 tios.c_cflag |= CRTSCTS;
391 else if (crtscts < 0)
392 tios.c_cflag &= ~CRTSCTS;
393
394 tios.c_cflag |= CS8 | CREAD | HUPCL;
395 if (local || !modem)
396 tios.c_cflag |= CLOCAL;
397 tios.c_iflag = IGNBRK | IGNPAR;
398 tios.c_oflag = 0;
399 tios.c_lflag = 0;
400 tios.c_cc[VMIN] = 1;
401 tios.c_cc[VTIME] = 0;
402
403 if (crtscts == -2) {
404 tios.c_iflag |= IXON | IXOFF;
405 tios.c_cc[VSTOP] = 0x13; /* DC3 = XOFF = ^S */
406 tios.c_cc[VSTART] = 0x11; /* DC1 = XON = ^Q */
407 }
408
409 if (inspeed) {
410 cfsetospeed(&tios, inspeed);
411 cfsetispeed(&tios, inspeed);
412 } else {
413 inspeed = cfgetospeed(&tios);
414 /*
415 * We can't proceed if the serial port speed is 0,
416 * since that implies that the serial port is disabled.
417 */
418 if (inspeed == 0) {
419 syslog(LOG_ERR, "Baud rate for %s is 0; need explicit baud rate",
420 devnam);
421 die(1);
422 }
423 }
424 baud_rate = inspeed;
425
426 if (tcsetattr(fd, TCSAFLUSH, &tios) < 0) {
427 syslog(LOG_ERR, "tcsetattr: %m");
428 die(1);
429 }
430
431 restore_term = 1;
432}
433
434/*
435 * restore_tty - restore the terminal to the saved settings.
436 */
437void
21da1569 438restore_tty(int fd)
984263bc
MD
439{
440 if (restore_term) {
441 if (!default_device) {
442 /*
443 * Turn off echoing, because otherwise we can get into
444 * a loop with the tty and the modem echoing to each other.
445 * We presume we are the sole user of this tty device, so
446 * when we close it, it will revert to its defaults anyway.
447 */
448 inittermios.c_lflag &= ~(ECHO | ECHONL);
449 }
450 if (tcsetattr(fd, TCSAFLUSH, &inittermios) < 0)
451 if (errno != ENXIO)
452 syslog(LOG_WARNING, "tcsetattr: %m");
453 ioctl(fd, TIOCSWINSZ, &wsinfo);
454 restore_term = 0;
455 }
456}
457
458/*
459 * setdtr - control the DTR line on the serial port.
460 * This is called from die(), so it shouldn't call die().
461 */
462void
21da1569 463setdtr(int fd, int on)
984263bc
MD
464{
465 int modembits = TIOCM_DTR;
466
467 ioctl(fd, (on? TIOCMBIS: TIOCMBIC), &modembits);
468}
469
470
471/*
472 * open_ppp_loopback - open the device we use for getting
473 * packets in demand mode, and connect it to a ppp interface.
474 * Here we use a pty.
475 */
476void
21da1569 477open_ppp_loopback(void)
984263bc
MD
478{
479 int flags;
480 struct termios tios;
481 int pppdisc = PPPDISC;
482
483 if (openpty(&loop_master, &loop_slave, loop_name, NULL, NULL) < 0) {
484 syslog(LOG_ERR, "No free pty for loopback");
485 die(1);
486 }
487 SYSDEBUG((LOG_DEBUG, "using %s for loopback", loop_name));
488
489 if (tcgetattr(loop_slave, &tios) == 0) {
490 tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB);
491 tios.c_cflag |= CS8 | CREAD;
492 tios.c_iflag = IGNPAR;
493 tios.c_oflag = 0;
494 tios.c_lflag = 0;
495 if (tcsetattr(loop_slave, TCSAFLUSH, &tios) < 0)
496 syslog(LOG_WARNING, "couldn't set attributes on loopback: %m");
497 }
498
499 if ((flags = fcntl(loop_master, F_GETFL)) != -1)
500 if (fcntl(loop_master, F_SETFL, flags | O_NONBLOCK) == -1)
501 syslog(LOG_WARNING, "couldn't set loopback to nonblock: %m");
502
503 ppp_fd = loop_slave;
504 if (ioctl(ppp_fd, TIOCSETD, &pppdisc) < 0) {
505 syslog(LOG_ERR, "ioctl(TIOCSETD): %m");
506 die(1);
507 }
508
509 /*
510 * Find out which interface we were given.
511 */
512 if (ioctl(ppp_fd, PPPIOCGUNIT, &ifunit) < 0) {
513 syslog(LOG_ERR, "ioctl(PPPIOCGUNIT): %m");
514 die(1);
515 }
516
517 /*
518 * Enable debug in the driver if requested.
519 */
520 if (kdebugflag) {
521 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &flags) < 0) {
522 syslog(LOG_WARNING, "ioctl (PPPIOCGFLAGS): %m");
523 } else {
524 flags |= (kdebugflag & 0xFF) * SC_DEBUG;
525 if (ioctl(ppp_fd, PPPIOCSFLAGS, (caddr_t) &flags) < 0)
526 syslog(LOG_WARNING, "ioctl(PPPIOCSFLAGS): %m");
527 }
528 }
529
530}
531
532
533/*
534 * output - Output PPP packet.
535 */
536void
21da1569 537output(int unit, u_char *p, int len)
984263bc
MD
538{
539 if (debug)
540 log_packet(p, len, "sent ", LOG_DEBUG);
541
542 if (write(ttyfd, p, len) < 0) {
543 if (errno != EIO)
544 syslog(LOG_ERR, "write: %m");
545 }
546}
547
548
549/*
550 * wait_input - wait until there is data available on ttyfd,
551 * for the length of time specified by *timo (indefinite
552 * if timo is NULL).
553 */
554void
21da1569 555wait_input(struct timeval *timo)
984263bc
MD
556{
557 fd_set ready;
558 int n;
559
560 if (ttyfd >= FD_SETSIZE) {
561 syslog(LOG_ERR, "descriptor too big");
562 die(1);
563 }
564 FD_ZERO(&ready);
565 FD_SET(ttyfd, &ready);
566 n = select(ttyfd+1, &ready, NULL, &ready, timo);
567 if (n < 0 && errno != EINTR) {
568 syslog(LOG_ERR, "select: %m");
569 die(1);
570 }
571}
572
573
574/*
575 * wait_loop_output - wait until there is data available on the
576 * loopback, for the length of time specified by *timo (indefinite
577 * if timo is NULL).
578 */
579void
21da1569 580wait_loop_output(struct timeval *timo)
984263bc
MD
581{
582 fd_set ready;
583 int n;
584
585 if (loop_master >= FD_SETSIZE) {
586 syslog(LOG_ERR, "descriptor too big");
587 die(1);
588 }
589 FD_ZERO(&ready);
590 FD_SET(loop_master, &ready);
591 n = select(loop_master + 1, &ready, NULL, &ready, timo);
592 if (n < 0 && errno != EINTR) {
593 syslog(LOG_ERR, "select: %m");
594 die(1);
595 }
596}
597
598
599/*
600 * wait_time - wait for a given length of time or until a
601 * signal is received.
602 */
603void
21da1569 604wait_time(struct timeval *timo)
984263bc
MD
605{
606 int n;
607
608 n = select(0, NULL, NULL, NULL, timo);
609 if (n < 0 && errno != EINTR) {
610 syslog(LOG_ERR, "select: %m");
611 die(1);
612 }
613}
614
615
616/*
617 * read_packet - get a PPP packet from the serial device.
618 */
619int
21da1569 620read_packet(u_char *buf)
984263bc
MD
621{
622 int len;
623
624 if ((len = read(ttyfd, buf, PPP_MTU + PPP_HDRLEN)) < 0) {
625 if (errno == EWOULDBLOCK || errno == EINTR)
626 return -1;
627 syslog(LOG_ERR, "read: %m");
628 die(1);
629 }
630 return len;
631}
632
633
634/*
635 * get_loop_output - read characters from the loopback, form them
636 * into frames, and detect when we want to bring the real link up.
637 * Return value is 1 if we need to bring up the link, 0 otherwise.
638 */
639int
21da1569 640get_loop_output(void)
984263bc
MD
641{
642 int rv = 0;
643 int n;
644
645 while ((n = read(loop_master, inbuf, sizeof(inbuf))) >= 0) {
646 if (loop_chars(inbuf, n))
647 rv = 1;
648 }
649
650 if (n == 0) {
651 syslog(LOG_ERR, "eof on loopback");
652 die(1);
653 } else if (errno != EWOULDBLOCK){
654 syslog(LOG_ERR, "read from loopback: %m");
655 die(1);
656 }
657
658 return rv;
659}
660
661
662/*
663 * ppp_send_config - configure the transmit characteristics of
664 * the ppp interface.
665 */
666void
21da1569 667ppp_send_config(int unit, int mtu, u_int32_t asyncmap, int pcomp, int accomp)
984263bc
MD
668{
669 u_int x;
670 struct ifreq ifr;
671
672 strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
673 ifr.ifr_mtu = mtu;
674 if (ioctl(sockfd, SIOCSIFMTU, (caddr_t) &ifr) < 0) {
675 syslog(LOG_ERR, "ioctl(SIOCSIFMTU): %m");
676 quit();
677 }
678
679 if (ioctl(ppp_fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
680 syslog(LOG_ERR, "ioctl(PPPIOCSASYNCMAP): %m");
681 quit();
682 }
683
684 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
685 syslog(LOG_ERR, "ioctl (PPPIOCGFLAGS): %m");
686 quit();
687 }
688 x = pcomp? x | SC_COMP_PROT: x &~ SC_COMP_PROT;
689 x = accomp? x | SC_COMP_AC: x &~ SC_COMP_AC;
690 if (ioctl(ppp_fd, PPPIOCSFLAGS, (caddr_t) &x) < 0) {
691 syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): %m");
692 quit();
693 }
694}
695
696
697/*
698 * ppp_set_xaccm - set the extended transmit ACCM for the interface.
699 */
700void
21da1569 701ppp_set_xaccm(int unit, ext_accm accm)
984263bc
MD
702{
703 if (ioctl(ppp_fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY)
704 syslog(LOG_WARNING, "ioctl(set extended ACCM): %m");
705}
706
707
708/*
709 * ppp_recv_config - configure the receive-side characteristics of
710 * the ppp interface.
711 */
712void
21da1569 713ppp_recv_config(int unit, int mru, u_int32_t asyncmap, int pcomp, int accomp)
984263bc
MD
714{
715 int x;
716
717 if (ioctl(ppp_fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
718 syslog(LOG_ERR, "ioctl(PPPIOCSMRU): %m");
719 quit();
720 }
721 if (ioctl(ppp_fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
722 syslog(LOG_ERR, "ioctl(PPPIOCSRASYNCMAP): %m");
723 quit();
724 }
725 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
726 syslog(LOG_ERR, "ioctl (PPPIOCGFLAGS): %m");
727 quit();
728 }
729 x = !accomp? x | SC_REJ_COMP_AC: x &~ SC_REJ_COMP_AC;
730 if (ioctl(ppp_fd, PPPIOCSFLAGS, (caddr_t) &x) < 0) {
731 syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): %m");
732 quit();
733 }
734}
735
736/*
737 * ccp_test - ask kernel whether a given compression method
738 * is acceptable for use. Returns 1 if the method and parameters
739 * are OK, 0 if the method is known but the parameters are not OK
740 * (e.g. code size should be reduced), or -1 if the method is unknown.
741 */
742int
21da1569 743ccp_test(int unit, u_char *opt_ptr, int opt_len, int for_transmit)
984263bc
MD
744{
745 struct ppp_option_data data;
746
747 data.ptr = opt_ptr;
748 data.length = opt_len;
749 data.transmit = for_transmit;
750 if (ioctl(ttyfd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0)
751 return 1;
752 return (errno == ENOBUFS)? 0: -1;
753}
754
755/*
756 * ccp_flags_set - inform kernel about the current state of CCP.
757 */
758void
21da1569 759ccp_flags_set(int unit, int isopen, int isup)
984263bc
MD
760{
761 int x;
762
763 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
764 syslog(LOG_ERR, "ioctl (PPPIOCGFLAGS): %m");
765 return;
766 }
767 x = isopen? x | SC_CCP_OPEN: x &~ SC_CCP_OPEN;
768 x = isup? x | SC_CCP_UP: x &~ SC_CCP_UP;
769 if (ioctl(ppp_fd, PPPIOCSFLAGS, (caddr_t) &x) < 0)
770 syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): %m");
771}
772
773/*
774 * ccp_fatal_error - returns 1 if decompression was disabled as a
775 * result of an error detected after decompression of a packet,
776 * 0 otherwise. This is necessary because of patent nonsense.
777 */
778int
21da1569 779ccp_fatal_error(int unit)
984263bc
MD
780{
781 int x;
782
783 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
784 syslog(LOG_ERR, "ioctl(PPPIOCGFLAGS): %m");
785 return 0;
786 }
787 return x & SC_DC_FERROR;
788}
789
790/*
791 * get_idle_time - return how long the link has been idle.
792 */
793int
21da1569 794get_idle_time(int u, struct ppp_idle *ip)
984263bc
MD
795{
796 return ioctl(ppp_fd, PPPIOCGIDLE, ip) >= 0;
797}
798
799
800#ifdef PPP_FILTER
801/*
802 * set_filters - transfer the pass and active filters to the kernel.
803 */
804int
21da1569 805set_filters(struct bpf_program *pass, struct bpf_program *active)
984263bc
MD
806{
807 int ret = 1;
808
809 if (pass->bf_len > 0) {
810 if (ioctl(ppp_fd, PPPIOCSPASS, pass) < 0) {
811 syslog(LOG_ERR, "Couldn't set pass-filter in kernel: %m");
812 ret = 0;
813 }
814 }
815 if (active->bf_len > 0) {
816 if (ioctl(ppp_fd, PPPIOCSACTIVE, active) < 0) {
817 syslog(LOG_ERR, "Couldn't set active-filter in kernel: %m");
818 ret = 0;
819 }
820 }
821 return ret;
822}
823#endif
824
825/*
826 * sifvjcomp - config tcp header compression
827 */
828int
21da1569 829sifvjcomp(int u, int vjcomp, int cidcomp, int maxcid)
984263bc
MD
830{
831 u_int x;
832
833 if (ioctl(ppp_fd, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
834 syslog(LOG_ERR, "ioctl (PPPIOCGFLAGS): %m");
835 return 0;
836 }
837 x = vjcomp ? x | SC_COMP_TCP: x &~ SC_COMP_TCP;
838 x = cidcomp? x & ~SC_NO_TCP_CCID: x | SC_NO_TCP_CCID;
839 if (ioctl(ppp_fd, PPPIOCSFLAGS, (caddr_t) &x) < 0) {
840 syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): %m");
841 return 0;
842 }
843 if (vjcomp && ioctl(ppp_fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
844 syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): %m");
845 return 0;
846 }
847 return 1;
848}
849
850/*
851 * sifup - Config the interface up and enable IP packets to pass.
852 */
853int
21da1569 854sifup(int u)
984263bc
MD
855{
856 struct ifreq ifr;
857
858 strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
859 if (ioctl(sockfd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
860 syslog(LOG_ERR, "ioctl (SIOCGIFFLAGS): %m");
861 return 0;
862 }
863 ifr.ifr_flags |= IFF_UP;
864 if (ioctl(sockfd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
865 syslog(LOG_ERR, "ioctl(SIOCSIFFLAGS): %m");
866 return 0;
867 }
868 if_is_up = 1;
869 return 1;
870}
871
872/*
873 * sifnpmode - Set the mode for handling packets for a given NP.
874 */
875int
21da1569 876sifnpmode(int u, int proto, enum NPmode mode)
984263bc
MD
877{
878 struct npioctl npi;
879
880 npi.protocol = proto;
881 npi.mode = mode;
882 if (ioctl(ppp_fd, PPPIOCSNPMODE, &npi) < 0) {
883 syslog(LOG_ERR, "ioctl(set NP %d mode to %d): %m", proto, mode);
884 return 0;
885 }
886 return 1;
887}
888
889/*
890 * sifdown - Config the interface down and disable IP.
891 */
892int
21da1569 893sifdown(int u)
984263bc
MD
894{
895 struct ifreq ifr;
896 int rv;
897 struct npioctl npi;
898
899 rv = 1;
900 npi.protocol = PPP_IP;
901 npi.mode = NPMODE_ERROR;
902 ioctl(ppp_fd, PPPIOCSNPMODE, (caddr_t) &npi);
903 /* ignore errors, because ppp_fd might have been closed by now. */
904
905 strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
906 if (ioctl(sockfd, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
907 syslog(LOG_ERR, "ioctl (SIOCGIFFLAGS): %m");
908 rv = 0;
909 } else {
910 ifr.ifr_flags &= ~IFF_UP;
911 if (ioctl(sockfd, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
912 syslog(LOG_ERR, "ioctl(SIOCSIFFLAGS): %m");
913 rv = 0;
914 } else
915 if_is_up = 0;
916 }
917 return rv;
918}
919
920/*
921 * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
922 * if it exists.
923 */
924#define SET_SA_FAMILY(addr, family) \
925 BZERO((char *) &(addr), sizeof(addr)); \
926 addr.sa_family = (family); \
927 addr.sa_len = sizeof(addr);
928
929/*
930 * sifaddr - Config the interface IP addresses and netmask.
931 */
932int
21da1569 933sifaddr(int u, u_int32_t o, u_int32_t h, u_int32_t m)
984263bc
MD
934{
935 struct ifaliasreq ifra;
936 struct ifreq ifr;
937
938 strncpy(ifra.ifra_name, ifname, sizeof(ifra.ifra_name));
939 SET_SA_FAMILY(ifra.ifra_addr, AF_INET);
940 ((struct sockaddr_in *) &ifra.ifra_addr)->sin_addr.s_addr = o;
941 SET_SA_FAMILY(ifra.ifra_broadaddr, AF_INET);
942 ((struct sockaddr_in *) &ifra.ifra_broadaddr)->sin_addr.s_addr = h;
943 if (m != 0) {
944 SET_SA_FAMILY(ifra.ifra_mask, AF_INET);
945 ((struct sockaddr_in *) &ifra.ifra_mask)->sin_addr.s_addr = m;
946 } else
947 BZERO(&ifra.ifra_mask, sizeof(ifra.ifra_mask));
948 BZERO(&ifr, sizeof(ifr));
949 strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name));
950 if (ioctl(sockfd, SIOCDIFADDR, (caddr_t) &ifr) < 0) {
951 if (errno != EADDRNOTAVAIL)
952 syslog(LOG_WARNING, "Couldn't remove interface address: %m");
953 }
954 if (ioctl(sockfd, SIOCAIFADDR, (caddr_t) &ifra) < 0) {
955 if (errno != EEXIST) {
956 syslog(LOG_ERR, "Couldn't set interface address: %m");
957 return 0;
958 }
959 syslog(LOG_WARNING,
960 "Couldn't set interface address: Address %s already exists",
961 ip_ntoa(o));
962 }
963 ifaddrs[0] = o;
964 ifaddrs[1] = h;
965 return 1;
966}
967
968/*
969 * cifaddr - Clear the interface IP addresses, and delete routes
970 * through the interface if possible.
971 */
972int
21da1569 973cifaddr(int u, u_int32_t o, u_int32_t h)
984263bc
MD
974{
975 struct ifaliasreq ifra;
976
977 ifaddrs[0] = 0;
978 strncpy(ifra.ifra_name, ifname, sizeof(ifra.ifra_name));
979 SET_SA_FAMILY(ifra.ifra_addr, AF_INET);
980 ((struct sockaddr_in *) &ifra.ifra_addr)->sin_addr.s_addr = o;
981 SET_SA_FAMILY(ifra.ifra_broadaddr, AF_INET);
982 ((struct sockaddr_in *) &ifra.ifra_broadaddr)->sin_addr.s_addr = h;
983 BZERO(&ifra.ifra_mask, sizeof(ifra.ifra_mask));
984 if (ioctl(sockfd, SIOCDIFADDR, (caddr_t) &ifra) < 0) {
985 if (errno != EADDRNOTAVAIL)
986 syslog(LOG_WARNING, "Couldn't delete interface address: %m");
987 return 0;
988 }
989 return 1;
990}
991
992/*
993 * sifdefaultroute - assign a default route through the address given.
994 */
995int
21da1569 996sifdefaultroute(int u, u_int32_t l, u_int32_t g)
984263bc
MD
997{
998 return dodefaultroute(g, 's');
999}
1000
1001/*
1002 * cifdefaultroute - delete a default route through the address given.
1003 */
1004int
21da1569 1005cifdefaultroute(int u, u_int32_t l, u_int32_t g)
984263bc
MD
1006{
1007 return dodefaultroute(g, 'c');
1008}
1009
1010/*
1011 * dodefaultroute - talk to a routing socket to add/delete a default route.
1012 */
1013static int
21da1569 1014dodefaultroute(u_int32_t g, int cmd)
984263bc
MD
1015{
1016 int routes;
1017 struct {
1018 struct rt_msghdr hdr;
1019 struct sockaddr_in dst;
1020 struct sockaddr_in gway;
1021 struct sockaddr_in mask;
1022 } rtmsg;
1023
1024 if ((routes = socket(PF_ROUTE, SOCK_RAW, AF_INET)) < 0) {
1025 syslog(LOG_ERR, "Couldn't %s default route: socket: %m",
1026 cmd=='s'? "add": "delete");
1027 return 0;
1028 }
1029
1030 memset(&rtmsg, 0, sizeof(rtmsg));
1031 rtmsg.hdr.rtm_type = cmd == 's'? RTM_ADD: RTM_DELETE;
1032 rtmsg.hdr.rtm_flags = RTF_UP | RTF_GATEWAY | RTF_STATIC;
1033 rtmsg.hdr.rtm_version = RTM_VERSION;
1034 rtmsg.hdr.rtm_seq = ++rtm_seq;
1035 rtmsg.hdr.rtm_addrs = RTA_DST | RTA_GATEWAY | RTA_NETMASK;
1036 rtmsg.dst.sin_len = sizeof(rtmsg.dst);
1037 rtmsg.dst.sin_family = AF_INET;
1038 rtmsg.gway.sin_len = sizeof(rtmsg.gway);
1039 rtmsg.gway.sin_family = AF_INET;
1040 rtmsg.gway.sin_addr.s_addr = g;
1041 rtmsg.mask.sin_len = sizeof(rtmsg.dst);
1042 rtmsg.mask.sin_family = AF_INET;
1043
1044 rtmsg.hdr.rtm_msglen = sizeof(rtmsg);
1045 if (write(routes, &rtmsg, sizeof(rtmsg)) < 0) {
1046 syslog(LOG_ERR, "Couldn't %s default route: %m",
1047 cmd=='s'? "add": "delete");
1048 close(routes);
1049 return 0;
1050 }
1051
1052 close(routes);
1053 default_route_gateway = (cmd == 's')? g: 0;
1054 return 1;
1055}
1056
1057#if RTM_VERSION >= 3
1058
1059/*
1060 * sifproxyarp - Make a proxy ARP entry for the peer.
1061 */
1062static struct {
1063 struct rt_msghdr hdr;
1064 struct sockaddr_inarp dst;
1065 struct sockaddr_dl hwa;
1066 char extra[128];
1067} arpmsg;
1068
1069static int arpmsg_valid;
1070
1071int
21da1569 1072sifproxyarp(int unit, u_int32_t hisaddr)
984263bc
MD
1073{
1074 int routes;
1075
1076 /*
1077 * Get the hardware address of an interface on the same subnet
1078 * as our local address.
1079 */
1080 memset(&arpmsg, 0, sizeof(arpmsg));
1081 if (!get_ether_addr(hisaddr, &arpmsg.hwa)) {
1082 syslog(LOG_ERR, "Cannot determine ethernet address for proxy ARP");
1083 return 0;
1084 }
1085
1086 if ((routes = socket(PF_ROUTE, SOCK_RAW, AF_INET)) < 0) {
1087 syslog(LOG_ERR, "Couldn't add proxy arp entry: socket: %m");
1088 return 0;
1089 }
1090
1091 arpmsg.hdr.rtm_type = RTM_ADD;
1092 arpmsg.hdr.rtm_flags = RTF_ANNOUNCE | RTF_HOST | RTF_STATIC;
1093 arpmsg.hdr.rtm_version = RTM_VERSION;
1094 arpmsg.hdr.rtm_seq = ++rtm_seq;
1095 arpmsg.hdr.rtm_addrs = RTA_DST | RTA_GATEWAY;
1096 arpmsg.hdr.rtm_inits = RTV_EXPIRE;
1097 arpmsg.dst.sin_len = sizeof(struct sockaddr_inarp);
1098 arpmsg.dst.sin_family = AF_INET;
1099 arpmsg.dst.sin_addr.s_addr = hisaddr;
1100 arpmsg.dst.sin_other = SIN_PROXY;
1101
1102 arpmsg.hdr.rtm_msglen = (char *) &arpmsg.hwa - (char *) &arpmsg
1103 + arpmsg.hwa.sdl_len;
1104 if (write(routes, &arpmsg, arpmsg.hdr.rtm_msglen) < 0) {
1105 syslog(LOG_ERR, "Couldn't add proxy arp entry: %m");
1106 close(routes);
1107 return 0;
1108 }
1109
1110 close(routes);
1111 arpmsg_valid = 1;
1112 proxy_arp_addr = hisaddr;
1113 return 1;
1114}
1115
1116/*
1117 * cifproxyarp - Delete the proxy ARP entry for the peer.
1118 */
1119int
21da1569 1120cifproxyarp(int unit, u_int32_t hisaddr)
984263bc
MD
1121{
1122 int routes;
1123
1124 if (!arpmsg_valid)
1125 return 0;
1126 arpmsg_valid = 0;
1127
1128 arpmsg.hdr.rtm_type = RTM_DELETE;
1129 arpmsg.hdr.rtm_seq = ++rtm_seq;
1130
1131 if ((routes = socket(PF_ROUTE, SOCK_RAW, AF_INET)) < 0) {
1132 syslog(LOG_ERR, "Couldn't delete proxy arp entry: socket: %m");
1133 return 0;
1134 }
1135
1136 if (write(routes, &arpmsg, arpmsg.hdr.rtm_msglen) < 0) {
1137 syslog(LOG_ERR, "Couldn't delete proxy arp entry: %m");
1138 close(routes);
1139 return 0;
1140 }
1141
1142 close(routes);
1143 proxy_arp_addr = 0;
1144 return 1;
1145}
1146
1147#else /* RTM_VERSION */
1148
1149/*
1150 * sifproxyarp - Make a proxy ARP entry for the peer.
1151 */
1152int
21da1569 1153sifproxyarp(int unit, u_int32_t hisaddr)
984263bc
MD
1154{
1155 struct arpreq arpreq;
1156 struct {
1157 struct sockaddr_dl sdl;
1158 char space[128];
1159 } dls;
1160
1161 BZERO(&arpreq, sizeof(arpreq));
1162
1163 /*
1164 * Get the hardware address of an interface on the same subnet
1165 * as our local address.
1166 */
1167 if (!get_ether_addr(hisaddr, &dls.sdl)) {
1168 syslog(LOG_ERR, "Cannot determine ethernet address for proxy ARP");
1169 return 0;
1170 }
1171
1172 arpreq.arp_ha.sa_len = sizeof(struct sockaddr);
1173 arpreq.arp_ha.sa_family = AF_UNSPEC;
1174 BCOPY(LLADDR(&dls.sdl), arpreq.arp_ha.sa_data, dls.sdl.sdl_alen);
1175 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1176 ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = hisaddr;
1177 arpreq.arp_flags = ATF_PERM | ATF_PUBL;
1178 if (ioctl(sockfd, SIOCSARP, (caddr_t)&arpreq) < 0) {
1179 syslog(LOG_ERR, "Couldn't add proxy arp entry: %m");
1180 return 0;
1181 }
1182
1183 proxy_arp_addr = hisaddr;
1184 return 1;
1185}
1186
1187/*
1188 * cifproxyarp - Delete the proxy ARP entry for the peer.
1189 */
1190int
21da1569 1191cifproxyarp(int unit, u_int32_t hisaddr)
984263bc
MD
1192{
1193 struct arpreq arpreq;
1194
1195 BZERO(&arpreq, sizeof(arpreq));
1196 SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
1197 ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = hisaddr;
1198 if (ioctl(sockfd, SIOCDARP, (caddr_t)&arpreq) < 0) {
1199 syslog(LOG_WARNING, "Couldn't delete proxy arp entry: %m");
1200 return 0;
1201 }
1202 proxy_arp_addr = 0;
1203 return 1;
1204}
1205#endif /* RTM_VERSION */
1206
1207#ifdef IPX_CHANGE
1208/********************************************************************
1209 *
1210 * sipxfaddr - Config the interface IPX networknumber
1211 */
1212
1213int
21da1569
SW
1214sipxfaddr(int unit, unsigned long int network, unsigned char *node)
1215{
984263bc
MD
1216 int result = 1;
1217
1218 int skfd;
1219 struct sockaddr_ipx ipx_addr;
1220 struct ifreq ifr;
1221 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
1222 union ipx_net_u net;
1223
1224 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
1225 if (skfd < 0)
1226 {
1227 syslog (LOG_DEBUG, "socket(AF_IPX): %m(%d)", errno);
1228 result = 0;
1229 }
1230 else
1231 {
1232 memset (&ifr, '\0', sizeof (ifr));
1233 strcpy (ifr.ifr_name, ifname);
1234
1235 memcpy (sipx->sipx_addr.x_host.c_host, node, 6);
1236 sipx->sipx_len = sizeof(sipx);
1237 sipx->sipx_family = AF_IPX;
1238 sipx->sipx_port = 0;
1239 memset(&net, 0, sizeof(net));
1240 net.long_e = htonl (network);
1241 sipx->sipx_addr.x_net = net.net_e;
1242/*
1243 * Set the IPX device
1244 */
1245 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0)
1246 {
1247 result = 0;
1248 if (errno != EEXIST)
1249 {
1250 syslog (LOG_DEBUG,
1251 "ioctl(SIOCAIFADDR, CRTITF): %m(%d)", errno);
1252 }
1253 else
1254 {
1255 syslog (LOG_WARNING,
1256 "ioctl(SIOCAIFADDR, CRTITF): Address already exists");
1257 }
1258 }
1259 close (skfd);
1260 }
1261 return result;
21da1569 1262}
984263bc
MD
1263
1264/********************************************************************
1265 *
1266 * cipxfaddr - Clear the information for the IPX network. The IPX routes
1267 * are removed and the device is no longer able to pass IPX
1268 * frames.
1269 */
1270
21da1569
SW
1271int cipxfaddr(int unit)
1272{
984263bc
MD
1273 int result = 1;
1274
1275 int skfd;
1276 struct sockaddr_ipx ipx_addr;
1277 struct ifreq ifr;
1278 struct sockaddr_ipx *sipx = (struct sockaddr_ipx *) &ifr.ifr_addr;
1279
1280 skfd = socket (AF_IPX, SOCK_DGRAM, 0);
1281 if (skfd < 0)
1282 {
1283 syslog (LOG_DEBUG, "socket(AF_IPX): %m(%d)", errno);
1284 result = 0;
1285 }
1286 else
1287 {
1288 memset (&ifr, '\0', sizeof (ifr));
1289 strcpy (ifr.ifr_name, ifname);
1290
1291 sipx->sipx_len = sizeof(sipx);
1292 sipx->sipx_family = AF_IPX;
1293/*
1294 * Set the IPX device
1295 */
1296 if (ioctl(skfd, SIOCSIFADDR, (caddr_t) &ifr) < 0)
1297 {
1298 syslog (LOG_INFO,
1299 "ioctl(SIOCAIFADDR, IPX_DLTITF): %m(%d)", errno);
1300 result = 0;
1301 }
1302 close (skfd);
1303 }
1304 return result;
21da1569 1305}
984263bc
MD
1306#endif
1307
1308/*
1309 * get_ether_addr - get the hardware address of an interface on the
1310 * the same subnet as ipaddr.
1311 */
1312#define MAX_IFS 32
1313
1314static int
21da1569 1315get_ether_addr(u_int32_t ipaddr, struct sockaddr_dl *hwaddr)
984263bc
MD
1316{
1317 struct ifreq *ifr, *ifend, *ifp;
1318 u_int32_t ina, mask;
1319 struct sockaddr_dl *dla;
1320 struct ifreq ifreq;
1321 struct ifconf ifc;
1322 struct ifreq ifs[MAX_IFS];
1323
1324 ifc.ifc_len = sizeof(ifs);
1325 ifc.ifc_req = ifs;
1326 if (ioctl(sockfd, SIOCGIFCONF, &ifc) < 0) {
1327 syslog(LOG_ERR, "ioctl(SIOCGIFCONF): %m");
1328 return 0;
1329 }
1330
1331 /*
1332 * Scan through looking for an interface with an Internet
1333 * address on the same subnet as `ipaddr'.
1334 */
1335 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1336 for (ifr = ifc.ifc_req; ifr < ifend;
1337 ifr = (struct ifreq *) ((char *)&ifr->ifr_addr
1338 + MAX(ifr->ifr_addr.sa_len, sizeof(ifr->ifr_addr)))) {
1339 if (ifr->ifr_addr.sa_family == AF_INET) {
1340 ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
1341 strncpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1342 /*
1343 * Check that the interface is up, and not point-to-point
1344 * or loopback.
1345 */
1346 if (ioctl(sockfd, SIOCGIFFLAGS, &ifreq) < 0)
1347 continue;
1348 if ((ifreq.ifr_flags &
1349 (IFF_UP|IFF_BROADCAST|IFF_POINTOPOINT|IFF_LOOPBACK|IFF_NOARP))
1350 != (IFF_UP|IFF_BROADCAST))
1351 continue;
1352 /*
1353 * Get its netmask and check that it's on the right subnet.
1354 */
1355 if (ioctl(sockfd, SIOCGIFNETMASK, &ifreq) < 0)
1356 continue;
1357 mask = ((struct sockaddr_in *) &ifreq.ifr_addr)->sin_addr.s_addr;
1358 if ((ipaddr & mask) != (ina & mask))
1359 continue;
1360
1361 break;
1362 }
1363 }
1364
1365 if (ifr >= ifend)
1366 return 0;
1367 syslog(LOG_INFO, "found interface %s for proxy arp", ifr->ifr_name);
1368
1369 /*
1370 * Now scan through again looking for a link-level address
1371 * for this interface.
1372 */
1373 ifp = ifr;
1374 for (ifr = ifc.ifc_req; ifr < ifend; ) {
1375 if (strcmp(ifp->ifr_name, ifr->ifr_name) == 0
1376 && ifr->ifr_addr.sa_family == AF_LINK) {
1377 /*
1378 * Found the link-level address - copy it out
1379 */
1380 dla = (struct sockaddr_dl *) &ifr->ifr_addr;
1381 BCOPY(dla, hwaddr, dla->sdl_len);
1382 return 1;
1383 }
1384 ifr = (struct ifreq *) ((char *)&ifr->ifr_addr
1385 + MAX(ifr->ifr_addr.sa_len, sizeof(ifr->ifr_addr)));
1386 }
1387
1388 return 0;
1389}
1390
1391/*
1392 * Return user specified netmask, modified by any mask we might determine
1393 * for address `addr' (in network byte order).
1394 * Here we scan through the system's list of interfaces, looking for
1395 * any non-point-to-point interfaces which might appear to be on the same
1396 * network as `addr'. If we find any, we OR in their netmask to the
1397 * user-specified netmask.
1398 */
1399u_int32_t
21da1569 1400GetMask(u_int32_t addr)
984263bc
MD
1401{
1402 u_int32_t mask, nmask, ina;
1403 struct ifreq *ifr, *ifend, ifreq;
1404 struct ifconf ifc;
1405 struct ifreq ifs[MAX_IFS];
1406
1407 addr = ntohl(addr);
1408 if (IN_CLASSA(addr)) /* determine network mask for address class */
1409 nmask = IN_CLASSA_NET;
1410 else if (IN_CLASSB(addr))
1411 nmask = IN_CLASSB_NET;
1412 else
1413 nmask = IN_CLASSC_NET;
1414 /* class D nets are disallowed by bad_ip_adrs */
1415 mask = netmask | htonl(nmask);
1416
1417 /*
1418 * Scan through the system's network interfaces.
1419 */
1420 ifc.ifc_len = sizeof(ifs);
1421 ifc.ifc_req = ifs;
1422 if (ioctl(sockfd, SIOCGIFCONF, &ifc) < 0) {
1423 syslog(LOG_WARNING, "ioctl(SIOCGIFCONF): %m");
1424 return mask;
1425 }
1426 ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
1427 for (ifr = ifc.ifc_req; ifr < ifend;
1428 ifr = (struct ifreq *) ((char *)&ifr->ifr_addr
1429 + MAX(ifr->ifr_addr.sa_len, sizeof(ifr->ifr_addr)))) {
1430 /*
1431 * Check the interface's internet address.
1432 */
1433 if (ifr->ifr_addr.sa_family != AF_INET)
1434 continue;
1435 ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
1436 if ((ntohl(ina) & nmask) != (addr & nmask))
1437 continue;
1438 /*
1439 * Check that the interface is up, and not point-to-point or loopback.
1440 */
1441 strncpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
1442 if (ioctl(sockfd, SIOCGIFFLAGS, &ifreq) < 0)
1443 continue;
1444 if ((ifreq.ifr_flags & (IFF_UP|IFF_POINTOPOINT|IFF_LOOPBACK))
1445 != IFF_UP)
1446 continue;
1447 /*
1448 * Get its netmask and OR it into our mask.
1449 */
1450 if (ioctl(sockfd, SIOCGIFNETMASK, &ifreq) < 0)
1451 continue;
1452 mask |= ((struct sockaddr_in *)&ifreq.ifr_addr)->sin_addr.s_addr;
1453 }
1454
1455 return mask;
1456}
1457
1458/*
1459 * Use the hostid as part of the random number seed.
1460 */
1461int
21da1569 1462get_host_seed(void)
984263bc
MD
1463{
1464 return gethostid();
1465}
1466
1467/*
1468 * lock - create a lock file for the named lock device
1469 */
1470#define LOCK_PREFIX "/var/spool/lock/LCK.."
1471
1472int
21da1569 1473lock(char *dev)
984263bc
MD
1474{
1475 char hdb_lock_buffer[12];
1476 int fd, pid, n;
1477 char *p;
1478
1479 if ((p = strrchr(dev, '/')) != NULL)
1480 dev = p + 1;
1481 lock_file = malloc(strlen(LOCK_PREFIX) + strlen(dev) + 1);
1482 if (lock_file == NULL)
1483 novm("lock file name");
1484 strcat(strcpy(lock_file, LOCK_PREFIX), dev);
1485
1486 while ((fd = open(lock_file, O_EXCL | O_CREAT | O_RDWR, 0644)) < 0) {
1487 if (errno == EEXIST
1488 && (fd = open(lock_file, O_RDONLY, 0)) >= 0) {
1489 /* Read the lock file to find out who has the device locked */
1490 n = read(fd, hdb_lock_buffer, 11);
1491 if (n <= 0) {
1492 syslog(LOG_ERR, "Can't read pid from lock file %s", lock_file);
1493 close(fd);
1494 } else {
1495 hdb_lock_buffer[n] = 0;
1496 pid = atoi(hdb_lock_buffer);
1497 if (kill(pid, 0) == -1 && errno == ESRCH) {
1498 /* pid no longer exists - remove the lock file */
1499 if (unlink(lock_file) == 0) {
1500 close(fd);
1501 syslog(LOG_NOTICE, "Removed stale lock on %s (pid %d)",
1502 dev, pid);
1503 continue;
1504 } else
1505 syslog(LOG_WARNING, "Couldn't remove stale lock on %s",
1506 dev);
1507 } else
1508 syslog(LOG_NOTICE, "Device %s is locked by pid %d",
1509 dev, pid);
1510 }
1511 close(fd);
1512 } else
1513 syslog(LOG_ERR, "Can't create lock file %s: %m", lock_file);
1514 free(lock_file);
1515 lock_file = NULL;
1516 return -1;
1517 }
1518
1519 sprintf(hdb_lock_buffer, "%10d\n", getpid());
1520 write(fd, hdb_lock_buffer, 11);
1521
1522 close(fd);
1523 return 0;
1524}
1525
1526/*
1527 * unlock - remove our lockfile
1528 */
1529void
21da1569 1530unlock(void)
984263bc
MD
1531{
1532 if (lock_file) {
1533 unlink(lock_file);
1534 free(lock_file);
1535 lock_file = NULL;
1536 }
1537}