2 * Copyright (c) 2001 Brian Somers <brian@Awfulhak.org>
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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.
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
26 * $FreeBSD: src/usr.sbin/ppp/ncpaddr.c,v 1.10.2.3 2003/04/29 16:05:55 ume Exp $
27 * $DragonFly: src/usr.sbin/ppp/ncpaddr.c,v 1.3 2006/01/18 00:49:16 dillon Exp $
30 #include <sys/types.h>
31 #include <sys/socket.h>
33 #include <net/if_types.h>
34 #include <net/route.h>
36 #include <netinet/in.h>
37 #include <netinet/in_systm.h>
38 #include <netinet/ip.h>
39 #include <arpa/inet.h>
53 #include "slcompress.h"
55 #include "throughput.h"
58 #include "descriptor.h"
70 #define ncprange_ip4addr u.ip4.ipaddr
71 #define ncprange_ip4mask u.ip4.mask
72 #define ncprange_ip4width u.ip4.width
73 #define ncpaddr_ip4addr u.ip4addr
75 #define ncprange_ip6addr u.ip6.ipaddr
76 #define ncprange_ip6width u.ip6.width
77 #define ncpaddr_ip6addr u.ip6addr
80 #define NCP_ASCIIBUFFERSIZE 52
85 struct in_addr result
;
86 u_int32_t bit
= 0x80000000;
96 result
.s_addr
= htonl(result
.s_addr
);
101 mask42bits(struct in_addr mask
)
103 u_int32_t msk
= ntohl(mask
.s_addr
);
107 for (ret
= 32, tst
= 1; tst
; ret
--, tst
<<= 1)
111 for (tst
<<= 1; tst
; tst
<<= 1)
115 return tst
? -1 : ret
;
119 static struct in6_addr
122 struct in6_addr result
;
123 u_int32_t bit
= 0x80;
124 u_char
*c
= result
.s6_addr
;
126 memset(&result
, '\0', sizeof result
);
142 mask62bits(const struct in6_addr
*mask
)
144 const u_char masks
[] = { 0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe };
145 const u_char
*c
, *p
, *end
;
148 p
= (const u_char
*)mask
;
149 for (masklen
= 0, end
= p
+ 16; p
< end
&& *p
== 0xff; p
++)
153 for (c
= masks
; c
< masks
+ sizeof masks
; c
++)
155 masklen
+= c
- masks
;
164 adjust_linklocal(struct sockaddr_in6
*sin6
)
166 /* XXX: ?????!?!?!!!!! This is horrible ! */
169 * The kernel does not understand sin6_scope_id for routing at this moment.
170 * We should rather keep the embedded ID.
171 * jinmei@kame.net, 20011026
173 if (IN6_IS_ADDR_LINKLOCAL(&sin6
->sin6_addr
) ||
174 IN6_IS_ADDR_MC_LINKLOCAL(&sin6
->sin6_addr
)) {
175 sin6
->sin6_scope_id
=
176 ntohs(*(u_short
*)&sin6
->sin6_addr
.s6_addr
[2]);
177 *(u_short
*)&sin6
->sin6_addr
.s6_addr
[2] = 0;
184 ncpaddr_init(struct ncpaddr
*addr
)
186 addr
->ncpaddr_family
= AF_UNSPEC
;
190 ncpaddr_isset(const struct ncpaddr
*addr
)
192 return addr
->ncpaddr_family
!= AF_UNSPEC
;
196 ncpaddr_isdefault(const struct ncpaddr
*addr
)
198 switch (addr
->ncpaddr_family
) {
200 if (addr
->ncpaddr_ip4addr
.s_addr
== INADDR_ANY
)
206 if (IN6_IS_ADDR_UNSPECIFIED(&addr
->ncpaddr_ip6addr
))
216 ncpaddr_equal(const struct ncpaddr
*addr
, const struct ncpaddr
*cmp
)
218 if (addr
->ncpaddr_family
!= cmp
->ncpaddr_family
)
221 switch (addr
->ncpaddr_family
) {
223 return addr
->ncpaddr_ip4addr
.s_addr
== cmp
->ncpaddr_ip4addr
.s_addr
;
227 return !memcmp(&addr
->ncpaddr_ip6addr
, &cmp
->ncpaddr_ip6addr
,
228 sizeof addr
->ncpaddr_ip6addr
);
239 ncpaddr_copy(struct ncpaddr
*addr
, const struct ncpaddr
*from
)
241 switch (from
->ncpaddr_family
) {
243 addr
->ncpaddr_family
= AF_INET
;
244 addr
->ncpaddr_ip4addr
= from
->ncpaddr_ip4addr
;
248 addr
->ncpaddr_family
= AF_INET6
;
249 addr
->ncpaddr_ip6addr
= from
->ncpaddr_ip6addr
;
253 addr
->ncpaddr_family
= AF_UNSPEC
;
258 ncpaddr_setip4addr(struct ncpaddr
*addr
, u_int32_t ip
)
260 addr
->ncpaddr_family
= AF_INET
;
261 addr
->ncpaddr_ip4addr
.s_addr
= ip
;
265 ncpaddr_getip4addr(const struct ncpaddr
*addr
, u_int32_t
*ip
)
267 if (addr
->ncpaddr_family
!= AF_INET
)
269 *ip
= addr
->ncpaddr_ip4addr
.s_addr
;
274 ncpaddr_setip4(struct ncpaddr
*addr
, struct in_addr ip
)
276 addr
->ncpaddr_family
= AF_INET
;
277 addr
->ncpaddr_ip4addr
= ip
;
281 ncpaddr_getip4(const struct ncpaddr
*addr
, struct in_addr
*ip
)
283 if (addr
->ncpaddr_family
!= AF_INET
)
285 *ip
= addr
->ncpaddr_ip4addr
;
291 ncpaddr_setip6(struct ncpaddr
*addr
, const struct in6_addr
*ip6
)
293 addr
->ncpaddr_family
= AF_INET6
;
294 addr
->ncpaddr_ip6addr
= *ip6
;
298 ncpaddr_getip6(const struct ncpaddr
*addr
, struct in6_addr
*ip6
)
300 if (addr
->ncpaddr_family
!= AF_INET6
)
302 *ip6
= addr
->ncpaddr_ip6addr
;
308 ncpaddr_getsa(const struct ncpaddr
*addr
, struct sockaddr_storage
*host
)
310 struct sockaddr_in
*host4
= (struct sockaddr_in
*)host
;
312 struct sockaddr_in6
*host6
= (struct sockaddr_in6
*)host
;
315 memset(host
, '\0', sizeof(*host
));
317 switch (addr
->ncpaddr_family
) {
319 host4
->sin_family
= AF_INET
;
320 host4
->sin_len
= sizeof(*host4
);
321 host4
->sin_addr
= addr
->ncpaddr_ip4addr
;
326 host6
->sin6_family
= AF_INET6
;
327 host6
->sin6_len
= sizeof(*host6
);
328 host6
->sin6_addr
= addr
->ncpaddr_ip6addr
;
333 host
->ss_family
= AF_UNSPEC
;
339 ncpaddr_setsa(struct ncpaddr
*addr
, const struct sockaddr
*host
)
341 const struct sockaddr_in
*host4
= (const struct sockaddr_in
*)host
;
343 const struct sockaddr_in6
*host6
= (const struct sockaddr_in6
*)host
;
346 switch (host
->sa_family
) {
348 addr
->ncpaddr_family
= AF_INET
;
349 addr
->ncpaddr_ip4addr
= host4
->sin_addr
;
354 if (IN6_IS_ADDR_V4MAPPED(&host6
->sin6_addr
)) {
355 addr
->ncpaddr_family
= AF_INET
;
356 addr
->ncpaddr_ip4addr
.s_addr
=
357 *(const u_int32_t
*)(host6
->sin6_addr
.s6_addr
+ 12);
359 addr
->ncpaddr_family
= AF_INET6
;
360 addr
->ncpaddr_ip6addr
= host6
->sin6_addr
;
366 addr
->ncpaddr_family
= AF_UNSPEC
;
371 ncpaddr_ntowa(const struct ncpaddr
*addr
)
373 static char res
[NCP_ASCIIBUFFERSIZE
];
375 struct sockaddr_in6 sin6
;
378 switch (addr
->ncpaddr_family
) {
380 snprintf(res
, sizeof res
, "%s", inet_ntoa(addr
->ncpaddr_ip4addr
));
385 memset(&sin6
, '\0', sizeof(sin6
));
386 sin6
.sin6_len
= sizeof(sin6
);
387 sin6
.sin6_family
= AF_INET6
;
388 sin6
.sin6_addr
= addr
->ncpaddr_ip6addr
;
389 adjust_linklocal(&sin6
);
390 #ifdef NI_WITHSCOPEID
391 if (getnameinfo((struct sockaddr
*)&sin6
, sizeof sin6
, res
, sizeof(res
),
392 NULL
, 0, NI_WITHSCOPEID
| NI_NUMERICHOST
) != 0)
394 if (getnameinfo((struct sockaddr
*)&sin6
, sizeof sin6
, res
, sizeof(res
),
395 NULL
, 0, NI_NUMERICHOST
) != 0)
403 snprintf(res
, sizeof res
, "<AF_UNSPEC>");
408 ncpaddr_ntoa(const struct ncpaddr
*addr
)
410 return ncpaddr_ntowa(addr
);
415 ncpaddr_aton(struct ncpaddr
*addr
, struct ncp
*ncp
, const char *data
)
417 struct ncprange range
;
419 if (!ncprange_aton(&range
, ncp
, data
))
422 if (range
.ncprange_family
== AF_INET
&& range
.ncprange_ip4width
!= 32) {
423 log_Printf(LogWARN
, "ncpaddr_aton: %s: Only 32 bits allowed\n", data
);
428 if (range
.ncprange_family
== AF_INET6
&& range
.ncprange_ip6width
!= 128) {
429 log_Printf(LogWARN
, "ncpaddr_aton: %s: Only 128 bits allowed\n", data
);
434 switch (range
.ncprange_family
) {
436 addr
->ncpaddr_family
= range
.ncprange_family
;
437 addr
->ncpaddr_ip4addr
= range
.ncprange_ip4addr
;
442 addr
->ncpaddr_family
= range
.ncprange_family
;
443 addr
->ncpaddr_ip6addr
= range
.ncprange_ip6addr
;
452 ncprange_init(struct ncprange
*range
)
454 range
->ncprange_family
= AF_UNSPEC
;
458 ncprange_isset(const struct ncprange
*range
)
460 return range
->ncprange_family
!= AF_UNSPEC
;
464 ncprange_equal(const struct ncprange
*range
, const struct ncprange
*cmp
)
466 if (range
->ncprange_family
!= cmp
->ncprange_family
)
469 switch (range
->ncprange_family
) {
471 if (range
->ncprange_ip4addr
.s_addr
!= cmp
->ncprange_ip4addr
.s_addr
)
473 return range
->ncprange_ip4mask
.s_addr
== cmp
->ncprange_ip4mask
.s_addr
;
477 if (range
->ncprange_ip6width
!= cmp
->ncprange_ip6width
)
479 return !memcmp(&range
->ncprange_ip6addr
, &cmp
->ncprange_ip6addr
,
480 sizeof range
->ncprange_ip6addr
);
491 ncprange_isdefault(const struct ncprange
*range
)
493 switch (range
->ncprange_family
) {
495 if (range
->ncprange_ip4addr
.s_addr
== INADDR_ANY
)
501 if (range
->ncprange_ip6width
== 0 &&
502 IN6_IS_ADDR_UNSPECIFIED(&range
->ncprange_ip6addr
))
512 ncprange_setdefault(struct ncprange
*range
, int af
)
514 memset(range
, '\0', sizeof *range
);
515 range
->ncprange_family
= af
;
519 ncprange_contains(const struct ncprange
*range
, const struct ncpaddr
*addr
)
522 const u_char masks
[] = { 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff };
523 const u_char
*addrp
, *rangep
;
527 if (range
->ncprange_family
!= addr
->ncpaddr_family
)
530 switch (range
->ncprange_family
) {
532 return !((addr
->ncpaddr_ip4addr
.s_addr
^ range
->ncprange_ip4addr
.s_addr
) &
533 range
->ncprange_ip4mask
.s_addr
);
537 rangep
= (const u_char
*)range
->ncprange_ip6addr
.s6_addr
;
538 addrp
= (const u_char
*)addr
->ncpaddr_ip6addr
.s6_addr
;
540 for (bits
= range
->ncprange_ip6width
; bits
> 0; bits
-= 8)
541 if ((*addrp
++ ^ *rangep
++) & masks
[bits
> 7 ? 7 : bits
- 1])
552 ncprange_containsip4(const struct ncprange
*range
, struct in_addr addr
)
554 switch (range
->ncprange_family
) {
556 return !((addr
.s_addr
^ range
->ncprange_ip4addr
.s_addr
) &
557 range
->ncprange_ip4mask
.s_addr
);
564 ncprange_copy(struct ncprange
*range
, const struct ncprange
*from
)
566 switch (from
->ncprange_family
) {
568 range
->ncprange_family
= AF_INET
;
569 range
->ncprange_ip4addr
= from
->ncprange_ip4addr
;
570 range
->ncprange_ip4mask
= from
->ncprange_ip4mask
;
571 range
->ncprange_ip4width
= from
->ncprange_ip4width
;
576 range
->ncprange_family
= AF_INET6
;
577 range
->ncprange_ip6addr
= from
->ncprange_ip6addr
;
578 range
->ncprange_ip6width
= from
->ncprange_ip6width
;
583 range
->ncprange_family
= AF_UNSPEC
;
588 ncprange_set(struct ncprange
*range
, const struct ncpaddr
*addr
, int width
)
590 ncprange_sethost(range
, addr
);
591 ncprange_setwidth(range
, width
);
595 ncprange_sethost(struct ncprange
*range
, const struct ncpaddr
*from
)
597 switch (from
->ncpaddr_family
) {
599 range
->ncprange_family
= AF_INET
;
600 range
->ncprange_ip4addr
= from
->ncpaddr_ip4addr
;
601 if (from
->ncpaddr_ip4addr
.s_addr
== INADDR_ANY
) {
602 range
->ncprange_ip4mask
.s_addr
= INADDR_ANY
;
603 range
->ncprange_ip4width
= 0;
605 range
->ncprange_ip4mask
.s_addr
= INADDR_BROADCAST
;
606 range
->ncprange_ip4width
= 32;
612 range
->ncprange_family
= AF_INET6
;
613 range
->ncprange_ip6addr
= from
->ncpaddr_ip6addr
;
614 range
->ncprange_ip6width
= 128;
619 range
->ncprange_family
= AF_UNSPEC
;
624 ncprange_ishost(const struct ncprange
*range
)
626 switch (range
->ncprange_family
) {
628 return range
->ncprange_ip4width
== 32;
631 return range
->ncprange_ip6width
== 128;
639 ncprange_setwidth(struct ncprange
*range
, int width
)
641 switch (range
->ncprange_family
) {
643 if (width
< 0 || width
> 32)
645 range
->ncprange_ip4width
= width
;
646 range
->ncprange_ip4mask
= bits2mask4(width
);
651 if (width
< 0 || width
> 128)
653 range
->ncprange_ip6width
= width
;
665 ncprange_setip4host(struct ncprange
*range
, struct in_addr from
)
667 range
->ncprange_family
= AF_INET
;
668 range
->ncprange_ip4addr
= from
;
669 if (from
.s_addr
== INADDR_ANY
) {
670 range
->ncprange_ip4mask
.s_addr
= INADDR_ANY
;
671 range
->ncprange_ip4width
= 0;
673 range
->ncprange_ip4mask
.s_addr
= INADDR_BROADCAST
;
674 range
->ncprange_ip4width
= 32;
679 ncprange_setip4(struct ncprange
*range
, struct in_addr from
, struct in_addr msk
)
681 range
->ncprange_family
= AF_INET
;
682 range
->ncprange_ip4addr
= from
;
683 range
->ncprange_ip4mask
= msk
;
684 range
->ncprange_ip4width
= mask42bits(msk
);
689 ncprange_setip4mask(struct ncprange
*range
, struct in_addr mask
)
691 if (range
->ncprange_family
!= AF_INET
)
693 range
->ncprange_ip4mask
= mask
;
694 range
->ncprange_ip4width
= mask42bits(mask
);
699 ncprange_setsa(struct ncprange
*range
, const struct sockaddr
*host
,
700 const struct sockaddr
*mask
)
702 const struct sockaddr_in
*host4
= (const struct sockaddr_in
*)host
;
703 const struct sockaddr_in
*mask4
= (const struct sockaddr_in
*)mask
;
705 const struct sockaddr_in6
*host6
= (const struct sockaddr_in6
*)host
;
706 const struct sockaddr_in6
*mask6
= (const struct sockaddr_in6
*)mask
;
709 switch (host
->sa_family
) {
711 range
->ncprange_family
= AF_INET
;
712 range
->ncprange_ip4addr
= host4
->sin_addr
;
713 if (host4
->sin_addr
.s_addr
== INADDR_ANY
) {
714 range
->ncprange_ip4mask
.s_addr
= INADDR_ANY
;
715 range
->ncprange_ip4width
= 0;
716 } else if (mask4
&& mask4
->sin_family
== AF_INET
) {
717 range
->ncprange_ip4mask
.s_addr
= mask4
->sin_addr
.s_addr
;
718 range
->ncprange_ip4width
= mask42bits(mask4
->sin_addr
);
720 range
->ncprange_ip4mask
.s_addr
= INADDR_BROADCAST
;
721 range
->ncprange_ip4width
= 32;
727 range
->ncprange_family
= AF_INET6
;
728 range
->ncprange_ip6addr
= host6
->sin6_addr
;
729 if (IN6_IS_ADDR_UNSPECIFIED(&host6
->sin6_addr
))
730 range
->ncprange_ip6width
= 0;
732 range
->ncprange_ip6width
= mask6
? mask62bits(&mask6
->sin6_addr
) : 128;
737 range
->ncprange_family
= AF_UNSPEC
;
742 ncprange_getsa(const struct ncprange
*range
, struct sockaddr_storage
*host
,
743 struct sockaddr_storage
*mask
)
745 struct sockaddr_in
*host4
= (struct sockaddr_in
*)host
;
746 struct sockaddr_in
*mask4
= (struct sockaddr_in
*)mask
;
748 struct sockaddr_in6
*host6
= (struct sockaddr_in6
*)host
;
749 struct sockaddr_in6
*mask6
= (struct sockaddr_in6
*)mask
;
752 memset(host
, '\0', sizeof(*host
));
754 memset(mask
, '\0', sizeof(*mask
));
756 switch (range
->ncprange_family
) {
758 host4
->sin_family
= AF_INET
;
759 host4
->sin_len
= sizeof(*host4
);
760 host4
->sin_addr
= range
->ncprange_ip4addr
;
762 mask4
->sin_family
= AF_INET
;
763 mask4
->sin_len
= sizeof(*host4
);
764 mask4
->sin_addr
= range
->ncprange_ip4mask
;
770 host6
->sin6_family
= AF_INET6
;
771 host6
->sin6_len
= sizeof(*host6
);
772 host6
->sin6_addr
= range
->ncprange_ip6addr
;
774 mask6
->sin6_family
= AF_INET6
;
775 mask6
->sin6_len
= sizeof(*host6
);
776 mask6
->sin6_addr
= bits2mask6(range
->ncprange_ip6width
);
782 host
->ss_family
= AF_UNSPEC
;
784 mask
->ss_family
= AF_UNSPEC
;
790 ncprange_getaddr(const struct ncprange
*range
, struct ncpaddr
*addr
)
792 switch (range
->ncprange_family
) {
794 addr
->ncpaddr_family
= AF_INET
;
795 addr
->ncpaddr_ip4addr
= range
->ncprange_ip4addr
;
799 addr
->ncpaddr_family
= AF_INET6
;
800 addr
->ncpaddr_ip6addr
= range
->ncprange_ip6addr
;
809 ncprange_getip4addr(const struct ncprange
*range
, struct in_addr
*addr
)
811 if (range
->ncprange_family
!= AF_INET
)
814 *addr
= range
->ncprange_ip4addr
;
819 ncprange_getip4mask(const struct ncprange
*range
, struct in_addr
*mask
)
821 switch (range
->ncprange_family
) {
823 *mask
= range
->ncprange_ip4mask
;
831 ncprange_getwidth(const struct ncprange
*range
, int *width
)
833 switch (range
->ncprange_family
) {
835 *width
= range
->ncprange_ip4width
;
839 *width
= range
->ncprange_ip6width
;
848 ncprange_ntoa(const struct ncprange
*range
)
854 if (!ncprange_getaddr(range
, &addr
))
855 return "<AF_UNSPEC>";
857 res
= ncpaddr_ntowa(&addr
);
859 if (len
>= NCP_ASCIIBUFFERSIZE
- 1)
862 switch (range
->ncprange_family
) {
864 if (range
->ncprange_ip4width
== -1) {
865 /* A non-contiguous mask */
866 for (; len
>= 3; res
[len
-= 2] = '\0')
867 if (strcmp(res
+ len
- 2, ".0"))
869 snprintf(res
+ len
, strlen(res
) - len
, "&0x%08lx",
870 (unsigned long)ntohl(range
->ncprange_ip4mask
.s_addr
));
871 } else if (range
->ncprange_ip4width
< 32)
872 snprintf(res
+ len
, strlen(res
) - len
, "/%d", range
->ncprange_ip4width
);
878 if (range
->ncprange_ip6width
!= 128)
879 snprintf(res
+ len
, strlen(res
) - len
, "/%d", range
->ncprange_ip6width
);
885 return "<AF_UNSPEC>";
890 ncprange_scopeid(const struct ncprange
*range
)
892 const struct in6_addr
*sin6
;
895 if (range
->ncprange_family
== AF_INET6
) {
896 sin6
= &range
->ncprange_ip6addr
;
897 if (IN6_IS_ADDR_LINKLOCAL(sin6
) || IN6_IS_ADDR_MC_LINKLOCAL(sin6
))
898 if ((scopeid
= ntohs(*(const u_short
*)&sin6
->s6_addr
[2])) == 0)
907 ncprange_aton(struct ncprange
*range
, struct ncp
*ncp
, const char *data
)
914 len
= strcspn(data
, "/");
916 if (ncp
&& strncasecmp(data
, "HISADDR", len
) == 0) {
917 range
->ncprange_family
= AF_INET
;
918 range
->ncprange_ip4addr
= ncp
->ipcp
.peer_ip
;
919 range
->ncprange_ip4mask
.s_addr
= INADDR_BROADCAST
;
920 range
->ncprange_ip4width
= 32;
923 } else if (ncp
&& strncasecmp(data
, "HISADDR6", len
) == 0) {
924 range
->ncprange_family
= AF_INET6
;
925 range
->ncprange_ip6addr
= ncp
->ipv6cp
.hisaddr
.ncpaddr_ip6addr
;
926 range
->ncprange_ip6width
= 128;
929 } else if (ncp
&& strncasecmp(data
, "MYADDR", len
) == 0) {
930 range
->ncprange_family
= AF_INET
;
931 range
->ncprange_ip4addr
= ncp
->ipcp
.my_ip
;
932 range
->ncprange_ip4mask
.s_addr
= INADDR_BROADCAST
;
933 range
->ncprange_ip4width
= 32;
936 } else if (ncp
&& strncasecmp(data
, "MYADDR6", len
) == 0) {
937 range
->ncprange_family
= AF_INET6
;
938 range
->ncprange_ip6addr
= ncp
->ipv6cp
.myaddr
.ncpaddr_ip6addr
;
939 range
->ncprange_ip6width
= 128;
942 } else if (ncp
&& strncasecmp(data
, "DNS0", len
) == 0) {
943 range
->ncprange_family
= AF_INET
;
944 range
->ncprange_ip4addr
= ncp
->ipcp
.ns
.dns
[0];
945 range
->ncprange_ip4mask
.s_addr
= INADDR_BROADCAST
;
946 range
->ncprange_ip4width
= 32;
948 } else if (ncp
&& strncasecmp(data
, "DNS1", len
) == 0) {
949 range
->ncprange_family
= AF_INET
;
950 range
->ncprange_ip4addr
= ncp
->ipcp
.ns
.dns
[1];
951 range
->ncprange_ip4mask
.s_addr
= INADDR_BROADCAST
;
952 range
->ncprange_ip4width
= 32;
956 s
= (char *)alloca(len
+ 1);
957 strncpy(s
, data
, len
);
961 if (data
[len
] != '\0') {
962 bits
= strtol(data
+ len
+ 1, &wp
, 0);
963 if (*wp
|| wp
== data
+ len
+ 1 || bits
< 0 || bits
> 128) {
964 log_Printf(LogWARN
, "ncprange_aton: bad mask width.\n");
969 if ((cp
= strchr(data
, ':')) == NULL
) {
970 range
->ncprange_family
= AF_INET
;
972 range
->ncprange_ip4addr
= GetIpAddr(s
);
974 if (range
->ncprange_ip4addr
.s_addr
== INADDR_NONE
) {
975 log_Printf(LogWARN
, "ncprange_aton: %s: Bad address\n", s
);
979 if (range
->ncprange_ip4addr
.s_addr
== INADDR_ANY
) {
980 range
->ncprange_ip4mask
.s_addr
= INADDR_ANY
;
981 range
->ncprange_ip4width
= 0;
982 } else if (bits
== -1) {
983 range
->ncprange_ip4mask
.s_addr
= INADDR_BROADCAST
;
984 range
->ncprange_ip4width
= 32;
985 } else if (bits
> 32) {
986 log_Printf(LogWARN
, "ncprange_aton: bad mask width.\n");
989 range
->ncprange_ip4mask
= bits2mask4(bits
);
990 range
->ncprange_ip4width
= bits
;
995 } else if (strchr(cp
+ 1, ':') != NULL
) {
996 range
->ncprange_family
= AF_INET6
;
998 if (inet_pton(AF_INET6
, s
, &range
->ncprange_ip6addr
) != 1) {
999 log_Printf(LogWARN
, "ncprange_aton: %s: Bad address\n", s
);
1003 if (IN6_IS_ADDR_UNSPECIFIED(&range
->ncprange_ip6addr
))
1004 range
->ncprange_ip6width
= 0;
1006 range
->ncprange_ip6width
= (bits
== -1) ? 128 : bits
;