xref: /freebsd/usr.sbin/ppp/ncpaddr.c (revision 057f1760a8171825b260dad27502f74ed5f69faf)
1 /*-
2  * Copyright (c) 2001 Brian Somers <brian@Awfulhak.org>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  *
26  * $FreeBSD$
27  */
28 
29 #include <sys/types.h>
30 #include <sys/socket.h>
31 #ifdef __OpenBSD__
32 #include <net/if_types.h>
33 #include <net/route.h>
34 #endif
35 #include <netinet/in.h>
36 #include <netinet/in_systm.h>
37 #include <netinet/ip.h>
38 #include <arpa/inet.h>
39 #include <sys/un.h>
40 
41 #include <netdb.h>
42 #include <stdio.h>
43 #include <stdlib.h>
44 #include <string.h>
45 #include <termios.h>
46 
47 #include "log.h"
48 #include "ncpaddr.h"
49 #include "timer.h"
50 #include "fsm.h"
51 #include "defs.h"
52 #include "slcompress.h"
53 #include "iplist.h"
54 #include "throughput.h"
55 #include "mbuf.h"
56 #include "ipcp.h"
57 #include "descriptor.h"
58 #include "layer.h"
59 #include "lqr.h"
60 #include "hdlc.h"
61 #include "lcp.h"
62 #include "ccp.h"
63 #include "link.h"
64 #include "mp.h"
65 #include "ipv6cp.h"
66 #include "ncp.h"
67 
68 
69 #define ncprange_ip4addr	u.ip4.ipaddr
70 #define ncprange_ip4mask	u.ip4.mask
71 #define ncprange_ip4width	u.ip4.width
72 #define ncpaddr_ip4addr		u.ip4addr
73 #ifndef NOINET6
74 #define ncprange_ip6addr	u.ip6.ipaddr
75 #define ncprange_ip6width	u.ip6.width
76 #define ncpaddr_ip6addr		u.ip6addr
77 #endif
78 
79 #define	NCP_ASCIIBUFFERSIZE	52
80 
81 static struct in_addr
82 bits2mask4(int bits)
83 {
84   struct in_addr result;
85   u_int32_t bit = 0x80000000;
86 
87   result.s_addr = 0;
88 
89   while (bits) {
90     result.s_addr |= bit;
91     bit >>= 1;
92     bits--;
93   }
94 
95   result.s_addr = htonl(result.s_addr);
96   return result;
97 }
98 
99 static int
100 mask42bits(struct in_addr mask)
101 {
102   u_int32_t msk = ntohl(mask.s_addr);
103   u_int32_t tst;
104   int ret;
105 
106   for (ret = 32, tst = 1; tst; ret--, tst <<= 1)
107     if (msk & tst)
108       break;
109 
110   for (tst <<= 1; tst; tst <<= 1)
111     if (!(msk & tst))
112       break;
113 
114   return tst ? -1 : ret;
115 }
116 
117 #ifndef NOINET6
118 static struct in6_addr
119 bits2mask6(int bits)
120 {
121   struct in6_addr result;
122   u_int32_t bit = 0x80;
123   u_char *c = result.s6_addr;
124 
125   memset(&result, '\0', sizeof result);
126 
127   while (bits) {
128     if (bit == 0) {
129       bit = 0x80;
130       c++;
131     }
132     *c |= bit;
133     bit >>= 1;
134     bits--;
135   }
136 
137   return result;
138 }
139 
140 static int
141 mask62bits(const struct in6_addr *mask)
142 {
143   const u_char masks[] = { 0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe };
144   const u_char *c, *p, *end;
145   int masklen, m;
146 
147   p = (const u_char *)mask;
148   for (masklen = 0, end = p + 16; p < end && *p == 0xff; p++)
149     masklen += 8;
150 
151   if (p < end) {
152     for (c = masks, m = 0; c < masks + sizeof masks; c++, m++)
153       if (*c == *p) {
154         masklen += m;
155         break;
156       }
157   }
158 
159   return masklen;
160 }
161 
162 #if 0
163 static void
164 adjust_linklocal(struct sockaddr_in6 *sin6)
165 {
166     /* XXX: ?????!?!?!!!!!  This is horrible ! */
167     /*
168      * The kernel does not understand sin6_scope_id for routing at this moment.
169      * We should rather keep the embedded ID.
170      * jinmei@kame.net, 20011026
171      */
172     if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr) ||
173         IN6_IS_ADDR_MC_LINKLOCAL(&sin6->sin6_addr)) {
174       sin6->sin6_scope_id =
175         ntohs(*(u_short *)&sin6->sin6_addr.s6_addr[2]);
176       *(u_short *)&sin6->sin6_addr.s6_addr[2] = 0;
177     }
178 }
179 #endif
180 #endif
181 
182 void
183 ncpaddr_init(struct ncpaddr *addr)
184 {
185   addr->ncpaddr_family = AF_UNSPEC;
186 }
187 
188 int
189 ncpaddr_isset(const struct ncpaddr *addr)
190 {
191   return addr->ncpaddr_family != AF_UNSPEC;
192 }
193 
194 int
195 ncpaddr_isdefault(const struct ncpaddr *addr)
196 {
197   switch (addr->ncpaddr_family) {
198   case AF_INET:
199     if (addr->ncpaddr_ip4addr.s_addr == INADDR_ANY)
200       return 1;
201     break;
202 
203 #ifndef NOINET6
204   case AF_INET6:
205     if (IN6_IS_ADDR_UNSPECIFIED(&addr->ncpaddr_ip6addr))
206       return 1;
207     break;
208 #endif
209   }
210 
211   return 0;
212 }
213 
214 int
215 ncpaddr_equal(const struct ncpaddr *addr, const struct ncpaddr *cmp)
216 {
217   if (addr->ncpaddr_family != cmp->ncpaddr_family)
218     return 0;
219 
220   switch (addr->ncpaddr_family) {
221   case AF_INET:
222     return addr->ncpaddr_ip4addr.s_addr == cmp->ncpaddr_ip4addr.s_addr;
223 
224 #ifndef NOINET6
225   case AF_INET6:
226     return !memcmp(&addr->ncpaddr_ip6addr, &cmp->ncpaddr_ip6addr,
227                    sizeof addr->ncpaddr_ip6addr);
228 #endif
229 
230   case AF_UNSPEC:
231     return 1;
232   }
233 
234   return 0;
235 }
236 
237 void
238 ncpaddr_copy(struct ncpaddr *addr, const struct ncpaddr *from)
239 {
240   switch (from->ncpaddr_family) {
241   case AF_INET:
242     addr->ncpaddr_family = AF_INET;
243     addr->ncpaddr_ip4addr = from->ncpaddr_ip4addr;
244     break;
245 #ifndef NOINET6
246   case AF_INET6:
247     addr->ncpaddr_family = AF_INET6;
248     addr->ncpaddr_ip6addr = from->ncpaddr_ip6addr;
249     break;
250 #endif
251   default:
252     addr->ncpaddr_family = AF_UNSPEC;
253   }
254 }
255 
256 void
257 ncpaddr_setip4addr(struct ncpaddr *addr, u_int32_t ip)
258 {
259   addr->ncpaddr_family = AF_INET;
260   addr->ncpaddr_ip4addr.s_addr = ip;
261 }
262 
263 int
264 ncpaddr_getip4addr(const struct ncpaddr *addr, u_int32_t *ip)
265 {
266   if (addr->ncpaddr_family != AF_INET)
267     return 0;
268   *ip = addr->ncpaddr_ip4addr.s_addr;
269   return 1;
270 }
271 
272 void
273 ncpaddr_setip4(struct ncpaddr *addr, struct in_addr ip)
274 {
275   addr->ncpaddr_family = AF_INET;
276   addr->ncpaddr_ip4addr = ip;
277 }
278 
279 int
280 ncpaddr_getip4(const struct ncpaddr *addr, struct in_addr *ip)
281 {
282   if (addr->ncpaddr_family != AF_INET)
283     return 0;
284   *ip = addr->ncpaddr_ip4addr;
285   return 1;
286 }
287 
288 #ifndef NOINET6
289 void
290 ncpaddr_setip6(struct ncpaddr *addr, const struct in6_addr *ip6)
291 {
292   addr->ncpaddr_family = AF_INET6;
293   addr->ncpaddr_ip6addr = *ip6;
294 }
295 
296 int
297 ncpaddr_getip6(const struct ncpaddr *addr, struct in6_addr *ip6)
298 {
299   if (addr->ncpaddr_family != AF_INET6)
300     return 0;
301   *ip6 = addr->ncpaddr_ip6addr;
302   return 1;
303 }
304 #endif
305 
306 void
307 ncpaddr_getsa(const struct ncpaddr *addr, struct sockaddr_storage *host)
308 {
309   struct sockaddr_in *host4 = (struct sockaddr_in *)host;
310 #ifndef NOINET6
311   struct sockaddr_in6 *host6 = (struct sockaddr_in6 *)host;
312 #endif
313 
314   memset(host, '\0', sizeof(*host));
315 
316   switch (addr->ncpaddr_family) {
317   case AF_INET:
318     host4->sin_family = AF_INET;
319     host4->sin_len = sizeof(*host4);
320     host4->sin_addr = addr->ncpaddr_ip4addr;
321     break;
322 
323 #ifndef NOINET6
324   case AF_INET6:
325     host6->sin6_family = AF_INET6;
326     host6->sin6_len = sizeof(*host6);
327     host6->sin6_addr = addr->ncpaddr_ip6addr;
328     break;
329 #endif
330 
331   default:
332     host->ss_family = AF_UNSPEC;
333     break;
334   }
335 }
336 
337 void
338 ncpaddr_setsa(struct ncpaddr *addr, const struct sockaddr *host)
339 {
340   const struct sockaddr_in *host4 = (const struct sockaddr_in *)host;
341 #ifndef NOINET6
342   const struct sockaddr_in6 *host6 = (const struct sockaddr_in6 *)host;
343 #endif
344 
345   switch (host->sa_family) {
346   case AF_INET:
347     addr->ncpaddr_family = AF_INET;
348     addr->ncpaddr_ip4addr = host4->sin_addr;
349     break;
350 
351 #ifndef NOINET6
352   case AF_INET6:
353     if (IN6_IS_ADDR_V4MAPPED(&host6->sin6_addr)) {
354       addr->ncpaddr_family = AF_INET;
355       addr->ncpaddr_ip4addr.s_addr =
356         *(const u_int32_t *)(host6->sin6_addr.s6_addr + 12);
357     } else {
358       addr->ncpaddr_family = AF_INET6;
359       addr->ncpaddr_ip6addr = host6->sin6_addr;
360     }
361     break;
362 #endif
363 
364   default:
365     addr->ncpaddr_family = AF_UNSPEC;
366   }
367 }
368 
369 static char *
370 ncpaddr_ntowa(const struct ncpaddr *addr)
371 {
372   static char res[NCP_ASCIIBUFFERSIZE];
373 #ifndef NOINET6
374   struct sockaddr_in6 sin6;
375 #endif
376 
377   switch (addr->ncpaddr_family) {
378   case AF_INET:
379     snprintf(res, sizeof res, "%s", inet_ntoa(addr->ncpaddr_ip4addr));
380     return res;
381 
382 #ifndef NOINET6
383   case AF_INET6:
384     memset(&sin6, '\0', sizeof(sin6));
385     sin6.sin6_len = sizeof(sin6);
386     sin6.sin6_family = AF_INET6;
387     sin6.sin6_addr = addr->ncpaddr_ip6addr;
388 #if 0
389     adjust_linklocal(&sin6);
390 #endif
391 #ifdef NI_WITHSCOPEID
392     if (getnameinfo((struct sockaddr *)&sin6, sizeof sin6, res, sizeof(res),
393                     NULL, 0, NI_WITHSCOPEID | NI_NUMERICHOST) != 0)
394 #else
395     if (getnameinfo((struct sockaddr *)&sin6, sizeof sin6, res, sizeof(res),
396                     NULL, 0, NI_NUMERICHOST) != 0)
397 #endif
398       break;
399 
400     return res;
401 #endif
402   }
403 
404   snprintf(res, sizeof res, "<AF_UNSPEC>");
405   return res;
406 }
407 
408 const char *
409 ncpaddr_ntoa(const struct ncpaddr *addr)
410 {
411   return ncpaddr_ntowa(addr);
412 }
413 
414 
415 int
416 ncpaddr_aton(struct ncpaddr *addr, struct ncp *ncp, const char *data)
417 {
418   struct ncprange range;
419 
420   if (!ncprange_aton(&range, ncp, data))
421     return 0;
422 
423   if (range.ncprange_family == AF_INET && range.ncprange_ip4width != 32 &&
424       range.ncprange_ip4addr.s_addr != INADDR_ANY) {
425     log_Printf(LogWARN, "ncpaddr_aton: %s: Only 32 bits allowed\n", data);
426     return 0;
427   }
428 
429 #ifndef NOINET6
430   if (range.ncprange_family == AF_INET6 && range.ncprange_ip6width != 128 &&
431       !IN6_IS_ADDR_UNSPECIFIED(&range.ncprange_ip6addr)) {
432     log_Printf(LogWARN, "ncpaddr_aton: %s: Only 128 bits allowed\n", data);
433     return 0;
434   }
435 #endif
436 
437   switch (range.ncprange_family) {
438   case AF_INET:
439     addr->ncpaddr_family = range.ncprange_family;
440     addr->ncpaddr_ip4addr = range.ncprange_ip4addr;
441     return 1;
442 
443 #ifndef NOINET6
444   case AF_INET6:
445     addr->ncpaddr_family = range.ncprange_family;
446     addr->ncpaddr_ip6addr = range.ncprange_ip6addr;
447     return 1;
448 #endif
449   }
450 
451   return 0;
452 }
453 
454 void
455 ncprange_init(struct ncprange *range)
456 {
457   range->ncprange_family = AF_UNSPEC;
458 }
459 
460 int
461 ncprange_isset(const struct ncprange *range)
462 {
463   return range->ncprange_family != AF_UNSPEC;
464 }
465 
466 int
467 ncprange_equal(const struct ncprange *range, const struct ncprange *cmp)
468 {
469   if (range->ncprange_family != cmp->ncprange_family)
470     return 0;
471 
472   switch (range->ncprange_family) {
473   case AF_INET:
474     if (range->ncprange_ip4addr.s_addr != cmp->ncprange_ip4addr.s_addr)
475       return 0;
476     return range->ncprange_ip4mask.s_addr == cmp->ncprange_ip4mask.s_addr;
477 
478 #ifndef NOINET6
479   case AF_INET6:
480     if (range->ncprange_ip6width != cmp->ncprange_ip6width)
481       return 0;
482     return !memcmp(&range->ncprange_ip6addr, &cmp->ncprange_ip6addr,
483                    sizeof range->ncprange_ip6addr);
484 #endif
485 
486   case AF_UNSPEC:
487     return 1;
488   }
489 
490   return 0;
491 }
492 
493 int
494 ncprange_isdefault(const struct ncprange *range)
495 {
496   switch (range->ncprange_family) {
497   case AF_INET:
498     if (range->ncprange_ip4addr.s_addr == INADDR_ANY)
499       return 1;
500     break;
501 
502 #ifndef NOINET6
503   case AF_INET6:
504     if (range->ncprange_ip6width == 0 &&
505         IN6_IS_ADDR_UNSPECIFIED(&range->ncprange_ip6addr))
506       return 1;
507     break;
508 #endif
509   }
510 
511   return 0;
512 }
513 
514 void
515 ncprange_setdefault(struct ncprange *range, int af)
516 {
517   memset(range, '\0', sizeof *range);
518   range->ncprange_family = af;
519 }
520 
521 int
522 ncprange_contains(const struct ncprange *range, const struct ncpaddr *addr)
523 {
524 #ifndef NOINET6
525   const u_char masks[] = { 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff };
526   const u_char *addrp, *rangep;
527   int bits;
528 #endif
529 
530   if (range->ncprange_family != addr->ncpaddr_family)
531     return 0;
532 
533   switch (range->ncprange_family) {
534   case AF_INET:
535     return !((addr->ncpaddr_ip4addr.s_addr ^ range->ncprange_ip4addr.s_addr) &
536              range->ncprange_ip4mask.s_addr);
537 
538 #ifndef NOINET6
539   case AF_INET6:
540     rangep = (const u_char *)range->ncprange_ip6addr.s6_addr;
541     addrp = (const u_char *)addr->ncpaddr_ip6addr.s6_addr;
542 
543     for (bits = range->ncprange_ip6width; bits > 0; bits -= 8)
544       if ((*addrp++ ^ *rangep++) & masks[bits > 7 ? 7 : bits - 1])
545         return 0;
546 
547     return 1;
548 #endif
549   }
550 
551   return 0;
552 }
553 
554 int
555 ncprange_containsip4(const struct ncprange *range, struct in_addr addr)
556 {
557   switch (range->ncprange_family) {
558   case AF_INET:
559     return !((addr.s_addr ^ range->ncprange_ip4addr.s_addr) &
560              range->ncprange_ip4mask.s_addr);
561   }
562 
563   return 0;
564 }
565 
566 void
567 ncprange_copy(struct ncprange *range, const struct ncprange *from)
568 {
569   switch (from->ncprange_family) {
570   case AF_INET:
571     range->ncprange_family = AF_INET;
572     range->ncprange_ip4addr = from->ncprange_ip4addr;
573     range->ncprange_ip4mask = from->ncprange_ip4mask;
574     range->ncprange_ip4width = from->ncprange_ip4width;
575     break;
576 
577 #ifndef NOINET6
578   case AF_INET6:
579     range->ncprange_family = AF_INET6;
580     range->ncprange_ip6addr = from->ncprange_ip6addr;
581     range->ncprange_ip6width = from->ncprange_ip6width;
582     break;
583 #endif
584 
585   default:
586     range->ncprange_family = AF_UNSPEC;
587   }
588 }
589 
590 void
591 ncprange_set(struct ncprange *range, const struct ncpaddr *addr, int width)
592 {
593   ncprange_sethost(range, addr);
594   ncprange_setwidth(range, width);
595 }
596 
597 void
598 ncprange_sethost(struct ncprange *range, const struct ncpaddr *from)
599 {
600   switch (from->ncpaddr_family) {
601   case AF_INET:
602     range->ncprange_family = AF_INET;
603     range->ncprange_ip4addr = from->ncpaddr_ip4addr;
604     if (from->ncpaddr_ip4addr.s_addr == INADDR_ANY) {
605       range->ncprange_ip4mask.s_addr = INADDR_ANY;
606       range->ncprange_ip4width = 0;
607     } else {
608       range->ncprange_ip4mask.s_addr = INADDR_BROADCAST;
609       range->ncprange_ip4width = 32;
610     }
611     break;
612 
613 #ifndef NOINET6
614   case AF_INET6:
615     range->ncprange_family = AF_INET6;
616     range->ncprange_ip6addr = from->ncpaddr_ip6addr;
617     range->ncprange_ip6width = 128;
618     break;
619 #endif
620 
621   default:
622     range->ncprange_family = AF_UNSPEC;
623   }
624 }
625 
626 int
627 ncprange_ishost(const struct ncprange *range)
628 {
629   switch (range->ncprange_family) {
630   case AF_INET:
631     return range->ncprange_ip4width == 32;
632 #ifndef NOINET6
633   case AF_INET6:
634     return range->ncprange_ip6width == 128;
635 #endif
636   }
637 
638   return (0);
639 }
640 
641 int
642 ncprange_setwidth(struct ncprange *range, int width)
643 {
644   switch (range->ncprange_family) {
645   case AF_INET:
646     if (width < 0 || width > 32)
647       break;
648     range->ncprange_ip4width = width;
649     range->ncprange_ip4mask = bits2mask4(width);
650     break;
651 
652 #ifndef NOINET6
653   case AF_INET6:
654     if (width < 0 || width > 128)
655       break;
656     range->ncprange_ip6width = width;
657     break;
658 #endif
659 
660   case AF_UNSPEC:
661     return 1;
662   }
663 
664   return 0;
665 }
666 
667 void
668 ncprange_setip4host(struct ncprange *range, struct in_addr from)
669 {
670   range->ncprange_family = AF_INET;
671   range->ncprange_ip4addr = from;
672   if (from.s_addr == INADDR_ANY) {
673     range->ncprange_ip4mask.s_addr = INADDR_ANY;
674     range->ncprange_ip4width = 0;
675   } else {
676     range->ncprange_ip4mask.s_addr = INADDR_BROADCAST;
677     range->ncprange_ip4width = 32;
678   }
679 }
680 
681 void
682 ncprange_setip4(struct ncprange *range, struct in_addr from, struct in_addr msk)
683 {
684   range->ncprange_family = AF_INET;
685   range->ncprange_ip4addr = from;
686   range->ncprange_ip4mask = msk;
687   range->ncprange_ip4width = mask42bits(msk);
688 }
689 
690 
691 int
692 ncprange_setip4mask(struct ncprange *range, struct in_addr mask)
693 {
694   if (range->ncprange_family != AF_INET)
695     return 0;
696   range->ncprange_ip4mask = mask;
697   range->ncprange_ip4width = mask42bits(mask);
698   return 1;
699 }
700 
701 void
702 ncprange_setsa(struct ncprange *range, const struct sockaddr *host,
703                const struct sockaddr *mask)
704 {
705   const struct sockaddr_in *host4 = (const struct sockaddr_in *)host;
706   const struct sockaddr_in *mask4 = (const struct sockaddr_in *)mask;
707 #ifndef NOINET6
708   const struct sockaddr_in6 *host6 = (const struct sockaddr_in6 *)host;
709   const struct sockaddr_in6 *mask6 = (const struct sockaddr_in6 *)mask;
710 #endif
711 
712   switch (host->sa_family) {
713   case AF_INET:
714     range->ncprange_family = AF_INET;
715     range->ncprange_ip4addr = host4->sin_addr;
716     if (host4->sin_addr.s_addr == INADDR_ANY) {
717       range->ncprange_ip4mask.s_addr = INADDR_ANY;
718       range->ncprange_ip4width = 0;
719     } else if (mask4 && mask4->sin_family == AF_INET) {
720       range->ncprange_ip4mask.s_addr = mask4->sin_addr.s_addr;
721       range->ncprange_ip4width = mask42bits(mask4->sin_addr);
722     } else {
723       range->ncprange_ip4mask.s_addr = INADDR_BROADCAST;
724       range->ncprange_ip4width = 32;
725     }
726     break;
727 
728 #ifndef NOINET6
729   case AF_INET6:
730     range->ncprange_family = AF_INET6;
731     range->ncprange_ip6addr = host6->sin6_addr;
732     if (IN6_IS_ADDR_UNSPECIFIED(&host6->sin6_addr))
733       range->ncprange_ip6width = 0;
734     else
735       range->ncprange_ip6width = mask6 ? mask62bits(&mask6->sin6_addr) : 128;
736     break;
737 #endif
738 
739   default:
740     range->ncprange_family = AF_UNSPEC;
741   }
742 }
743 
744 void
745 ncprange_getsa(const struct ncprange *range, struct sockaddr_storage *host,
746                struct sockaddr_storage *mask)
747 {
748   struct sockaddr_in *host4 = (struct sockaddr_in *)host;
749   struct sockaddr_in *mask4 = (struct sockaddr_in *)mask;
750 #ifndef NOINET6
751   struct sockaddr_in6 *host6 = (struct sockaddr_in6 *)host;
752   struct sockaddr_in6 *mask6 = (struct sockaddr_in6 *)mask;
753 #endif
754 
755   memset(host, '\0', sizeof(*host));
756   if (mask)
757     memset(mask, '\0', sizeof(*mask));
758 
759   switch (range->ncprange_family) {
760   case AF_INET:
761     host4->sin_family = AF_INET;
762     host4->sin_len = sizeof(*host4);
763     host4->sin_addr = range->ncprange_ip4addr;
764     if (mask4) {
765       mask4->sin_family = AF_INET;
766       mask4->sin_len = sizeof(*host4);
767       mask4->sin_addr = range->ncprange_ip4mask;
768     }
769     break;
770 
771 #ifndef NOINET6
772   case AF_INET6:
773     host6->sin6_family = AF_INET6;
774     host6->sin6_len = sizeof(*host6);
775     host6->sin6_addr = range->ncprange_ip6addr;
776     if (mask6) {
777       mask6->sin6_family = AF_INET6;
778       mask6->sin6_len = sizeof(*host6);
779       mask6->sin6_addr = bits2mask6(range->ncprange_ip6width);
780     }
781     break;
782 #endif
783 
784   default:
785     host->ss_family = AF_UNSPEC;
786     if (mask)
787       mask->ss_family = AF_UNSPEC;
788     break;
789   }
790 }
791 
792 int
793 ncprange_getaddr(const struct ncprange *range, struct ncpaddr *addr)
794 {
795   switch (range->ncprange_family) {
796   case AF_INET:
797     addr->ncpaddr_family = AF_INET;
798     addr->ncpaddr_ip4addr = range->ncprange_ip4addr;
799     return 1;
800 #ifndef NOINET6
801   case AF_INET6:
802     addr->ncpaddr_family = AF_INET6;
803     addr->ncpaddr_ip6addr =  range->ncprange_ip6addr;
804     return 1;
805 #endif
806   }
807 
808   return 0;
809 }
810 
811 int
812 ncprange_getip4addr(const struct ncprange *range, struct in_addr *addr)
813 {
814   if (range->ncprange_family != AF_INET)
815     return 0;
816 
817   *addr = range->ncprange_ip4addr;
818   return 1;
819 }
820 
821 int
822 ncprange_getip4mask(const struct ncprange *range, struct in_addr *mask)
823 {
824   switch (range->ncprange_family) {
825   case AF_INET:
826     *mask = range->ncprange_ip4mask;
827     return 1;
828   }
829 
830   return 0;
831 }
832 
833 int
834 ncprange_getwidth(const struct ncprange *range, int *width)
835 {
836   switch (range->ncprange_family) {
837   case AF_INET:
838     *width = range->ncprange_ip4width;
839     return 1;
840 #ifndef NOINET6
841   case AF_INET6:
842     *width = range->ncprange_ip6width;
843     return 1;
844 #endif
845   }
846 
847   return 0;
848 }
849 
850 const char *
851 ncprange_ntoa(const struct ncprange *range)
852 {
853   char *res;
854   struct ncpaddr addr;
855   int len;
856 
857   if (!ncprange_getaddr(range, &addr))
858     return "<AF_UNSPEC>";
859 
860   res = ncpaddr_ntowa(&addr);
861   len = strlen(res);
862   if (len >= NCP_ASCIIBUFFERSIZE - 1)
863     return res;
864 
865   switch (range->ncprange_family) {
866   case AF_INET:
867     if (range->ncprange_ip4width == -1) {
868       /* A non-contiguous mask */
869       for (; len >= 3; res[len -= 2] = '\0')
870         if (strcmp(res + len - 2, ".0"))
871           break;
872       snprintf(res + len, sizeof res - len, "&0x%08lx",
873                (unsigned long)ntohl(range->ncprange_ip4mask.s_addr));
874     } else if (range->ncprange_ip4width < 32)
875       snprintf(res + len, sizeof res - len, "/%d", range->ncprange_ip4width);
876 
877     return res;
878 
879 #ifndef NOINET6
880   case AF_INET6:
881     if (range->ncprange_ip6width != 128)
882       snprintf(res + len, sizeof res - len, "/%d", range->ncprange_ip6width);
883 
884     return res;
885 #endif
886   }
887 
888   return "<AF_UNSPEC>";
889 }
890 
891 #ifndef NOINET6
892 int
893 ncprange_scopeid(const struct ncprange *range)
894 {
895   const struct in6_addr *sin6;
896   int scopeid = -1;
897 
898   if (range->ncprange_family == AF_INET6) {
899     sin6 = &range->ncprange_ip6addr;
900     if (IN6_IS_ADDR_LINKLOCAL(sin6) || IN6_IS_ADDR_MC_LINKLOCAL(sin6))
901       if ((scopeid = ntohs(*(const u_short *)&sin6->s6_addr[2])) == 0)
902         scopeid = -1;
903   }
904 
905   return scopeid;
906 }
907 #endif
908 
909 int
910 ncprange_aton(struct ncprange *range, struct ncp *ncp, const char *data)
911 {
912   int bits, len;
913   char *wp;
914   const char *cp;
915   char *s;
916 
917   len = strcspn(data, "/");
918 
919   if (ncp && strncasecmp(data, "HISADDR", len) == 0) {
920     range->ncprange_family = AF_INET;
921     range->ncprange_ip4addr = ncp->ipcp.peer_ip;
922     range->ncprange_ip4mask.s_addr = INADDR_BROADCAST;
923     range->ncprange_ip4width = 32;
924     return 1;
925 #ifndef NOINET6
926   } else if (ncp && strncasecmp(data, "HISADDR6", len) == 0) {
927     range->ncprange_family = AF_INET6;
928     range->ncprange_ip6addr = ncp->ipv6cp.hisaddr.ncpaddr_ip6addr;
929     range->ncprange_ip6width = 128;
930     return 1;
931 #endif
932   } else if (ncp && strncasecmp(data, "MYADDR", len) == 0) {
933     range->ncprange_family = AF_INET;
934     range->ncprange_ip4addr = ncp->ipcp.my_ip;
935     range->ncprange_ip4mask.s_addr = INADDR_BROADCAST;
936     range->ncprange_ip4width = 32;
937     return 1;
938 #ifndef NOINET6
939   } else if (ncp && strncasecmp(data, "MYADDR6", len) == 0) {
940     range->ncprange_family = AF_INET6;
941     range->ncprange_ip6addr = ncp->ipv6cp.myaddr.ncpaddr_ip6addr;
942     range->ncprange_ip6width = 128;
943     return 1;
944 #endif
945   } else if (ncp && strncasecmp(data, "DNS0", len) == 0) {
946     range->ncprange_family = AF_INET;
947     range->ncprange_ip4addr = ncp->ipcp.ns.dns[0];
948     range->ncprange_ip4mask.s_addr = INADDR_BROADCAST;
949     range->ncprange_ip4width = 32;
950     return 1;
951   } else if (ncp && strncasecmp(data, "DNS1", len) == 0) {
952     range->ncprange_family = AF_INET;
953     range->ncprange_ip4addr = ncp->ipcp.ns.dns[1];
954     range->ncprange_ip4mask.s_addr = INADDR_BROADCAST;
955     range->ncprange_ip4width = 32;
956     return 1;
957   }
958 
959   s = (char *)alloca(len + 1);
960   strncpy(s, data, len);
961   s[len] = '\0';
962   bits = -1;
963 
964   if (data[len] != '\0') {
965     bits = strtol(data + len + 1, &wp, 0);
966     if (*wp || wp == data + len + 1 || bits < 0 || bits > 128) {
967       log_Printf(LogWARN, "ncprange_aton: bad mask width.\n");
968       return 0;
969     }
970   }
971 
972   if ((cp = strchr(data, ':')) == NULL) {
973     range->ncprange_family = AF_INET;
974 
975     range->ncprange_ip4addr = GetIpAddr(s);
976 
977     if (range->ncprange_ip4addr.s_addr == INADDR_NONE) {
978       log_Printf(LogWARN, "ncprange_aton: %s: Bad address\n", s);
979       return 0;
980     }
981 
982     if (range->ncprange_ip4addr.s_addr == INADDR_ANY) {
983       range->ncprange_ip4mask.s_addr = INADDR_ANY;
984       range->ncprange_ip4width = 0;
985     } else if (bits == -1) {
986       range->ncprange_ip4mask.s_addr = INADDR_BROADCAST;
987       range->ncprange_ip4width = 32;
988     } else if (bits > 32) {
989       log_Printf(LogWARN, "ncprange_aton: bad mask width.\n");
990       return 0;
991     } else {
992       range->ncprange_ip4mask = bits2mask4(bits);
993       range->ncprange_ip4width = bits;
994     }
995 
996     return 1;
997 #ifndef NOINET6
998   } else if (strchr(cp + 1, ':') != NULL) {
999     range->ncprange_family = AF_INET6;
1000 
1001     if (inet_pton(AF_INET6, s, &range->ncprange_ip6addr) != 1) {
1002       log_Printf(LogWARN, "ncprange_aton: %s: Bad address\n", s);
1003       return 0;
1004     }
1005 
1006     if (IN6_IS_ADDR_UNSPECIFIED(&range->ncprange_ip6addr))
1007       range->ncprange_ip6width = 0;
1008     else
1009       range->ncprange_ip6width = (bits == -1) ? 128 : bits;
1010     return 1;
1011 #endif
1012   }
1013 
1014   return 0;
1015 }
1016