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
29 #include <sys/types.h>
30 #include <sys/socket.h>
32 #include <net/if_types.h>
33 #include <net/route.h>
35 #include <netinet/in.h>
36 #include <netinet/in_systm.h>
37 #include <netinet/ip.h>
38 #include <arpa/inet.h>
52 #include "slcompress.h"
54 #include "throughput.h"
57 #include "descriptor.h"
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
74 #define ncprange_ip6addr u.ip6.ipaddr
75 #define ncprange_ip6width u.ip6.width
76 #define ncpaddr_ip6addr u.ip6addr
82 struct in_addr result;
83 u_int32_t bit = 0x80000000;
93 result.s_addr = htonl(result.s_addr);
98 mask42bits(struct in_addr mask)
100 u_int32_t msk = ntohl(mask.s_addr);
104 for (ret = 32, tst = 1; tst; ret--, tst <<= 1)
108 for (tst <<= 1; tst; tst <<= 1)
112 return tst ? -1 : ret;
116 static struct in6_addr
119 struct in6_addr result;
120 u_int32_t bit = 0x80;
121 u_char *c = result.s6_addr;
123 memset(&result, '\0', sizeof result);
139 mask62bits(const struct in6_addr *mask)
141 const u_char masks[] = { 0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe };
142 const u_char *c, *p, *end;
145 p = (const u_char *)mask;
146 for (masklen = 0, end = p + 16; p < end && *p == 0xff; p++)
150 for (c = masks, m = 0; c < masks + sizeof masks; c++, m++)
162 adjust_linklocal(struct sockaddr_in6 *sin6)
164 /* XXX: ?????!?!?!!!!! This is horrible ! */
166 * The kernel does not understand sin6_scope_id for routing at this moment.
167 * We should rather keep the embedded ID.
168 * jinmei@kame.net, 20011026
170 if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr) ||
171 IN6_IS_ADDR_MC_LINKLOCAL(&sin6->sin6_addr)) {
172 sin6->sin6_scope_id =
173 ntohs(*(u_short *)&sin6->sin6_addr.s6_addr[2]);
174 *(u_short *)&sin6->sin6_addr.s6_addr[2] = 0;
181 ncpaddr_init(struct ncpaddr *addr)
183 addr->ncpaddr_family = AF_UNSPEC;
187 ncpaddr_isset(const struct ncpaddr *addr)
189 return addr->ncpaddr_family != AF_UNSPEC;
193 ncpaddr_isdefault(const struct ncpaddr *addr)
195 switch (addr->ncpaddr_family) {
197 if (addr->ncpaddr_ip4addr.s_addr == INADDR_ANY)
203 if (IN6_IS_ADDR_UNSPECIFIED(&addr->ncpaddr_ip6addr))
213 ncpaddr_equal(const struct ncpaddr *addr, const struct ncpaddr *cmp)
215 if (addr->ncpaddr_family != cmp->ncpaddr_family)
218 switch (addr->ncpaddr_family) {
220 return addr->ncpaddr_ip4addr.s_addr == cmp->ncpaddr_ip4addr.s_addr;
224 return !memcmp(&addr->ncpaddr_ip6addr, &cmp->ncpaddr_ip6addr,
225 sizeof addr->ncpaddr_ip6addr);
236 ncpaddr_copy(struct ncpaddr *addr, const struct ncpaddr *from)
238 switch (from->ncpaddr_family) {
240 addr->ncpaddr_family = AF_INET;
241 addr->ncpaddr_ip4addr = from->ncpaddr_ip4addr;
245 addr->ncpaddr_family = AF_INET6;
246 addr->ncpaddr_ip6addr = from->ncpaddr_ip6addr;
250 addr->ncpaddr_family = AF_UNSPEC;
255 ncpaddr_setip4addr(struct ncpaddr *addr, u_int32_t ip)
257 addr->ncpaddr_family = AF_INET;
258 addr->ncpaddr_ip4addr.s_addr = ip;
262 ncpaddr_getip4addr(const struct ncpaddr *addr, u_int32_t *ip)
264 if (addr->ncpaddr_family != AF_INET)
266 *ip = addr->ncpaddr_ip4addr.s_addr;
271 ncpaddr_setip4(struct ncpaddr *addr, struct in_addr ip)
273 addr->ncpaddr_family = AF_INET;
274 addr->ncpaddr_ip4addr = ip;
278 ncpaddr_getip4(const struct ncpaddr *addr, struct in_addr *ip)
280 if (addr->ncpaddr_family != AF_INET)
282 *ip = addr->ncpaddr_ip4addr;
288 ncpaddr_setip6(struct ncpaddr *addr, const struct in6_addr *ip6)
290 addr->ncpaddr_family = AF_INET6;
291 addr->ncpaddr_ip6addr = *ip6;
295 ncpaddr_getip6(const struct ncpaddr *addr, struct in6_addr *ip6)
297 if (addr->ncpaddr_family != AF_INET6)
299 *ip6 = addr->ncpaddr_ip6addr;
305 ncpaddr_getsa(const struct ncpaddr *addr, struct sockaddr_storage *host)
307 struct sockaddr_in *host4 = (struct sockaddr_in *)host;
309 struct sockaddr_in6 *host6 = (struct sockaddr_in6 *)host;
312 memset(host, '\0', sizeof(*host));
314 switch (addr->ncpaddr_family) {
316 host4->sin_family = AF_INET;
317 host4->sin_len = sizeof(*host4);
318 host4->sin_addr = addr->ncpaddr_ip4addr;
323 host6->sin6_family = AF_INET6;
324 host6->sin6_len = sizeof(*host6);
325 host6->sin6_addr = addr->ncpaddr_ip6addr;
330 host->ss_family = AF_UNSPEC;
336 ncpaddr_setsa(struct ncpaddr *addr, const struct sockaddr *host)
338 const struct sockaddr_in *host4 = (const struct sockaddr_in *)host;
340 const struct sockaddr_in6 *host6 = (const struct sockaddr_in6 *)host;
343 switch (host->sa_family) {
345 addr->ncpaddr_family = AF_INET;
346 addr->ncpaddr_ip4addr = host4->sin_addr;
351 if (IN6_IS_ADDR_V4MAPPED(&host6->sin6_addr)) {
352 addr->ncpaddr_family = AF_INET;
353 addr->ncpaddr_ip4addr.s_addr =
354 *(const u_int32_t *)(host6->sin6_addr.s6_addr + 12);
356 addr->ncpaddr_family = AF_INET6;
357 addr->ncpaddr_ip6addr = host6->sin6_addr;
363 addr->ncpaddr_family = AF_UNSPEC;
368 ncpaddr_ntowa(const struct ncpaddr *addr)
370 static char res[NCP_ASCIIBUFFERSIZE];
372 struct sockaddr_in6 sin6;
375 switch (addr->ncpaddr_family) {
377 snprintf(res, sizeof res, "%s", inet_ntoa(addr->ncpaddr_ip4addr));
382 memset(&sin6, '\0', sizeof(sin6));
383 sin6.sin6_len = sizeof(sin6);
384 sin6.sin6_family = AF_INET6;
385 sin6.sin6_addr = addr->ncpaddr_ip6addr;
387 adjust_linklocal(&sin6);
389 if (getnameinfo((struct sockaddr *)&sin6, sizeof sin6, res, sizeof(res),
390 NULL, 0, NI_NUMERICHOST) != 0)
397 snprintf(res, sizeof res, "<AF_UNSPEC>");
402 ncpaddr_ntoa(const struct ncpaddr *addr)
404 return ncpaddr_ntowa(addr);
409 ncpaddr_aton(struct ncpaddr *addr, struct ncp *ncp, const char *data)
411 struct ncprange range;
413 if (!ncprange_aton(&range, ncp, data))
416 if (range.ncprange_family == AF_INET && range.ncprange_ip4width != 32 &&
417 range.ncprange_ip4addr.s_addr != INADDR_ANY) {
418 log_Printf(LogWARN, "ncpaddr_aton: %s: Only 32 bits allowed\n", data);
423 if (range.ncprange_family == AF_INET6 && range.ncprange_ip6width != 128 &&
424 !IN6_IS_ADDR_UNSPECIFIED(&range.ncprange_ip6addr)) {
425 log_Printf(LogWARN, "ncpaddr_aton: %s: Only 128 bits allowed\n", data);
430 switch (range.ncprange_family) {
432 addr->ncpaddr_family = range.ncprange_family;
433 addr->ncpaddr_ip4addr = range.ncprange_ip4addr;
438 addr->ncpaddr_family = range.ncprange_family;
439 addr->ncpaddr_ip6addr = range.ncprange_ip6addr;
448 ncprange_init(struct ncprange *range)
450 range->ncprange_family = AF_UNSPEC;
454 ncprange_isset(const struct ncprange *range)
456 return range->ncprange_family != AF_UNSPEC;
460 ncprange_equal(const struct ncprange *range, const struct ncprange *cmp)
462 if (range->ncprange_family != cmp->ncprange_family)
465 switch (range->ncprange_family) {
467 if (range->ncprange_ip4addr.s_addr != cmp->ncprange_ip4addr.s_addr)
469 return range->ncprange_ip4mask.s_addr == cmp->ncprange_ip4mask.s_addr;
473 if (range->ncprange_ip6width != cmp->ncprange_ip6width)
475 return !memcmp(&range->ncprange_ip6addr, &cmp->ncprange_ip6addr,
476 sizeof range->ncprange_ip6addr);
487 ncprange_isdefault(const struct ncprange *range)
489 switch (range->ncprange_family) {
491 if (range->ncprange_ip4addr.s_addr == INADDR_ANY)
497 if (range->ncprange_ip6width == 0 &&
498 IN6_IS_ADDR_UNSPECIFIED(&range->ncprange_ip6addr))
508 ncprange_setdefault(struct ncprange *range, int af)
510 memset(range, '\0', sizeof *range);
511 range->ncprange_family = af;
515 ncprange_contains(const struct ncprange *range, const struct ncpaddr *addr)
518 const u_char masks[] = { 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff };
519 const u_char *addrp, *rangep;
523 if (range->ncprange_family != addr->ncpaddr_family)
526 switch (range->ncprange_family) {
528 return !((addr->ncpaddr_ip4addr.s_addr ^ range->ncprange_ip4addr.s_addr) &
529 range->ncprange_ip4mask.s_addr);
533 rangep = (const u_char *)range->ncprange_ip6addr.s6_addr;
534 addrp = (const u_char *)addr->ncpaddr_ip6addr.s6_addr;
536 for (bits = range->ncprange_ip6width; bits > 0; bits -= 8)
537 if ((*addrp++ ^ *rangep++) & masks[bits > 7 ? 7 : bits - 1])
548 ncprange_containsip4(const struct ncprange *range, struct in_addr addr)
550 switch (range->ncprange_family) {
552 return !((addr.s_addr ^ range->ncprange_ip4addr.s_addr) &
553 range->ncprange_ip4mask.s_addr);
560 ncprange_copy(struct ncprange *range, const struct ncprange *from)
562 switch (from->ncprange_family) {
564 range->ncprange_family = AF_INET;
565 range->ncprange_ip4addr = from->ncprange_ip4addr;
566 range->ncprange_ip4mask = from->ncprange_ip4mask;
567 range->ncprange_ip4width = from->ncprange_ip4width;
572 range->ncprange_family = AF_INET6;
573 range->ncprange_ip6addr = from->ncprange_ip6addr;
574 range->ncprange_ip6width = from->ncprange_ip6width;
579 range->ncprange_family = AF_UNSPEC;
584 ncprange_set(struct ncprange *range, const struct ncpaddr *addr, int width)
586 ncprange_sethost(range, addr);
587 ncprange_setwidth(range, width);
591 ncprange_sethost(struct ncprange *range, const struct ncpaddr *from)
593 switch (from->ncpaddr_family) {
595 range->ncprange_family = AF_INET;
596 range->ncprange_ip4addr = from->ncpaddr_ip4addr;
597 if (from->ncpaddr_ip4addr.s_addr == INADDR_ANY) {
598 range->ncprange_ip4mask.s_addr = INADDR_ANY;
599 range->ncprange_ip4width = 0;
601 range->ncprange_ip4mask.s_addr = INADDR_BROADCAST;
602 range->ncprange_ip4width = 32;
608 range->ncprange_family = AF_INET6;
609 range->ncprange_ip6addr = from->ncpaddr_ip6addr;
610 range->ncprange_ip6width = 128;
615 range->ncprange_family = AF_UNSPEC;
620 ncprange_ishost(const struct ncprange *range)
622 switch (range->ncprange_family) {
624 return range->ncprange_ip4width == 32;
627 return range->ncprange_ip6width == 128;
635 ncprange_setwidth(struct ncprange *range, int width)
637 switch (range->ncprange_family) {
639 if (width < 0 || width > 32)
641 range->ncprange_ip4width = width;
642 range->ncprange_ip4mask = bits2mask4(width);
647 if (width < 0 || width > 128)
649 range->ncprange_ip6width = width;
661 ncprange_setip4host(struct ncprange *range, struct in_addr from)
663 range->ncprange_family = AF_INET;
664 range->ncprange_ip4addr = from;
665 if (from.s_addr == INADDR_ANY) {
666 range->ncprange_ip4mask.s_addr = INADDR_ANY;
667 range->ncprange_ip4width = 0;
669 range->ncprange_ip4mask.s_addr = INADDR_BROADCAST;
670 range->ncprange_ip4width = 32;
675 ncprange_setip4(struct ncprange *range, struct in_addr from, struct in_addr msk)
677 range->ncprange_family = AF_INET;
678 range->ncprange_ip4addr = from;
679 range->ncprange_ip4mask = msk;
680 range->ncprange_ip4width = mask42bits(msk);
685 ncprange_setip4mask(struct ncprange *range, struct in_addr mask)
687 if (range->ncprange_family != AF_INET)
689 range->ncprange_ip4mask = mask;
690 range->ncprange_ip4width = mask42bits(mask);
695 ncprange_setsa(struct ncprange *range, const struct sockaddr *host,
696 const struct sockaddr *mask)
698 const struct sockaddr_in *host4 = (const struct sockaddr_in *)host;
699 const struct sockaddr_in *mask4 = (const struct sockaddr_in *)mask;
701 const struct sockaddr_in6 *host6 = (const struct sockaddr_in6 *)host;
702 const struct sockaddr_in6 *mask6 = (const struct sockaddr_in6 *)mask;
705 switch (host->sa_family) {
707 range->ncprange_family = AF_INET;
708 range->ncprange_ip4addr = host4->sin_addr;
709 if (host4->sin_addr.s_addr == INADDR_ANY) {
710 range->ncprange_ip4mask.s_addr = INADDR_ANY;
711 range->ncprange_ip4width = 0;
712 } else if (mask4 && mask4->sin_family == AF_INET) {
713 range->ncprange_ip4mask.s_addr = mask4->sin_addr.s_addr;
714 range->ncprange_ip4width = mask42bits(mask4->sin_addr);
716 range->ncprange_ip4mask.s_addr = INADDR_BROADCAST;
717 range->ncprange_ip4width = 32;
723 range->ncprange_family = AF_INET6;
724 range->ncprange_ip6addr = host6->sin6_addr;
725 if (IN6_IS_ADDR_UNSPECIFIED(&host6->sin6_addr))
726 range->ncprange_ip6width = 0;
728 range->ncprange_ip6width = mask6 ? mask62bits(&mask6->sin6_addr) : 128;
733 range->ncprange_family = AF_UNSPEC;
738 ncprange_getsa(const struct ncprange *range, struct sockaddr_storage *host,
739 struct sockaddr_storage *mask)
741 struct sockaddr_in *host4 = (struct sockaddr_in *)host;
742 struct sockaddr_in *mask4 = (struct sockaddr_in *)mask;
744 struct sockaddr_in6 *host6 = (struct sockaddr_in6 *)host;
745 struct sockaddr_in6 *mask6 = (struct sockaddr_in6 *)mask;
748 memset(host, '\0', sizeof(*host));
750 memset(mask, '\0', sizeof(*mask));
752 switch (range->ncprange_family) {
754 host4->sin_family = AF_INET;
755 host4->sin_len = sizeof(*host4);
756 host4->sin_addr = range->ncprange_ip4addr;
758 mask4->sin_family = AF_INET;
759 mask4->sin_len = sizeof(*host4);
760 mask4->sin_addr = range->ncprange_ip4mask;
766 host6->sin6_family = AF_INET6;
767 host6->sin6_len = sizeof(*host6);
768 host6->sin6_addr = range->ncprange_ip6addr;
770 mask6->sin6_family = AF_INET6;
771 mask6->sin6_len = sizeof(*host6);
772 mask6->sin6_addr = bits2mask6(range->ncprange_ip6width);
778 host->ss_family = AF_UNSPEC;
780 mask->ss_family = AF_UNSPEC;
786 ncprange_getaddr(const struct ncprange *range, struct ncpaddr *addr)
788 switch (range->ncprange_family) {
790 addr->ncpaddr_family = AF_INET;
791 addr->ncpaddr_ip4addr = range->ncprange_ip4addr;
795 addr->ncpaddr_family = AF_INET6;
796 addr->ncpaddr_ip6addr = range->ncprange_ip6addr;
805 ncprange_getip4addr(const struct ncprange *range, struct in_addr *addr)
807 if (range->ncprange_family != AF_INET)
810 *addr = range->ncprange_ip4addr;
815 ncprange_getip4mask(const struct ncprange *range, struct in_addr *mask)
817 switch (range->ncprange_family) {
819 *mask = range->ncprange_ip4mask;
827 ncprange_getwidth(const struct ncprange *range, int *width)
829 switch (range->ncprange_family) {
831 *width = range->ncprange_ip4width;
835 *width = range->ncprange_ip6width;
844 ncprange_ntoa(const struct ncprange *range)
850 if (!ncprange_getaddr(range, &addr))
851 return "<AF_UNSPEC>";
853 res = ncpaddr_ntowa(&addr);
855 if (len >= NCP_ASCIIBUFFERSIZE - 1)
858 switch (range->ncprange_family) {
860 if (range->ncprange_ip4width == -1) {
861 /* A non-contiguous mask */
862 for (; len >= 3; res[len -= 2] = '\0')
863 if (strcmp(res + len - 2, ".0"))
865 snprintf(res + len, sizeof res - len, "&0x%08lx",
866 (unsigned long)ntohl(range->ncprange_ip4mask.s_addr));
867 } else if (range->ncprange_ip4width < 32)
868 snprintf(res + len, sizeof res - len, "/%d", range->ncprange_ip4width);
874 if (range->ncprange_ip6width != 128)
875 snprintf(res + len, sizeof res - len, "/%d", range->ncprange_ip6width);
881 return "<AF_UNSPEC>";
886 ncprange_scopeid(const struct ncprange *range)
888 const struct in6_addr *sin6;
891 if (range->ncprange_family == AF_INET6) {
892 sin6 = &range->ncprange_ip6addr;
893 if (IN6_IS_ADDR_LINKLOCAL(sin6) || IN6_IS_ADDR_MC_LINKLOCAL(sin6))
894 if ((scopeid = ntohs(*(const u_short *)&sin6->s6_addr[2])) == 0)
903 ncprange_aton(struct ncprange *range, struct ncp *ncp, const char *data)
910 len = strcspn(data, "/");
912 if (ncp && strncasecmp(data, "HISADDR", len) == 0) {
913 range->ncprange_family = AF_INET;
914 range->ncprange_ip4addr = ncp->ipcp.peer_ip;
915 range->ncprange_ip4mask.s_addr = INADDR_BROADCAST;
916 range->ncprange_ip4width = 32;
919 } else if (ncp && strncasecmp(data, "HISADDR6", len) == 0) {
920 range->ncprange_family = AF_INET6;
921 range->ncprange_ip6addr = ncp->ipv6cp.hisaddr.ncpaddr_ip6addr;
922 range->ncprange_ip6width = 128;
925 } else if (ncp && strncasecmp(data, "MYADDR", len) == 0) {
926 range->ncprange_family = AF_INET;
927 range->ncprange_ip4addr = ncp->ipcp.my_ip;
928 range->ncprange_ip4mask.s_addr = INADDR_BROADCAST;
929 range->ncprange_ip4width = 32;
932 } else if (ncp && strncasecmp(data, "MYADDR6", len) == 0) {
933 range->ncprange_family = AF_INET6;
934 range->ncprange_ip6addr = ncp->ipv6cp.myaddr.ncpaddr_ip6addr;
935 range->ncprange_ip6width = 128;
938 } else if (ncp && strncasecmp(data, "DNS0", len) == 0) {
939 range->ncprange_family = AF_INET;
940 range->ncprange_ip4addr = ncp->ipcp.ns.dns[0];
941 range->ncprange_ip4mask.s_addr = INADDR_BROADCAST;
942 range->ncprange_ip4width = 32;
944 } else if (ncp && strncasecmp(data, "DNS1", len) == 0) {
945 range->ncprange_family = AF_INET;
946 range->ncprange_ip4addr = ncp->ipcp.ns.dns[1];
947 range->ncprange_ip4mask.s_addr = INADDR_BROADCAST;
948 range->ncprange_ip4width = 32;
952 s = (char *)alloca(len + 1);
953 strncpy(s, data, len);
957 if (data[len] != '\0') {
958 bits = strtol(data + len + 1, &wp, 0);
959 if (*wp || wp == data + len + 1 || bits < 0 || bits > 128) {
960 log_Printf(LogWARN, "ncprange_aton: bad mask width.\n");
965 if ((cp = strchr(data, ':')) == NULL) {
966 range->ncprange_family = AF_INET;
968 range->ncprange_ip4addr = GetIpAddr(s);
970 if (range->ncprange_ip4addr.s_addr == INADDR_NONE) {
971 log_Printf(LogWARN, "ncprange_aton: %s: Bad address\n", s);
975 if (range->ncprange_ip4addr.s_addr == INADDR_ANY) {
976 range->ncprange_ip4mask.s_addr = INADDR_ANY;
977 range->ncprange_ip4width = 0;
978 } else if (bits == -1) {
979 range->ncprange_ip4mask.s_addr = INADDR_BROADCAST;
980 range->ncprange_ip4width = 32;
981 } else if (bits > 32) {
982 log_Printf(LogWARN, "ncprange_aton: bad mask width.\n");
985 range->ncprange_ip4mask = bits2mask4(bits);
986 range->ncprange_ip4width = bits;
991 } else if (strchr(cp + 1, ':') != NULL) {
992 range->ncprange_family = AF_INET6;
994 if (inet_pton(AF_INET6, s, &range->ncprange_ip6addr) != 1) {
995 log_Printf(LogWARN, "ncprange_aton: %s: Bad address\n", s);
999 if (IN6_IS_ADDR_UNSPECIFIED(&range->ncprange_ip6addr))
1000 range->ncprange_ip6width = 0;
1002 range->ncprange_ip6width = (bits == -1) ? 128 : bits;