usr.sbin/ppp/ncpaddr.c

   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: 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.4 2008/05/19 10:19:49 corecode Exp $
  28  */
  29
  30 #include <sys/types.h>
  31 #include <sys/select.h>
  32 #include <sys/socket.h>
  33 #ifdef __OpenBSD__
  34 #include <net/if_types.h>
  35 #include <net/route.h>
  36 #endif
  37 #include <netinet/in.h>
  38 #include <netinet/in_systm.h>
  39 #include <netinet/ip.h>
  40 #include <arpa/inet.h>
  41 #include <sys/un.h>
  42
  43 #include <netdb.h>
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46 #include <string.h>
  47 #include <termios.h>
  48
  49 #include "log.h"
  50 #include "ncpaddr.h"
  51 #include "timer.h"
  52 #include "fsm.h"
  53 #include "defs.h"
  54 #include "slcompress.h"
  55 #include "iplist.h"
  56 #include "throughput.h"
  57 #include "mbuf.h"
  58 #include "ipcp.h"
  59 #include "descriptor.h"
  60 #include "layer.h"
  61 #include "lqr.h"
  62 #include "hdlc.h"
  63 #include "lcp.h"
  64 #include "ccp.h"
  65 #include "link.h"
  66 #include "mp.h"
  67 #include "ipv6cp.h"
  68 #include "ncp.h"
  69
  70
  71 #define ncprange_ip4addr        u.ip4.ipaddr
  72 #define ncprange_ip4mask        u.ip4.mask
  73 #define ncprange_ip4width       u.ip4.width
  74 #define ncpaddr_ip4addr         u.ip4addr
  75 #ifndef NOINET6
  76 #define ncprange_ip6addr        u.ip6.ipaddr
  77 #define ncprange_ip6width       u.ip6.width
  78 #define ncpaddr_ip6addr         u.ip6addr
  79 #endif
  80
  81 #define NCP_ASCIIBUFFERSIZE     52
  82
  83 static struct in_addr
  84 bits2mask4(int bits)
  85 {
  86   struct in_addr result;
  87   u_int32_t bit = 0x80000000;
  88
  89   result.s_addr = 0;
  90
  91   while (bits) {
  92     result.s_addr |= bit;
  93     bit >>= 1;
  94     bits--;
  95   }
  96
  97   result.s_addr = htonl(result.s_addr);
  98   return result;
  99 }
 100
 101 static int
 102 mask42bits(struct in_addr mask)
 103 {
 104   u_int32_t msk = ntohl(mask.s_addr);
 105   u_int32_t tst;
 106   int ret;
 107
 108   for (ret = 32, tst = 1; tst; ret--, tst <<= 1)
 109     if (msk & tst)
 110       break;
 111
 112   for (tst <<= 1; tst; tst <<= 1)
 113     if (!(msk & tst))
 114       break;
 115
 116   return tst ? -1 : ret;
 117 }
 118
 119 #ifndef NOINET6
 120 static struct in6_addr
 121 bits2mask6(int bits)
 122 {
 123   struct in6_addr result;
 124   u_int32_t bit = 0x80;
 125   u_char *c = result.s6_addr;
 126
 127   memset(&result, '\0', sizeof result);
 128
 129   while (bits) {
 130     if (bit == 0) {
 131       bit = 0x80;
 132       c++;
 133     }
 134     *c |= bit;
 135     bit >>= 1;
 136     bits--;
 137   }
 138
 139   return result;
 140 }
 141
 142 static int
 143 mask62bits(const struct in6_addr *mask)
 144 {
 145   const u_char masks[] = { 0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe };
 146   const u_char *c, *p, *end;
 147   int masklen;
 148
 149   p = (const u_char *)mask;
 150   for (masklen = 0, end = p + 16; p < end && *p == 0xff; p++)
 151     masklen += 8;
 152
 153   if (p < end) {
 154     for (c = masks; c < masks + sizeof masks; c++)
 155       if (*c == *p) {
 156         masklen += c - masks;
 157         break;
 158       }
 159   }
 160
 161   return masklen;
 162 }
 163
 164 #if 0
 165 static void
 166 adjust_linklocal(struct sockaddr_in6 *sin6)
 167 {
 168     /* XXX: ?????!?!?!!!!!  This is horrible ! */
 169     /*
 170      * The kernel does not understand sin6_scope_id for routing at this moment.
 171      * We should rather keep the embedded ID.
 172      * jinmei@kame.net, 20011026
 173      */
 174     if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr) ||
 175         IN6_IS_ADDR_MC_LINKLOCAL(&sin6->sin6_addr)) {
 176       sin6->sin6_scope_id =
 177         ntohs(*(u_short *)&sin6->sin6_addr.s6_addr[2]);
 178       *(u_short *)&sin6->sin6_addr.s6_addr[2] = 0;
 179     }
 180 }
 181 #endif
 182 #endif
 183
 184 void
 185 ncpaddr_init(struct ncpaddr *addr)
 186 {
 187   addr->ncpaddr_family = AF_UNSPEC;
 188 }
 189
 190 int
 191 ncpaddr_isset(const struct ncpaddr *addr)
 192 {
 193   return addr->ncpaddr_family != AF_UNSPEC;
 194 }
 195
 196 int
 197 ncpaddr_isdefault(const struct ncpaddr *addr)
 198 {
 199   switch (addr->ncpaddr_family) {
 200   case AF_INET:
 201     if (addr->ncpaddr_ip4addr.s_addr == INADDR_ANY)
 202       return 1;
 203     break;
 204
 205 #ifndef NOINET6
 206   case AF_INET6:
 207     if (IN6_IS_ADDR_UNSPECIFIED(&addr->ncpaddr_ip6addr))
 208       return 1;
 209     break;
 210 #endif
 211   }
 212
 213   return 0;
 214 }
 215
 216 int
 217 ncpaddr_equal(const struct ncpaddr *addr, const struct ncpaddr *cmp)
 218 {
 219   if (addr->ncpaddr_family != cmp->ncpaddr_family)
 220     return 0;
 221
 222   switch (addr->ncpaddr_family) {
 223   case AF_INET:
 224     return addr->ncpaddr_ip4addr.s_addr == cmp->ncpaddr_ip4addr.s_addr;
 225
 226 #ifndef NOINET6
 227   case AF_INET6:
 228     return !memcmp(&addr->ncpaddr_ip6addr, &cmp->ncpaddr_ip6addr,
 229                    sizeof addr->ncpaddr_ip6addr);
 230 #endif
 231
 232   case AF_UNSPEC:
 233     return 1;
 234   }
 235
 236   return 0;
 237 }
 238
 239 void
 240 ncpaddr_copy(struct ncpaddr *addr, const struct ncpaddr *from)
 241 {
 242   switch (from->ncpaddr_family) {
 243   case AF_INET:
 244     addr->ncpaddr_family = AF_INET;
 245     addr->ncpaddr_ip4addr = from->ncpaddr_ip4addr;
 246     break;
 247 #ifndef NOINET6
 248   case AF_INET6:
 249     addr->ncpaddr_family = AF_INET6;
 250     addr->ncpaddr_ip6addr = from->ncpaddr_ip6addr;
 251     break;
 252 #endif
 253   default:
 254     addr->ncpaddr_family = AF_UNSPEC;
 255   }
 256 }
 257
 258 void
 259 ncpaddr_setip4addr(struct ncpaddr *addr, u_int32_t ip)
 260 {
 261   addr->ncpaddr_family = AF_INET;
 262   addr->ncpaddr_ip4addr.s_addr = ip;
 263 }
 264
 265 int
 266 ncpaddr_getip4addr(const struct ncpaddr *addr, u_int32_t *ip)
 267 {
 268   if (addr->ncpaddr_family != AF_INET)
 269     return 0;
 270   *ip = addr->ncpaddr_ip4addr.s_addr;
 271   return 1;
 272 }
 273
 274 void
 275 ncpaddr_setip4(struct ncpaddr *addr, struct in_addr ip)
 276 {
 277   addr->ncpaddr_family = AF_INET;
 278   addr->ncpaddr_ip4addr = ip;
 279 }
 280
 281 int
 282 ncpaddr_getip4(const struct ncpaddr *addr, struct in_addr *ip)
 283 {
 284   if (addr->ncpaddr_family != AF_INET)
 285     return 0;
 286   *ip = addr->ncpaddr_ip4addr;
 287   return 1;
 288 }
 289
 290 #ifndef NOINET6
 291 void
 292 ncpaddr_setip6(struct ncpaddr *addr, const struct in6_addr *ip6)
 293 {
 294   addr->ncpaddr_family = AF_INET6;
 295   addr->ncpaddr_ip6addr = *ip6;
 296 }
 297
 298 int
 299 ncpaddr_getip6(const struct ncpaddr *addr, struct in6_addr *ip6)
 300 {
 301   if (addr->ncpaddr_family != AF_INET6)
 302     return 0;
 303   *ip6 = addr->ncpaddr_ip6addr;
 304   return 1;
 305 }
 306 #endif
 307
 308 void
 309 ncpaddr_getsa(const struct ncpaddr *addr, struct sockaddr_storage *host)
 310 {
 311   struct sockaddr_in *host4 = (struct sockaddr_in *)host;
 312 #ifndef NOINET6
 313   struct sockaddr_in6 *host6 = (struct sockaddr_in6 *)host;
 314 #endif
 315
 316   memset(host, '\0', sizeof(*host));
 317
 318   switch (addr->ncpaddr_family) {
 319   case AF_INET:
 320     host4->sin_family = AF_INET;
 321     host4->sin_len = sizeof(*host4);
 322     host4->sin_addr = addr->ncpaddr_ip4addr;
 323     break;
 324
 325 #ifndef NOINET6
 326   case AF_INET6:
 327     host6->sin6_family = AF_INET6;
 328     host6->sin6_len = sizeof(*host6);
 329     host6->sin6_addr = addr->ncpaddr_ip6addr;
 330     break;
 331 #endif
 332
 333   default:
 334     host->ss_family = AF_UNSPEC;
 335     break;
 336   }
 337 }
 338
 339 void
 340 ncpaddr_setsa(struct ncpaddr *addr, const struct sockaddr *host)
 341 {
 342   const struct sockaddr_in *host4 = (const struct sockaddr_in *)host;
 343 #ifndef NOINET6
 344   const struct sockaddr_in6 *host6 = (const struct sockaddr_in6 *)host;
 345 #endif
 346
 347   switch (host->sa_family) {
 348   case AF_INET:
 349     addr->ncpaddr_family = AF_INET;
 350     addr->ncpaddr_ip4addr = host4->sin_addr;
 351     break;
 352
 353 #ifndef NOINET6
 354   case AF_INET6:
 355     if (IN6_IS_ADDR_V4MAPPED(&host6->sin6_addr)) {
 356       addr->ncpaddr_family = AF_INET;
 357       addr->ncpaddr_ip4addr.s_addr =
 358         *(const u_int32_t *)(host6->sin6_addr.s6_addr + 12);
 359     } else {
 360       addr->ncpaddr_family = AF_INET6;
 361       addr->ncpaddr_ip6addr = host6->sin6_addr;
 362     }
 363     break;
 364 #endif
 365
 366   default:
 367     addr->ncpaddr_family = AF_UNSPEC;
 368   }
 369 }
 370
 371 static char *
 372 ncpaddr_ntowa(const struct ncpaddr *addr)
 373 {
 374   static char res[NCP_ASCIIBUFFERSIZE];
 375 #ifndef NOINET6
 376   struct sockaddr_in6 sin6;
 377 #endif
 378
 379   switch (addr->ncpaddr_family) {
 380   case AF_INET:
 381     snprintf(res, sizeof res, "%s", inet_ntoa(addr->ncpaddr_ip4addr));
 382     return res;
 383
 384 #ifndef NOINET6
 385   case AF_INET6:
 386     memset(&sin6, '\0', sizeof(sin6));
 387     sin6.sin6_len = sizeof(sin6);
 388     sin6.sin6_family = AF_INET6;
 389     sin6.sin6_addr = addr->ncpaddr_ip6addr;
 390 #if 0
 391     adjust_linklocal(&sin6);
 392 #endif
 393 #ifdef NI_WITHSCOPEID
 394     if (getnameinfo((struct sockaddr *)&sin6, sizeof sin6, res, sizeof(res),
 395                     NULL, 0, NI_WITHSCOPEID | NI_NUMERICHOST) != 0)
 396 #else
 397     if (getnameinfo((struct sockaddr *)&sin6, sizeof sin6, res, sizeof(res),
 398                     NULL, 0, NI_NUMERICHOST) != 0)
 399 #endif
 400       break;
 401
 402     return res;
 403 #endif
 404   }
 405
 406   snprintf(res, sizeof res, "<AF_UNSPEC>");
 407   return res;
 408 }
 409
 410 const char *
 411 ncpaddr_ntoa(const struct ncpaddr *addr)
 412 {
 413   return ncpaddr_ntowa(addr);
 414 }
 415
 416
 417 int
 418 ncpaddr_aton(struct ncpaddr *addr, struct ncp *ncp, const char *data)
 419 {
 420   struct ncprange range;
 421
 422   if (!ncprange_aton(&range, ncp, data))
 423     return 0;
 424
 425   if (range.ncprange_family == AF_INET && range.ncprange_ip4width != 32) {
 426     log_Printf(LogWARN, "ncpaddr_aton: %s: Only 32 bits allowed\n", data);
 427     return 0;
 428   }
 429
 430 #ifndef NOINET6
 431   if (range.ncprange_family == AF_INET6 && range.ncprange_ip6width != 128) {
 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, strlen(res) - len, "&0x%08lx",
 873                (unsigned long)ntohl(range->ncprange_ip4mask.s_addr));
 874     } else if (range->ncprange_ip4width < 32)
 875       snprintf(res + len, strlen(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, strlen(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 }