added patent nonsense.
[ppp.git] / pppd / sys-bsd.c
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  * All rights reserved.
7  *
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.
19  */
20
21 #ifndef lint
22 static char rcsid[] = "$Id: sys-bsd.c,v 1.10 1994/09/01 00:36:39 paulus Exp $";
23 #endif
24
25 /*
26  * TODO:
27  */
28
29 #include <syslog.h>
30 #include <termios.h>
31 #include <sys/ioctl.h>
32 #include <sys/types.h>
33 #include <sys/socket.h>
34 #include <sys/time.h>
35 #include <sys/errno.h>
36
37 #include <net/if.h>
38 #include <net/if_ppp.h>
39 #include <net/route.h>
40 #include <net/if_dl.h>
41 #include <netinet/in.h>
42
43 #if RTM_VERSION >= 3
44 #include <netinet/if_ether.h>
45 #endif
46
47 #include "pppd.h"
48 #include "ppp.h"
49
50 static int initdisc = -1;       /* Initial TTY discipline */
51 static int rtm_seq;
52
53 static int      restore_term;   /* 1 => we've munged the terminal */
54 static struct termios inittermios; /* Initial TTY termios */
55
56 /*
57  * sys_init - System-dependent initialization.
58  */
59 void
60 sys_init()
61 {
62     openlog("pppd", LOG_PID | LOG_NDELAY, LOG_PPP);
63     setlogmask(LOG_UPTO(LOG_INFO));
64     if (debug)
65         setlogmask(LOG_UPTO(LOG_DEBUG));
66 }
67
68 /*
69  * note_debug_level - note a change in the debug level.
70  */
71 void
72 note_debug_level()
73 {
74     if (debug) {
75         syslog(LOG_INFO, "Debug turned ON, Level %d", debug);
76         setlogmask(LOG_UPTO(LOG_DEBUG));
77     } else {
78         setlogmask(LOG_UPTO(LOG_WARNING));
79     }
80 }
81
82 /*
83  * establish_ppp - Turn the serial port into a ppp interface.
84  */
85 void
86 establish_ppp()
87 {
88     int pppdisc = PPPDISC;
89     int x;
90
91     if (ioctl(fd, TIOCGETD, &initdisc) < 0) {
92         syslog(LOG_ERR, "ioctl(TIOCGETD): %m");
93         die(1);
94     }
95     if (ioctl(fd, TIOCSETD, &pppdisc) < 0) {
96         syslog(LOG_ERR, "ioctl(TIOCSETD): %m");
97         die(1);
98     }
99
100     /*
101      * Find out which interface we were given.
102      */
103     if (ioctl(fd, PPPIOCGUNIT, &ifunit) < 0) {  
104         syslog(LOG_ERR, "ioctl(PPPIOCGUNIT): %m");
105         die(1);
106     }
107
108     /*
109      * Enable debug in the driver if requested.
110      */
111     if (kdebugflag) {
112         if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
113             syslog(LOG_WARNING, "ioctl (PPPIOCGFLAGS): %m");
114         } else {
115             x |= (kdebugflag & 0xFF) * SC_DEBUG;
116             if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &x) < 0)
117                 syslog(LOG_WARNING, "ioctl(PPPIOCSFLAGS): %m");
118         }
119     }
120 }
121
122
123 /*
124  * disestablish_ppp - Restore the serial port to normal operation.
125  * This shouldn't call die() because it's called from die().
126  */
127 void
128 disestablish_ppp()
129 {
130     int x;
131     char *s;
132
133     if (initdisc >= 0) {
134         /*
135          * Check whether the link seems not to be 8-bit clean.
136          */
137         if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &x) == 0) {
138             s = NULL;
139             switch (~x & (SC_RCV_B7_0|SC_RCV_B7_1|SC_RCV_EVNP|SC_RCV_ODDP)) {
140             case SC_RCV_B7_0:
141                 s = "bit 7 set to 1";
142                 break;
143             case SC_RCV_B7_1:
144                 s = "bit 7 set to 0";
145                 break;
146             case SC_RCV_EVNP:
147                 s = "odd parity";
148                 break;
149             case SC_RCV_ODDP:
150                 s = "even parity";
151                 break;
152             }
153             if (s != NULL) {
154                 syslog(LOG_WARNING, "Serial link is not 8-bit clean:");
155                 syslog(LOG_WARNING, "All received characters had %s", s);
156             }
157         }
158         if (ioctl(fd, TIOCSETD, &initdisc) < 0)
159             syslog(LOG_ERR, "ioctl(TIOCSETD): %m");
160     }
161 }
162
163
164 /*
165  * set_up_tty: Set up the serial port on `fd' for 8 bits, no parity,
166  * at the requested speed, etc.  If `local' is true, set CLOCAL
167  * regardless of whether the modem option was specified.
168  *
169  * For *BSD, we assume that speed_t values numerically equal bits/second.
170  */
171 set_up_tty(fd, local)
172     int fd, local;
173 {
174     struct termios tios;
175
176     if (tcgetattr(fd, &tios) < 0) {
177         syslog(LOG_ERR, "tcgetattr: %m");
178         die(1);
179     }
180
181     if (!restore_term)
182         inittermios = tios;
183
184     tios.c_cflag &= ~(CSIZE | CSTOPB | PARENB | CLOCAL | CRTSCTS);
185     if (crtscts == 1)
186         tios.c_cflag |= CRTSCTS;
187
188     tios.c_cflag |= CS8 | CREAD | HUPCL;
189     if (local || !modem)
190         tios.c_cflag |= CLOCAL;
191     tios.c_iflag = IGNBRK | IGNPAR;
192     tios.c_oflag = 0;
193     tios.c_lflag = 0;
194     tios.c_cc[VMIN] = 1;
195     tios.c_cc[VTIME] = 0;
196
197     if (crtscts == 2) {
198         tios.c_iflag |= IXOFF;
199         tios.c_cc[VSTOP] = 0x13;        /* DC3 = XOFF = ^S */
200         tios.c_cc[VSTART] = 0x11;       /* DC1 = XON  = ^Q */
201     }
202
203     if (inspeed) {
204         cfsetospeed(&tios, inspeed);
205         cfsetispeed(&tios, inspeed);
206     } else {
207         inspeed = cfgetospeed(&tios);
208         /*
209          * We can't proceed if the serial port speed is 0,
210          * since that implies that the serial port is disabled.
211          */
212         if (inspeed == 0) {
213             syslog(LOG_ERR, "Baud rate for %s is 0; need explicit baud rate",
214                    devnam);
215             die(1);
216         }
217     }
218     baud_rate = inspeed;
219
220     if (tcsetattr(fd, TCSAFLUSH, &tios) < 0) {
221         syslog(LOG_ERR, "tcsetattr: %m");
222         die(1);
223     }
224
225     restore_term = 1;
226 }
227
228 /*
229  * restore_tty - restore the terminal to the saved settings.
230  */
231 void
232 restore_tty()
233 {
234     if (restore_term) {
235         if (tcsetattr(fd, TCSAFLUSH, &inittermios) < 0)
236             if (errno != ENXIO)
237                 syslog(LOG_WARNING, "tcsetattr: %m");
238         restore_term = 0;
239     }
240 }
241
242 /*
243  * setdtr - control the DTR line on the serial port.
244  * This is called from die(), so it shouldn't call die().
245  */
246 setdtr(fd, on)
247 int fd, on;
248 {
249     int modembits = TIOCM_DTR;
250
251     ioctl(fd, (on? TIOCMBIS: TIOCMBIC), &modembits);
252 }
253
254
255 /*
256  * output - Output PPP packet.
257  */
258 void
259 output(unit, p, len)
260     int unit;
261     u_char *p;
262     int len;
263 {
264     if (unit != 0)
265         MAINDEBUG((LOG_WARNING, "output: unit != 0!"));
266     if (debug)
267         log_packet(p, len, "sent ");
268
269     if (write(fd, p, len) < 0) {
270         syslog(LOG_ERR, "write: %m");
271         die(1);
272     }
273 }
274
275
276 /*
277  * wait_input - wait until there is data available on fd,
278  * for the length of time specified by *timo (indefinite
279  * if timo is NULL).
280  */
281 wait_input(timo)
282     struct timeval *timo;
283 {
284     fd_set ready;
285     int n;
286
287     FD_ZERO(&ready);
288     FD_SET(fd, &ready);
289     n = select(fd+1, &ready, NULL, &ready, timo);
290     if (n < 0 && errno != EINTR) {
291         syslog(LOG_ERR, "select: %m");
292         die(1);
293     }
294 }
295
296
297 /*
298  * read_packet - get a PPP packet from the serial device.
299  */
300 int
301 read_packet(buf)
302     u_char *buf;
303 {
304     int len;
305
306     if ((len = read(fd, buf, MTU + DLLHEADERLEN)) < 0) {
307         if (errno == EWOULDBLOCK) {
308             MAINDEBUG((LOG_DEBUG, "read(fd): EWOULDBLOCK"));
309             return -1;
310         }
311         syslog(LOG_ERR, "read(fd): %m");
312         die(1);
313     }
314     return len;
315 }
316
317
318 /*
319  * ppp_send_config - configure the transmit characteristics of
320  * the ppp interface.
321  */
322 void
323 ppp_send_config(unit, mtu, asyncmap, pcomp, accomp)
324     int unit, mtu;
325     uint32 asyncmap;
326     int pcomp, accomp;
327 {
328     u_int x;
329     struct ifreq ifr;
330
331     strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
332     ifr.ifr_mtu = mtu;
333     if (ioctl(s, SIOCSIFMTU, (caddr_t) &ifr) < 0) {
334         syslog(LOG_ERR, "ioctl(SIOCSIFMTU): %m");
335         quit();
336     }
337
338     if (ioctl(fd, PPPIOCSASYNCMAP, (caddr_t) &asyncmap) < 0) {
339         syslog(LOG_ERR, "ioctl(PPPIOCSASYNCMAP): %m");
340         quit();
341     }
342
343     if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
344         syslog(LOG_ERR, "ioctl (PPPIOCGFLAGS): %m");
345         quit();
346     }
347     x = pcomp? x | SC_COMP_PROT: x &~ SC_COMP_PROT;
348     x = accomp? x | SC_COMP_AC: x &~ SC_COMP_AC;
349     if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &x) < 0) {
350         syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): %m");
351         quit();
352     }
353 }
354
355
356 /*
357  * ppp_set_xaccm - set the extended transmit ACCM for the interface.
358  */
359 void
360 ppp_set_xaccm(unit, accm)
361     int unit;
362     ext_accm accm;
363 {
364     if (ioctl(fd, PPPIOCSXASYNCMAP, accm) < 0 && errno != ENOTTY)
365         syslog(LOG_WARNING, "ioctl(set extended ACCM): %m");
366 }
367
368
369 /*
370  * ppp_recv_config - configure the receive-side characteristics of
371  * the ppp interface.
372  */
373 void
374 ppp_recv_config(unit, mru, asyncmap, pcomp, accomp)
375     int unit, mru;
376     uint32 asyncmap;
377     int pcomp, accomp;
378 {
379     int x;
380
381     if (ioctl(fd, PPPIOCSMRU, (caddr_t) &mru) < 0) {
382         syslog(LOG_ERR, "ioctl(PPPIOCSMRU): %m");
383         quit();
384     }
385     if (ioctl(fd, PPPIOCSRASYNCMAP, (caddr_t) &asyncmap) < 0) {
386         syslog(LOG_ERR, "ioctl(PPPIOCSRASYNCMAP): %m");
387         quit();
388     }
389     if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
390         syslog(LOG_ERR, "ioctl (PPPIOCGFLAGS): %m");
391         quit();
392     }
393     x = !accomp? x | SC_REJ_COMP_AC: x &~ SC_REJ_COMP_AC;
394     if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &x) < 0) {
395         syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): %m");
396         quit();
397     }
398 }
399
400 /*
401  * ccp_test - ask kernel whether a given compression method
402  * is acceptable for use.
403  */
404 ccp_test(unit, opt_ptr, opt_len, for_transmit)
405     int unit, opt_len, for_transmit;
406     u_char *opt_ptr;
407 {
408     struct ppp_comp_data data;
409
410     data.ptr = opt_ptr;
411     data.length = opt_len;
412     data.transmit = for_transmit;
413     return ioctl(fd, PPPIOCSCOMPRESS, (caddr_t) &data) >= 0;
414 }
415
416 /*
417  * ccp_flags_set - inform kernel about the current state of CCP.
418  */
419 void
420 ccp_flags_set(unit, isopen, isup)
421     int unit, isopen, isup;
422 {
423     int x;
424
425     if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
426         syslog(LOG_ERR, "ioctl (PPPIOCGFLAGS): %m");
427         return;
428     }
429     x = isopen? x | SC_CCP_OPEN: x &~ SC_CCP_OPEN;
430     x = isup? x | SC_CCP_UP: x &~ SC_CCP_UP;
431     if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &x) < 0)
432         syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): %m");
433 }
434
435 /*
436  * sifvjcomp - config tcp header compression
437  */
438 int
439 sifvjcomp(u, vjcomp, cidcomp, maxcid)
440     int u, vjcomp, cidcomp, maxcid;
441 {
442     u_int x;
443
444     if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
445         syslog(LOG_ERR, "ioctl (PPPIOCGFLAGS): %m");
446         return 0;
447     }
448     x = vjcomp ? x | SC_COMP_TCP: x &~ SC_COMP_TCP;
449     x = cidcomp? x & ~SC_NO_TCP_CCID: x | SC_NO_TCP_CCID;
450     if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &x) < 0) {
451         syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): %m");
452         return 0;
453     }
454     if (ioctl(fd, PPPIOCSMAXCID, (caddr_t) &maxcid) < 0) {
455         syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): %m");
456         return 0;
457     }
458     return 1;
459 }
460
461 /*
462  * sifup - Config the interface up and enable IP packets to pass.
463  */
464 int
465 sifup(u)
466     int u;
467 {
468     struct ifreq ifr;
469     u_int x;
470
471     strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
472     if (ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
473         syslog(LOG_ERR, "ioctl (SIOCGIFFLAGS): %m");
474         return 0;
475     }
476     ifr.ifr_flags |= IFF_UP;
477     if (ioctl(s, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
478         syslog(LOG_ERR, "ioctl(SIOCSIFFLAGS): %m");
479         return 0;
480     }
481     if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
482         syslog(LOG_ERR, "ioctl (PPPIOCGFLAGS): %m");
483         return 0;
484     }
485     x |= SC_ENABLE_IP;
486     if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &x) < 0) {
487         syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): %m");
488         return 0;
489     }
490     return 1;
491 }
492
493 /*
494  * sifdown - Config the interface down and disable IP.
495  */
496 int
497 sifdown(u)
498     int u;
499 {
500     struct ifreq ifr;
501     u_int x;
502     int rv;
503
504     rv = 1;
505     if (ioctl(fd, PPPIOCGFLAGS, (caddr_t) &x) < 0) {
506         syslog(LOG_ERR, "ioctl (PPPIOCGFLAGS): %m");
507         rv = 0;
508     } else {
509         x &= ~SC_ENABLE_IP;
510         if (ioctl(fd, PPPIOCSFLAGS, (caddr_t) &x) < 0) {
511             syslog(LOG_ERR, "ioctl(PPPIOCSFLAGS): %m");
512             rv = 0;
513         }
514     }
515     strncpy(ifr.ifr_name, ifname, sizeof (ifr.ifr_name));
516     if (ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) < 0) {
517         syslog(LOG_ERR, "ioctl (SIOCGIFFLAGS): %m");
518         rv = 0;
519     } else {
520         ifr.ifr_flags &= ~IFF_UP;
521         if (ioctl(s, SIOCSIFFLAGS, (caddr_t) &ifr) < 0) {
522             syslog(LOG_ERR, "ioctl(SIOCSIFFLAGS): %m");
523             rv = 0;
524         }
525     }
526     return rv;
527 }
528
529 /*
530  * SET_SA_FAMILY - set the sa_family field of a struct sockaddr,
531  * if it exists.
532  */
533 #define SET_SA_FAMILY(addr, family)             \
534     BZERO((char *) &(addr), sizeof(addr));      \
535     addr.sa_family = (family);                  \
536     addr.sa_len = sizeof(addr);
537
538 /*
539  * sifaddr - Config the interface IP addresses and netmask.
540  */
541 int
542 sifaddr(u, o, h, m)
543     int u;
544     uint32 o, h, m;
545 {
546     struct ifaliasreq ifra;
547
548     strncpy(ifra.ifra_name, ifname, sizeof(ifra.ifra_name));
549     SET_SA_FAMILY(ifra.ifra_addr, AF_INET);
550     ((struct sockaddr_in *) &ifra.ifra_addr)->sin_addr.s_addr = o;
551     SET_SA_FAMILY(ifra.ifra_broadaddr, AF_INET);
552     ((struct sockaddr_in *) &ifra.ifra_broadaddr)->sin_addr.s_addr = h;
553     if (m != 0) {
554         SET_SA_FAMILY(ifra.ifra_mask, AF_INET);
555         ((struct sockaddr_in *) &ifra.ifra_mask)->sin_addr.s_addr = m;
556     } else
557         BZERO(&ifra.ifra_mask, sizeof(ifra.ifra_mask));
558     if (ioctl(s, SIOCAIFADDR, (caddr_t) &ifra) < 0) {
559         if (errno != EEXIST) {
560             syslog(LOG_ERR, "ioctl(SIOCAIFADDR): %m");
561             return 0;
562         }
563         syslog(LOG_WARNING, "ioctl(SIOCAIFADDR): Address already exists");
564     }
565     return 1;
566 }
567
568 /*
569  * cifaddr - Clear the interface IP addresses, and delete routes
570  * through the interface if possible.
571  */
572 int
573 cifaddr(u, o, h)
574     int u;
575     uint32 o, h;
576 {
577     struct ifaliasreq ifra;
578
579     strncpy(ifra.ifra_name, ifname, sizeof(ifra.ifra_name));
580     SET_SA_FAMILY(ifra.ifra_addr, AF_INET);
581     ((struct sockaddr_in *) &ifra.ifra_addr)->sin_addr.s_addr = o;
582     SET_SA_FAMILY(ifra.ifra_broadaddr, AF_INET);
583     ((struct sockaddr_in *) &ifra.ifra_broadaddr)->sin_addr.s_addr = h;
584     BZERO(&ifra.ifra_mask, sizeof(ifra.ifra_mask));
585     if (ioctl(s, SIOCDIFADDR, (caddr_t) &ifra) < 0) {
586         syslog(LOG_WARNING, "ioctl(SIOCDIFADDR): %m");
587         return 0;
588     }
589     return 1;
590 }
591
592 /*
593  * sifdefaultroute - assign a default route through the address given.
594  */
595 int
596 sifdefaultroute(u, g)
597     int u;
598     uint32 g;
599 {
600     return dodefaultroute(g, 's');
601 }
602
603 /*
604  * cifdefaultroute - delete a default route through the address given.
605  */
606 int
607 cifdefaultroute(u, g)
608     int u;
609     uint32 g;
610 {
611     return dodefaultroute(g, 'c');
612 }
613
614 /*
615  * dodefaultroute - talk to a routing socket to add/delete a default route.
616  */
617 int
618 dodefaultroute(g, cmd)
619     uint32 g;
620     int cmd;
621 {
622     int routes;
623     struct {
624         struct rt_msghdr        hdr;
625         struct sockaddr_in      dst;
626         struct sockaddr_in      gway;
627         struct sockaddr_in      mask;
628     } rtmsg;
629
630     if ((routes = socket(PF_ROUTE, SOCK_RAW, AF_INET)) < 0) {
631         syslog(LOG_ERR, "%cifdefaultroute: opening routing socket: %m", cmd);
632         return 0;
633     }
634
635     memset(&rtmsg, 0, sizeof(rtmsg));
636     rtmsg.hdr.rtm_type = cmd == 's'? RTM_ADD: RTM_DELETE;
637     rtmsg.hdr.rtm_flags = RTF_UP | RTF_GATEWAY;
638     rtmsg.hdr.rtm_version = RTM_VERSION;
639     rtmsg.hdr.rtm_seq = ++rtm_seq;
640     rtmsg.hdr.rtm_addrs = RTA_DST | RTA_GATEWAY | RTA_NETMASK;
641     rtmsg.dst.sin_len = sizeof(rtmsg.dst);
642     rtmsg.dst.sin_family = AF_INET;
643     rtmsg.gway.sin_len = sizeof(rtmsg.gway);
644     rtmsg.gway.sin_family = AF_INET;
645     rtmsg.gway.sin_addr.s_addr = g;
646     rtmsg.mask.sin_len = sizeof(rtmsg.dst);
647     rtmsg.mask.sin_family = AF_INET;
648
649     rtmsg.hdr.rtm_msglen = sizeof(rtmsg);
650     if (write(routes, &rtmsg, sizeof(rtmsg)) < 0) {
651         syslog(LOG_ERR, "%s default route: %m", cmd=='s'? "add": "delete");
652         close(routes);
653         return 0;
654     }
655
656     close(routes);
657     return 1;
658 }
659
660 #if RTM_VERSION >= 3
661
662 /*
663  * sifproxyarp - Make a proxy ARP entry for the peer.
664  */
665 static struct {
666     struct rt_msghdr            hdr;
667     struct sockaddr_inarp       dst;
668     struct sockaddr_dl          hwa;
669     char                        extra[128];
670 } arpmsg;
671
672 static int arpmsg_valid;
673
674 int
675 sifproxyarp(unit, hisaddr)
676     int unit;
677     uint32 hisaddr;
678 {
679     int routes;
680     int l;
681
682     /*
683      * Get the hardware address of an interface on the same subnet
684      * as our local address.
685      */
686     memset(&arpmsg, 0, sizeof(arpmsg));
687     if (!get_ether_addr(hisaddr, &arpmsg.hwa)) {
688         syslog(LOG_ERR, "Cannot determine ethernet address for proxy ARP");
689         return 0;
690     }
691
692     if ((routes = socket(PF_ROUTE, SOCK_RAW, AF_INET)) < 0) {
693         syslog(LOG_ERR, "sifproxyarp: opening routing socket: %m");
694         return 0;
695     }
696
697     arpmsg.hdr.rtm_type = RTM_ADD;
698     arpmsg.hdr.rtm_flags = RTF_ANNOUNCE | RTF_HOST | RTF_STATIC;
699     arpmsg.hdr.rtm_version = RTM_VERSION;
700     arpmsg.hdr.rtm_seq = ++rtm_seq;
701     arpmsg.hdr.rtm_addrs = RTA_DST | RTA_GATEWAY;
702     arpmsg.hdr.rtm_inits = RTV_EXPIRE;
703     arpmsg.dst.sin_len = sizeof(struct sockaddr_inarp);
704     arpmsg.dst.sin_family = AF_INET;
705     arpmsg.dst.sin_addr.s_addr = hisaddr;
706     arpmsg.dst.sin_other = SIN_PROXY;
707
708     arpmsg.hdr.rtm_msglen = (char *) &arpmsg.hwa - (char *) &arpmsg
709         + arpmsg.hwa.sdl_len;
710     if (write(routes, &arpmsg, arpmsg.hdr.rtm_msglen) < 0) {
711         syslog(LOG_ERR, "add proxy arp entry: %m");
712         close(routes);
713         return 0;
714     }
715
716     close(routes);
717     arpmsg_valid = 1;
718     return 1;
719 }
720
721 /*
722  * cifproxyarp - Delete the proxy ARP entry for the peer.
723  */
724 int
725 cifproxyarp(unit, hisaddr)
726     int unit;
727     uint32 hisaddr;
728 {
729     int routes;
730
731     if (!arpmsg_valid)
732         return 0;
733     arpmsg_valid = 0;
734
735     arpmsg.hdr.rtm_type = RTM_DELETE;
736     arpmsg.hdr.rtm_seq = ++rtm_seq;
737
738     if ((routes = socket(PF_ROUTE, SOCK_RAW, AF_INET)) < 0) {
739         syslog(LOG_ERR, "sifproxyarp: opening routing socket: %m");
740         return 0;
741     }
742
743     if (write(routes, &arpmsg, arpmsg.hdr.rtm_msglen) < 0) {
744         syslog(LOG_ERR, "delete proxy arp entry: %m");
745         close(routes);
746         return 0;
747     }
748
749     close(routes);
750     return 1;
751 }
752
753 #else   /* RTM_VERSION */
754
755 /*
756  * sifproxyarp - Make a proxy ARP entry for the peer.
757  */
758 int
759 sifproxyarp(unit, hisaddr)
760     int unit;
761     uint32 hisaddr;
762 {
763     struct arpreq arpreq;
764     struct {
765         struct sockaddr_dl      sdl;
766         char                    space[128];
767     } dls;
768
769     BZERO(&arpreq, sizeof(arpreq));
770
771     /*
772      * Get the hardware address of an interface on the same subnet
773      * as our local address.
774      */
775     if (!get_ether_addr(hisaddr, &dls.sdl)) {
776         syslog(LOG_ERR, "Cannot determine ethernet address for proxy ARP");
777         return 0;
778     }
779
780     arpreq.arp_ha.sa_len = sizeof(struct sockaddr);
781     arpreq.arp_ha.sa_family = AF_UNSPEC;
782     BCOPY(LLADDR(&dls.sdl), arpreq.arp_ha.sa_data, dls.sdl.sdl_alen);
783     SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
784     ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = hisaddr;
785     arpreq.arp_flags = ATF_PERM | ATF_PUBL;
786     if (ioctl(s, SIOCSARP, (caddr_t)&arpreq) < 0) {
787         syslog(LOG_ERR, "ioctl(SIOCSARP): %m");
788         return 0;
789     }
790
791     return 1;
792 }
793
794 /*
795  * cifproxyarp - Delete the proxy ARP entry for the peer.
796  */
797 int
798 cifproxyarp(unit, hisaddr)
799     int unit;
800     uint32 hisaddr;
801 {
802     struct arpreq arpreq;
803
804     BZERO(&arpreq, sizeof(arpreq));
805     SET_SA_FAMILY(arpreq.arp_pa, AF_INET);
806     ((struct sockaddr_in *) &arpreq.arp_pa)->sin_addr.s_addr = hisaddr;
807     if (ioctl(s, SIOCDARP, (caddr_t)&arpreq) < 0) {
808         syslog(LOG_WARNING, "ioctl(SIOCDARP): %m");
809         return 0;
810     }
811     return 1;
812 }
813 #endif  /* RTM_VERSION */
814
815
816 /*
817  * get_ether_addr - get the hardware address of an interface on the
818  * the same subnet as ipaddr.
819  */
820 #define MAX_IFS         32
821
822 int
823 get_ether_addr(ipaddr, hwaddr)
824     uint32 ipaddr;
825     struct sockaddr_dl *hwaddr;
826 {
827     struct ifreq *ifr, *ifend, *ifp;
828     uint32 ina, mask;
829     struct sockaddr_dl *dla;
830     struct ifreq ifreq;
831     struct ifconf ifc;
832     struct ifreq ifs[MAX_IFS];
833
834     ifc.ifc_len = sizeof(ifs);
835     ifc.ifc_req = ifs;
836     if (ioctl(s, SIOCGIFCONF, &ifc) < 0) {
837         syslog(LOG_ERR, "ioctl(SIOCGIFCONF): %m");
838         return 0;
839     }
840
841     /*
842      * Scan through looking for an interface with an Internet
843      * address on the same subnet as `ipaddr'.
844      */
845     ifend = (struct ifreq *) (ifc.ifc_buf + ifc.ifc_len);
846     for (ifr = ifc.ifc_req; ifr < ifend; ) {
847         if (ifr->ifr_addr.sa_family == AF_INET) {
848             ina = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
849             strncpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name));
850             /*
851              * Check that the interface is up, and not point-to-point
852              * or loopback.
853              */
854             if (ioctl(s, SIOCGIFFLAGS, &ifreq) < 0)
855                 continue;
856             if ((ifreq.ifr_flags &
857                  (IFF_UP|IFF_BROADCAST|IFF_POINTOPOINT|IFF_LOOPBACK|IFF_NOARP))
858                  != (IFF_UP|IFF_BROADCAST))
859                 continue;
860             /*
861              * Get its netmask and check that it's on the right subnet.
862              */
863             if (ioctl(s, SIOCGIFNETMASK, &ifreq) < 0)
864                 continue;
865             mask = ((struct sockaddr_in *) &ifr->ifr_addr)->sin_addr.s_addr;
866             if ((ipaddr & mask) != (ina & mask))
867                 continue;
868
869             break;
870         }
871         ifr = (struct ifreq *) ((char *)&ifr->ifr_addr + ifr->ifr_addr.sa_len);
872     }
873
874     if (ifr >= ifend)
875         return 0;
876     syslog(LOG_INFO, "found interface %s for proxy arp", ifr->ifr_name);
877
878     /*
879      * Now scan through again looking for a link-level address
880      * for this interface.
881      */
882     ifp = ifr;
883     for (ifr = ifc.ifc_req; ifr < ifend; ) {
884         if (strcmp(ifp->ifr_name, ifr->ifr_name) == 0
885             && ifr->ifr_addr.sa_family == AF_LINK) {
886             /*
887              * Found the link-level address - copy it out
888              */
889             dla = (struct sockaddr_dl *) &ifr->ifr_addr;
890             BCOPY(dla, hwaddr, dla->sdl_len);
891             return 1;
892         }
893         ifr = (struct ifreq *) ((char *)&ifr->ifr_addr + ifr->ifr_addr.sa_len);
894     }
895
896     return 0;
897 }
898
899
900 /*
901  * ppp_available - check whether the system has any ppp interfaces
902  * (in fact we check whether we can do an ioctl on ppp0).
903  */
904 int
905 ppp_available()
906 {
907     int s, ok;
908     struct ifreq ifr;
909
910     if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
911         return 1;               /* can't tell - maybe we're not root */
912
913     strncpy(ifr.ifr_name, "ppp0", sizeof (ifr.ifr_name));
914     ok = ioctl(s, SIOCGIFFLAGS, (caddr_t) &ifr) >= 0;
915     close(s);
916
917     return ok;
918 }