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.3 2006/01/17 23:49:16 dillon Exp $
  28  */
  29
  30 #include <sys/types.h>
  31 #include <sys/socket.h>
  32 #ifdef __OpenBSD__
  33 #include <net/if_types.h>
  34 #include <net/route.h>
  35 #endif
  36 #include <netinet/in.h>
  37 #include <netinet/in_systm.h>
  38 #include <netinet/ip.h>
  39 #include <arpa/inet.h>
  40 #include <sys/un.h>
  41
  42 #include <netdb.h>
  43 #include <stdio.h>
  44 #include <stdlib.h>
  45 #include <string.h>
  46 #include <termios.h>
  47
  48 #include "log.h"
  49 #include "ncpaddr.h"
  50 #include "timer.h"
  51 #include "fsm.h"
  52 #include "defs.h"
  53 #include "slcompress.h"
  54 #include "iplist.h"
  55 #include "throughput.h"
  56 #include "mbuf.h"
  57 #include "ipcp.h"
  58 #include "descriptor.h"
  59 #include "layer.h"
  60 #include "lqr.h"
  61 #include "hdlc.h"
  62 #include "lcp.h"
  63 #include "ccp.h"
  64 #include "link.h"
  65 #include "mp.h"
  66 #include "ipv6cp.h"
  67 #include "ncp.h"
  68
  69
  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
  74 #ifndef NOINET6
  75 #define ncprange_ip6addr        u.ip6.ipaddr
  76 #define ncprange_ip6width       u.ip6.width
  77 #define ncpaddr_ip6addr         u.ip6addr
  78 #endif
  79
  80 #define NCP_ASCIIBUFFERSIZE     52
  81
  82 static struct in_addr
  83 bits2mask4(int bits)
  84 {
  85   struct in_addr result;
  86   u_int32_t bit = 0x80000000;
  87
  88   result.s_addr = 0;
  89
  90   while (bits) {
  91     result.s_addr |= bit;
  92     bit >>= 1;
  93     bits--;
  94   }
  95
  96   result.s_addr = htonl(result.s_addr);
  97   return result;
  98 }
  99
 100 static int
 101 mask42bits(struct in_addr mask)
 102 {
 103   u_int32_t msk = ntohl(mask.s_addr);
 104   u_int32_t tst;
 105   int ret;
 106
 107   for (ret = 32, tst = 1; tst; ret--, tst <<= 1)
 108     if (msk & tst)
 109       break;
 110
 111   for (tst <<= 1; tst; tst <<= 1)
 112     if (!(msk & tst))
 113       break;
 114
 115   return tst ? -1 : ret;
 116 }
 117
 118 #ifndef NOINET6
 119 static struct in6_addr
 120 bits2mask6(int bits)
 121 {
 122   struct in6_addr result;
 123   u_int32_t bit = 0x80;
 124   u_char *c = result.s6_addr;
 125
 126   memset(&result, '\0', sizeof result);
 127
 128   while (bits) {
 129     if (bit == 0) {
 130       bit = 0x80;
 131       c++;
 132     }
 133     *c |= bit;
 134     bit >>= 1;
 135     bits--;
 136   }
 137
 138   return result;
 139 }
 140
 141 static int
 142 mask62bits(const struct in6_addr *mask)
 143 {
 144   const u_char masks[] = { 0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe };
 145   const u_char *c, *p, *end;
 146   int masklen;
 147
 148   p = (const u_char *)mask;
 149   for (masklen = 0, end = p + 16; p < end && *p == 0xff; p++)
 150     masklen += 8;
 151
 152   if (p < end) {
 153     for (c = masks; c < masks + sizeof masks; c++)
 154       if (*c == *p) {
 155         masklen += c - masks;
 156         break;
 157       }
 158   }
 159
 160   return masklen;
 161 }
 162
 163 static void
 164 adjust_linklocal(struct sockaddr_in6 *sin6)
 165 {
 166     /* XXX: ?????!?!?!!!!!  This is horrible ! */
 167 #if 0
 168     /*
 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
 172      */
 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;
 178     }
 179 #endif
 180 }
 181 #endif
 182
 183 void
 184 ncpaddr_init(struct ncpaddr *addr)
 185 {
 186   addr->ncpaddr_family = AF_UNSPEC;
 187 }
 188
 189 int
 190 ncpaddr_isset(const struct ncpaddr *addr)
 191 {
 192   return addr->ncpaddr_family != AF_UNSPEC;
 193 }
 194
 195 int
 196 ncpaddr_isdefault(const struct ncpaddr *addr)
 197 {
 198   switch (addr->ncpaddr_family) {
 199   case AF_INET:
 200     if (addr->ncpaddr_ip4addr.s_addr == INADDR_ANY)
 201       return 1;
 202     break;
 203
 204 #ifndef NOINET6
 205   case AF_INET6:
 206     if (IN6_IS_ADDR_UNSPECIFIED(&addr->ncpaddr_ip6addr))
 207       return 1;
 208     break;
 209 #endif
 210   }
 211
 212   return 0;
 213 }
 214
 215 int
 216 ncpaddr_equal(const struct ncpaddr *addr, const struct ncpaddr *cmp)
 217 {
 218   if (addr->ncpaddr_family != cmp->ncpaddr_family)
 219     return 0;
 220
 221   switch (addr->ncpaddr_family) {
 222   case AF_INET:
 223     return addr->ncpaddr_ip4addr.s_addr == cmp->ncpaddr_ip4addr.s_addr;
 224
 225 #ifndef NOINET6
 226   case AF_INET6:
 227     return !memcmp(&addr->ncpaddr_ip6addr, &cmp->ncpaddr_ip6addr,
 228                    sizeof addr->ncpaddr_ip6addr);
 229 #endif
 230
 231   case AF_UNSPEC:
 232     return 1;
 233   }
 234
 235   return 0;
 236 }
 237
 238 void
 239 ncpaddr_copy(struct ncpaddr *addr, const struct ncpaddr *from)
 240 {
 241   switch (from->ncpaddr_family) {
 242   case AF_INET:
 243     addr->ncpaddr_family = AF_INET;
 244     addr->ncpaddr_ip4addr = from->ncpaddr_ip4addr;
 245     break;
 246 #ifndef NOINET6
 247   case AF_INET6:
 248     addr->ncpaddr_family = AF_INET6;
 249     addr->ncpaddr_ip6addr = from->ncpaddr_ip6addr;
 250     break;
 251 #endif
 252   default:
 253     addr->ncpaddr_family = AF_UNSPEC;
 254   }
 255 }
 256
 257 void
 258 ncpaddr_setip4addr(struct ncpaddr *addr, u_int32_t ip)
 259 {
 260   addr->ncpaddr_family = AF_INET;
 261   addr->ncpaddr_ip4addr.s_addr = ip;
 262 }
 263
 264 int
 265 ncpaddr_getip4addr(const struct ncpaddr *addr, u_int32_t *ip)
 266 {
 267   if (addr->ncpaddr_family != AF_INET)
 268     return 0;
 269   *ip = addr->ncpaddr_ip4addr.s_addr;
 270   return 1;
 271 }
 272
 273 void
 274 ncpaddr_setip4(struct ncpaddr *addr, struct in_addr ip)
 275 {
 276   addr->ncpaddr_family = AF_INET;
 277   addr->ncpaddr_ip4addr = ip;
 278 }
 279
 280 int
 281 ncpaddr_getip4(const struct ncpaddr *addr, struct in_addr *ip)
 282 {
 283   if (addr->ncpaddr_family != AF_INET)
 284     return 0;
 285   *ip = addr->ncpaddr_ip4addr;
 286   return 1;
 287 }
 288
 289 #ifndef NOINET6
 290 void
 291 ncpaddr_setip6(struct ncpaddr *addr, const struct in6_addr *ip6)
 292 {
 293   addr->ncpaddr_family = AF_INET6;
 294   addr->ncpaddr_ip6addr = *ip6;
 295 }
 296
 297 int
 298 ncpaddr_getip6(const struct ncpaddr *addr, struct in6_addr *ip6)
 299 {
 300   if (addr->ncpaddr_family != AF_INET6)
 301     return 0;
 302   *ip6 = addr->ncpaddr_ip6addr;
 303   return 1;
 304 }
 305 #endif
 306
 307 void
 308 ncpaddr_getsa(const struct ncpaddr *addr, struct sockaddr_storage *host)
 309 {
 310   struct sockaddr_in *host4 = (struct sockaddr_in *)host;
 311 #ifndef NOINET6
 312   struct sockaddr_in6 *host6 = (struct sockaddr_in6 *)host;
 313 #endif
 314
 315   memset(host, '\0', sizeof(*host));
 316
 317   switch (addr->ncpaddr_family) {
 318   case AF_INET:
 319     host4->sin_family = AF_INET;
 320     host4->sin_len = sizeof(*host4);
 321     host4->sin_addr = addr->ncpaddr_ip4addr;
 322     break;
 323
 324 #ifndef NOINET6
 325   case AF_INET6:
 326     host6->sin6_family = AF_INET6;
 327     host6->sin6_len = sizeof(*host6);
 328     host6->sin6_addr = addr->ncpaddr_ip6addr;
 329     break;
 330 #endif
 331
 332   default:
 333     host->ss_family = AF_UNSPEC;
 334     break;
 335   }
 336 }
 337
 338 void
 339 ncpaddr_setsa(struct ncpaddr *addr, const struct sockaddr *host)
 340 {
 341   const struct sockaddr_in *host4 = (const struct sockaddr_in *)host;
 342 #ifndef NOINET6
 343   const struct sockaddr_in6 *host6 = (const struct sockaddr_in6 *)host;
 344 #endif
 345
 346   switch (host->sa_family) {
 347   case AF_INET:
 348     addr->ncpaddr_family = AF_INET;
 349     addr->ncpaddr_ip4addr = host4->sin_addr;
 350     break;
 351
 352 #ifndef NOINET6
 353   case AF_INET6:
 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);
 358     } else {
 359       addr->ncpaddr_family = AF_INET6;
 360       addr->ncpaddr_ip6addr = host6->sin6_addr;
 361     }
 362     break;
 363 #endif
 364
 365   default:
 366     addr->ncpaddr_family = AF_UNSPEC;
 367   }
 368 }
 369
 370 static char *
 371 ncpaddr_ntowa(const struct ncpaddr *addr)
 372 {
 373   static char res[NCP_ASCIIBUFFERSIZE];
 374 #ifndef NOINET6
 375   struct sockaddr_in6 sin6;
 376 #endif
 377
 378   switch (addr->ncpaddr_family) {
 379   case AF_INET:
 380     snprintf(res, sizeof res, "%s", inet_ntoa(addr->ncpaddr_ip4addr));
 381     return res;
 382
 383 #ifndef NOINET6
 384   case AF_INET6:
 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)
 393 #else
 394     if (getnameinfo((struct sockaddr *)&sin6, sizeof sin6, res, sizeof(res),
 395                     NULL, 0, NI_NUMERICHOST) != 0)
 396 #endif
 397       break;
 398
 399     return res;
 400 #endif
 401   }
 402
 403   snprintf(res, sizeof res, "<AF_UNSPEC>");
 404   return res;
 405 }
 406
 407 const char *
 408 ncpaddr_ntoa(const struct ncpaddr *addr)
 409 {
 410   return ncpaddr_ntowa(addr);
 411 }
 412
 413
 414 int
 415 ncpaddr_aton(struct ncpaddr *addr, struct ncp *ncp, const char *data)
 416 {
 417   struct ncprange range;
 418
 419   if (!ncprange_aton(&range, ncp, data))
 420     return 0;
 421
 422   if (range.ncprange_family == AF_INET && range.ncprange_ip4width != 32) {
 423     log_Printf(LogWARN, "ncpaddr_aton: %s: Only 32 bits allowed\n", data);
 424     return 0;
 425   }
 426
 427 #ifndef NOINET6
 428   if (range.ncprange_family == AF_INET6 && range.ncprange_ip6width != 128) {
 429     log_Printf(LogWARN, "ncpaddr_aton: %s: Only 128 bits allowed\n", data);
 430     return 0;
 431   }
 432 #endif
 433
 434   switch (range.ncprange_family) {
 435   case AF_INET:
 436     addr->ncpaddr_family = range.ncprange_family;
 437     addr->ncpaddr_ip4addr = range.ncprange_ip4addr;
 438     return 1;
 439
 440 #ifndef NOINET6
 441   case AF_INET6:
 442     addr->ncpaddr_family = range.ncprange_family;
 443     addr->ncpaddr_ip6addr = range.ncprange_ip6addr;
 444     return 1;
 445 #endif
 446   }
 447
 448   return 0;
 449 }
 450
 451 void
 452 ncprange_init(struct ncprange *range)
 453 {
 454   range->ncprange_family = AF_UNSPEC;
 455 }
 456
 457 int
 458 ncprange_isset(const struct ncprange *range)
 459 {
 460   return range->ncprange_family != AF_UNSPEC;
 461 }
 462
 463 int
 464 ncprange_equal(const struct ncprange *range, const struct ncprange *cmp)
 465 {
 466   if (range->ncprange_family != cmp->ncprange_family)
 467     return 0;
 468
 469   switch (range->ncprange_family) {
 470   case AF_INET:
 471     if (range->ncprange_ip4addr.s_addr != cmp->ncprange_ip4addr.s_addr)
 472       return 0;
 473     return range->ncprange_ip4mask.s_addr == cmp->ncprange_ip4mask.s_addr;
 474
 475 #ifndef NOINET6
 476   case AF_INET6:
 477     if (range->ncprange_ip6width != cmp->ncprange_ip6width)
 478       return 0;
 479     return !memcmp(&range->ncprange_ip6addr, &cmp->ncprange_ip6addr,
 480                    sizeof range->ncprange_ip6addr);
 481 #endif
 482
 483   case AF_UNSPEC:
 484     return 1;
 485   }
 486
 487   return 0;
 488 }
 489
 490 int
 491 ncprange_isdefault(const struct ncprange *range)
 492 {
 493   switch (range->ncprange_family) {
 494   case AF_INET:
 495     if (range->ncprange_ip4addr.s_addr == INADDR_ANY)
 496       return 1;
 497     break;
 498
 499 #ifndef NOINET6
 500   case AF_INET6:
 501     if (range->ncprange_ip6width == 0 &&
 502         IN6_IS_ADDR_UNSPECIFIED(&range->ncprange_ip6addr))
 503       return 1;
 504     break;
 505 #endif
 506   }
 507
 508   return 0;
 509 }
 510
 511 void
 512 ncprange_setdefault(struct ncprange *range, int af)
 513 {
 514   memset(range, '\0', sizeof *range);
 515   range->ncprange_family = af;
 516 }
 517
 518 int
 519 ncprange_contains(const struct ncprange *range, const struct ncpaddr *addr)
 520 {
 521 #ifndef NOINET6
 522   const u_char masks[] = { 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff };
 523   const u_char *addrp, *rangep;
 524   int bits;
 525 #endif
 526
 527   if (range->ncprange_family != addr->ncpaddr_family)
 528     return 0;
 529
 530   switch (range->ncprange_family) {
 531   case AF_INET:
 532     return !((addr->ncpaddr_ip4addr.s_addr ^ range->ncprange_ip4addr.s_addr) &
 533              range->ncprange_ip4mask.s_addr);
 534
 535 #ifndef NOINET6
 536   case AF_INET6:
 537     rangep = (const u_char *)range->ncprange_ip6addr.s6_addr;
 538     addrp = (const u_char *)addr->ncpaddr_ip6addr.s6_addr;
 539
 540     for (bits = range->ncprange_ip6width; bits > 0; bits -= 8)
 541       if ((*addrp++ ^ *rangep++) & masks[bits > 7 ? 7 : bits - 1])
 542         return 0;
 543
 544     return 1;
 545 #endif
 546   }
 547
 548   return 0;
 549 }
 550
 551 int
 552 ncprange_containsip4(const struct ncprange *range, struct in_addr addr)
 553 {
 554   switch (range->ncprange_family) {
 555   case AF_INET:
 556     return !((addr.s_addr ^ range->ncprange_ip4addr.s_addr) &
 557              range->ncprange_ip4mask.s_addr);
 558   }
 559
 560   return 0;
 561 }
 562
 563 void
 564 ncprange_copy(struct ncprange *range, const struct ncprange *from)
 565 {
 566   switch (from->ncprange_family) {
 567   case AF_INET:
 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;
 572     break;
 573
 574 #ifndef NOINET6
 575   case AF_INET6:
 576     range->ncprange_family = AF_INET6;
 577     range->ncprange_ip6addr = from->ncprange_ip6addr;
 578     range->ncprange_ip6width = from->ncprange_ip6width;
 579     break;
 580 #endif
 581
 582   default:
 583     range->ncprange_family = AF_UNSPEC;
 584   }
 585 }
 586
 587 void
 588 ncprange_set(struct ncprange *range, const struct ncpaddr *addr, int width)
 589 {
 590   ncprange_sethost(range, addr);
 591   ncprange_setwidth(range, width);
 592 }
 593
 594 void
 595 ncprange_sethost(struct ncprange *range, const struct ncpaddr *from)
 596 {
 597   switch (from->ncpaddr_family) {
 598   case AF_INET:
 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;
 604     } else {
 605       range->ncprange_ip4mask.s_addr = INADDR_BROADCAST;
 606       range->ncprange_ip4width = 32;
 607     }
 608     break;
 609
 610 #ifndef NOINET6
 611   case AF_INET6:
 612     range->ncprange_family = AF_INET6;
 613     range->ncprange_ip6addr = from->ncpaddr_ip6addr;
 614     range->ncprange_ip6width = 128;
 615     break;
 616 #endif
 617
 618   default:
 619     range->ncprange_family = AF_UNSPEC;
 620   }
 621 }
 622
 623 int
 624 ncprange_ishost(const struct ncprange *range)
 625 {
 626   switch (range->ncprange_family) {
 627   case AF_INET:
 628     return range->ncprange_ip4width == 32;
 629 #ifndef NOINET6
 630   case AF_INET6:
 631     return range->ncprange_ip6width == 128;
 632 #endif
 633   }
 634
 635   return (0);
 636 }
 637
 638 int
 639 ncprange_setwidth(struct ncprange *range, int width)
 640 {
 641   switch (range->ncprange_family) {
 642   case AF_INET:
 643     if (width < 0 || width > 32)
 644       break;
 645     range->ncprange_ip4width = width;
 646     range->ncprange_ip4mask = bits2mask4(width);
 647     break;
 648
 649 #ifndef NOINET6
 650   case AF_INET6:
 651     if (width < 0 || width > 128)
 652       break;
 653     range->ncprange_ip6width = width;
 654     break;
 655 #endif
 656
 657   case AF_UNSPEC:
 658     return 1;
 659   }
 660
 661   return 0;
 662 }
 663
 664 void
 665 ncprange_setip4host(struct ncprange *range, struct in_addr from)
 666 {
 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;
 672   } else {
 673     range->ncprange_ip4mask.s_addr = INADDR_BROADCAST;
 674     range->ncprange_ip4width = 32;
 675   }
 676 }
 677
 678 void
 679 ncprange_setip4(struct ncprange *range, struct in_addr from, struct in_addr msk)
 680 {
 681   range->ncprange_family = AF_INET;
 682   range->ncprange_ip4addr = from;
 683   range->ncprange_ip4mask = msk;
 684   range->ncprange_ip4width = mask42bits(msk);
 685 }
 686
 687
 688 int
 689 ncprange_setip4mask(struct ncprange *range, struct in_addr mask)
 690 {
 691   if (range->ncprange_family != AF_INET)
 692     return 0;
 693   range->ncprange_ip4mask = mask;
 694   range->ncprange_ip4width = mask42bits(mask);
 695   return 1;
 696 }
 697
 698 void
 699 ncprange_setsa(struct ncprange *range, const struct sockaddr *host,
 700                const struct sockaddr *mask)
 701 {
 702   const struct sockaddr_in *host4 = (const struct sockaddr_in *)host;
 703   const struct sockaddr_in *mask4 = (const struct sockaddr_in *)mask;
 704 #ifndef NOINET6
 705   const struct sockaddr_in6 *host6 = (const struct sockaddr_in6 *)host;
 706   const struct sockaddr_in6 *mask6 = (const struct sockaddr_in6 *)mask;
 707 #endif
 708
 709   switch (host->sa_family) {
 710   case AF_INET:
 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);
 719     } else {
 720       range->ncprange_ip4mask.s_addr = INADDR_BROADCAST;
 721       range->ncprange_ip4width = 32;
 722     }
 723     break;
 724
 725 #ifndef NOINET6
 726   case AF_INET6:
 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;
 731     else
 732       range->ncprange_ip6width = mask6 ? mask62bits(&mask6->sin6_addr) : 128;
 733     break;
 734 #endif
 735
 736   default:
 737     range->ncprange_family = AF_UNSPEC;
 738   }
 739 }
 740
 741 void
 742 ncprange_getsa(const struct ncprange *range, struct sockaddr_storage *host,
 743                struct sockaddr_storage *mask)
 744 {
 745   struct sockaddr_in *host4 = (struct sockaddr_in *)host;
 746   struct sockaddr_in *mask4 = (struct sockaddr_in *)mask;
 747 #ifndef NOINET6
 748   struct sockaddr_in6 *host6 = (struct sockaddr_in6 *)host;
 749   struct sockaddr_in6 *mask6 = (struct sockaddr_in6 *)mask;
 750 #endif
 751
 752   memset(host, '\0', sizeof(*host));
 753   if (mask)
 754     memset(mask, '\0', sizeof(*mask));
 755
 756   switch (range->ncprange_family) {
 757   case AF_INET:
 758     host4->sin_family = AF_INET;
 759     host4->sin_len = sizeof(*host4);
 760     host4->sin_addr = range->ncprange_ip4addr;
 761     if (mask4) {
 762       mask4->sin_family = AF_INET;
 763       mask4->sin_len = sizeof(*host4);
 764       mask4->sin_addr = range->ncprange_ip4mask;
 765     }
 766     break;
 767
 768 #ifndef NOINET6
 769   case AF_INET6:
 770     host6->sin6_family = AF_INET6;
 771     host6->sin6_len = sizeof(*host6);
 772     host6->sin6_addr = range->ncprange_ip6addr;
 773     if (mask6) {
 774       mask6->sin6_family = AF_INET6;
 775       mask6->sin6_len = sizeof(*host6);
 776       mask6->sin6_addr = bits2mask6(range->ncprange_ip6width);
 777     }
 778     break;
 779 #endif
 780
 781   default:
 782     host->ss_family = AF_UNSPEC;
 783     if (mask)
 784       mask->ss_family = AF_UNSPEC;
 785     break;
 786   }
 787 }
 788
 789 int
 790 ncprange_getaddr(const struct ncprange *range, struct ncpaddr *addr)
 791 {
 792   switch (range->ncprange_family) {
 793   case AF_INET:
 794     addr->ncpaddr_family = AF_INET;
 795     addr->ncpaddr_ip4addr = range->ncprange_ip4addr;
 796     return 1;
 797 #ifndef NOINET6
 798   case AF_INET6:
 799     addr->ncpaddr_family = AF_INET6;
 800     addr->ncpaddr_ip6addr =  range->ncprange_ip6addr;
 801     return 1;
 802 #endif
 803   }
 804
 805   return 0;
 806 }
 807
 808 int
 809 ncprange_getip4addr(const struct ncprange *range, struct in_addr *addr)
 810 {
 811   if (range->ncprange_family != AF_INET)
 812     return 0;
 813
 814   *addr = range->ncprange_ip4addr;
 815   return 1;
 816 }
 817
 818 int
 819 ncprange_getip4mask(const struct ncprange *range, struct in_addr *mask)
 820 {
 821   switch (range->ncprange_family) {
 822   case AF_INET:
 823     *mask = range->ncprange_ip4mask;
 824     return 1;
 825   }
 826
 827   return 0;
 828 }
 829
 830 int
 831 ncprange_getwidth(const struct ncprange *range, int *width)
 832 {
 833   switch (range->ncprange_family) {
 834   case AF_INET:
 835     *width = range->ncprange_ip4width;
 836     return 1;
 837 #ifndef NOINET6
 838   case AF_INET6:
 839     *width = range->ncprange_ip6width;
 840     return 1;
 841 #endif
 842   }
 843
 844   return 0;
 845 }
 846
 847 const char *
 848 ncprange_ntoa(const struct ncprange *range)
 849 {
 850   char *res;
 851   struct ncpaddr addr;
 852   int len;
 853
 854   if (!ncprange_getaddr(range, &addr))
 855     return "<AF_UNSPEC>";
 856
 857   res = ncpaddr_ntowa(&addr);
 858   len = strlen(res);
 859   if (len >= NCP_ASCIIBUFFERSIZE - 1)
 860     return res;
 861
 862   switch (range->ncprange_family) {
 863   case AF_INET:
 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"))
 868           break;
 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);
 873
 874     return res;
 875
 876 #ifndef NOINET6
 877   case AF_INET6:
 878     if (range->ncprange_ip6width != 128)
 879       snprintf(res + len, strlen(res) - len, "/%d", range->ncprange_ip6width);
 880
 881     return res;
 882 #endif
 883   }
 884
 885   return "<AF_UNSPEC>";
 886 }
 887
 888 #ifndef NOINET6
 889 int
 890 ncprange_scopeid(const struct ncprange *range)
 891 {
 892   const struct in6_addr *sin6;
 893   int scopeid = -1;
 894
 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)
 899         scopeid = -1;
 900   }
 901
 902   return scopeid;
 903 }
 904 #endif
 905
 906 int
 907 ncprange_aton(struct ncprange *range, struct ncp *ncp, const char *data)
 908 {
 909   int bits, len;
 910   char *wp;
 911   const char *cp;
 912   char *s;
 913
 914   len = strcspn(data, "/");
 915
 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;
 921     return 1;
 922 #ifndef NOINET6
 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;
 927     return 1;
 928 #endif
 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;
 934     return 1;
 935 #ifndef NOINET6
 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;
 940     return 1;
 941 #endif
 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;
 947     return 1;
 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;
 953     return 1;
 954   }
 955
 956   s = (char *)alloca(len + 1);
 957   strncpy(s, data, len);
 958   s[len] = '\0';
 959   bits = -1;
 960
 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");
 965       return 0;
 966     }
 967   }
 968
 969   if ((cp = strchr(data, ':')) == NULL) {
 970     range->ncprange_family = AF_INET;
 971
 972     range->ncprange_ip4addr = GetIpAddr(s);
 973
 974     if (range->ncprange_ip4addr.s_addr == INADDR_NONE) {
 975       log_Printf(LogWARN, "ncprange_aton: %s: Bad address\n", s);
 976       return 0;
 977     }
 978
 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");
 987       return 0;
 988     } else {
 989       range->ncprange_ip4mask = bits2mask4(bits);
 990       range->ncprange_ip4width = bits;
 991     }
 992
 993     return 1;
 994 #ifndef NOINET6
 995   } else if (strchr(cp + 1, ':') != NULL) {
 996     range->ncprange_family = AF_INET6;
 997
 998     if (inet_pton(AF_INET6, s, &range->ncprange_ip6addr) != 1) {
 999       log_Printf(LogWARN, "ncprange_aton: %s: Bad address\n", s);
1000       return 0;
1001     }
1002
1003     if (IN6_IS_ADDR_UNSPECIFIED(&range->ncprange_ip6addr))
1004       range->ncprange_ip6width = 0;
1005     else
1006       range->ncprange_ip6width = (bits == -1) ? 128 : bits;
1007     return 1;
1008 #endif
1009   }
1010
1011   return 0;
1012 }