src/kits/network/libnetapi/NetworkAddress.cpp

   1 /*
   2  * Copyright 2010-2015, Axel Dörfler, axeld@pinc-software.de.
   3  * Distributed under the terms of the MIT License.
   4  */
   5
   6
   7 #include <NetworkAddress.h>
   8
   9 #include <NetworkInterface.h>
  10 #include <NetworkRoster.h>
  11
  12 #include <arpa/inet.h>
  13 #include <ctype.h>
  14 #include <errno.h>
  15 #include <netinet/in.h>
  16 #include <stdio.h>
  17 #include <sys/sockio.h>
  18
  19
  20 /* The GCC builtin below only exists in > GCC 3.4
  21  * Benefits include faster execution time as the builtin
  22  * uses a bitcounting cpu instruction if it exists
  23  */
  24 #if __GNUC__ > 3
  25 #       define addr_bitcount(bitfield) __builtin_popcount(bitfield)
  26 #else
  27 static ssize_t
  28 addr_bitcount(uint32 bitfield)
  29 {
  30         ssize_t result = 0;
  31         for (uint8 i = 32; i > 0; i--) {
  32                 if ((bitfield & (1 << (i - 1))) == 0)
  33                         break;
  34                 result++;
  35         }
  36         return result;
  37 }
  38 #endif
  39
  40
  41 static uint8
  42 from_hex(char hex)
  43 {
  44         if (isdigit(hex))
  45                 return hex - '0';
  46
  47         return tolower(hex) - 'a' + 10;
  48 }
  49
  50
  51 // #pragma mark -
  52
  53
  54 BNetworkAddress::BNetworkAddress()
  55 {
  56         Unset();
  57 }
  58
  59
  60 BNetworkAddress::BNetworkAddress(const char* host, uint16 port, uint32 flags)
  61 {
  62         fStatus = SetTo(host, port, flags);
  63 }
  64
  65
  66 BNetworkAddress::BNetworkAddress(const char* host, const char* service,
  67         uint32 flags)
  68 {
  69         fStatus = SetTo(host, service, flags);
  70 }
  71
  72
  73 BNetworkAddress::BNetworkAddress(int family, const char* host, uint16 port,
  74         uint32 flags)
  75 {
  76         fStatus = SetTo(family, host, port, flags);
  77 }
  78
  79
  80 BNetworkAddress::BNetworkAddress(int family, const char* host,
  81         const char* service, uint32 flags)
  82 {
  83         fStatus = SetTo(family, host, service, flags);
  84 }
  85
  86
  87 BNetworkAddress::BNetworkAddress(const sockaddr& address)
  88 {
  89         SetTo(address);
  90 }
  91
  92
  93 BNetworkAddress::BNetworkAddress(const sockaddr_storage& address)
  94 {
  95         SetTo(address);
  96 }
  97
  98
  99 BNetworkAddress::BNetworkAddress(const sockaddr_in& address)
 100 {
 101         SetTo(address);
 102 }
 103
 104
 105 BNetworkAddress::BNetworkAddress(const sockaddr_in6& address)
 106 {
 107         SetTo(address);
 108 }
 109
 110
 111 BNetworkAddress::BNetworkAddress(const sockaddr_dl& address)
 112 {
 113         SetTo(address);
 114 }
 115
 116
 117 BNetworkAddress::BNetworkAddress(in_addr_t address, uint16 port)
 118 {
 119         SetTo(address, port);
 120 }
 121
 122
 123 BNetworkAddress::BNetworkAddress(const in6_addr& address, uint16 port)
 124 {
 125         SetTo(address, port);
 126 }
 127
 128
 129 BNetworkAddress::BNetworkAddress(const BNetworkAddress& other)
 130         :
 131         fAddress(other.fAddress),
 132         fStatus(other.fStatus),
 133         fHostName(other.fHostName)
 134 {
 135 }
 136
 137
 138 BNetworkAddress::~BNetworkAddress()
 139 {
 140 }
 141
 142
 143 status_t
 144 BNetworkAddress::InitCheck() const
 145 {
 146         return fStatus;
 147 }
 148
 149
 150 void
 151 BNetworkAddress::Unset()
 152 {
 153         fAddress.ss_family = AF_UNSPEC;
 154         fAddress.ss_len = 2;
 155         fHostName = "";
 156         fStatus = B_OK;
 157 }
 158
 159
 160 status_t
 161 BNetworkAddress::SetTo(const char* host, uint16 port, uint32 flags)
 162 {
 163         BReference<const BNetworkAddressResolver> resolver
 164                 = BNetworkAddressResolver::Resolve(host, port, flags);
 165         if (resolver.Get() == NULL)
 166                 return B_NO_MEMORY;
 167         status_t status = resolver->InitCheck();
 168         if (status != B_OK)
 169                 return status;
 170
 171         // Prefer IPv6 addresses
 172
 173         uint32 cookie = 0;
 174         status = resolver->GetNextAddress(AF_INET6, &cookie, *this);
 175         if (status != B_OK) {
 176                 cookie = 0;
 177                 status = resolver->GetNextAddress(&cookie, *this);
 178                 if (status != B_OK)
 179                         Unset();
 180         }
 181         fHostName = host;
 182         fStatus = status;
 183         return status;
 184 }
 185
 186
 187 status_t
 188 BNetworkAddress::SetTo(const char* host, const char* service, uint32 flags)
 189 {
 190         BReference<const BNetworkAddressResolver> resolver
 191                 = BNetworkAddressResolver::Resolve(host, service, flags);
 192         if (resolver.Get() == NULL)
 193                 return B_NO_MEMORY;
 194         status_t status = resolver->InitCheck();
 195         if (status != B_OK)
 196                 return status;
 197
 198         // Prefer IPv6 addresses
 199
 200         uint32 cookie = 0;
 201         status = resolver->GetNextAddress(AF_INET6, &cookie, *this);
 202         if (status != B_OK) {
 203                 cookie = 0;
 204                 status = resolver->GetNextAddress(&cookie, *this);
 205                 if (status != B_OK)
 206                         Unset();
 207         }
 208         fHostName = host;
 209         fStatus = status;
 210         return status;
 211 }
 212
 213
 214 status_t
 215 BNetworkAddress::SetTo(int family, const char* host, uint16 port, uint32 flags)
 216 {
 217         if (family == AF_LINK) {
 218                 if (port != 0)
 219                         return B_BAD_VALUE;
 220                 return _ParseLinkAddress(host);
 221                         // SetToLinkAddress takes care of setting fStatus
 222         }
 223
 224         BReference<const BNetworkAddressResolver> resolver
 225                 = BNetworkAddressResolver::Resolve(family, host, port, flags);
 226         if (resolver.Get() == NULL)
 227                 return B_NO_MEMORY;
 228         status_t status = resolver->InitCheck();
 229         if (status != B_OK)
 230                 return status;
 231
 232         uint32 cookie = 0;
 233         status = resolver->GetNextAddress(&cookie, *this);
 234         if (status != B_OK)
 235                 Unset();
 236         fHostName = host;
 237         fStatus = status;
 238         return status;
 239 }
 240
 241
 242 status_t
 243 BNetworkAddress::SetTo(int family, const char* host, const char* service,
 244         uint32 flags)
 245 {
 246         if (family == AF_LINK) {
 247                 if (service != NULL)
 248                         return B_BAD_VALUE;
 249                 return _ParseLinkAddress(host);
 250                         // SetToLinkAddress takes care of setting fStatus
 251         }
 252
 253         BReference<const BNetworkAddressResolver> resolver
 254                 = BNetworkAddressResolver::Resolve(family, host, service, flags);
 255         if (resolver.Get() == NULL)
 256                 return B_NO_MEMORY;
 257         status_t status = resolver->InitCheck();
 258         if (status != B_OK)
 259                 return status;
 260
 261         uint32 cookie = 0;
 262         status = resolver->GetNextAddress(&cookie, *this);
 263         if (status != B_OK)
 264                 Unset();
 265         fHostName = host;
 266         fStatus = status;
 267         return status;
 268 }
 269
 270
 271 void
 272 BNetworkAddress::SetTo(const sockaddr& address)
 273 {
 274         if (address.sa_family == AF_UNSPEC) {
 275                 Unset();
 276                 return;
 277         }
 278
 279         size_t length = min_c(sizeof(sockaddr_storage), address.sa_len);
 280         switch (address.sa_family) {
 281                 case AF_INET:
 282                         length = sizeof(sockaddr_in);
 283                         break;
 284                 case AF_INET6:
 285                         length = sizeof(sockaddr_in6);
 286                         break;
 287                 case AF_LINK:
 288                 {
 289                         sockaddr_dl& link = (sockaddr_dl&)address;
 290                         length = sizeof(sockaddr_dl) - sizeof(link.sdl_data) + link.sdl_alen
 291                                 + link.sdl_nlen + link.sdl_slen;
 292                         break;
 293                 }
 294         }
 295
 296         SetTo(address, length);
 297 }
 298
 299
 300 void
 301 BNetworkAddress::SetTo(const sockaddr& address, size_t length)
 302 {
 303         if (address.sa_family == AF_UNSPEC || length == 0) {
 304                 Unset();
 305                 return;
 306         }
 307
 308         memcpy(&fAddress, &address, length);
 309         fAddress.ss_len = length;
 310         fStatus = B_OK;
 311 }
 312
 313
 314 void
 315 BNetworkAddress::SetTo(const sockaddr_storage& address)
 316 {
 317         SetTo((sockaddr&)address);
 318 }
 319
 320
 321 void
 322 BNetworkAddress::SetTo(const sockaddr_in& address)
 323 {
 324         SetTo((sockaddr&)address);
 325 }
 326
 327
 328 void
 329 BNetworkAddress::SetTo(const sockaddr_in6& address)
 330 {
 331         SetTo((sockaddr&)address);
 332 }
 333
 334
 335 void
 336 BNetworkAddress::SetTo(const sockaddr_dl& address)
 337 {
 338         SetTo((sockaddr&)address);
 339 }
 340
 341
 342 void
 343 BNetworkAddress::SetTo(in_addr_t inetAddress, uint16 port)
 344 {
 345         memset(&fAddress, 0, sizeof(sockaddr_storage));
 346
 347         fAddress.ss_family = AF_INET;
 348         fAddress.ss_len = sizeof(sockaddr_in);
 349         SetAddress(inetAddress);
 350         SetPort(port);
 351
 352         fStatus = B_OK;
 353 }
 354
 355
 356 void
 357 BNetworkAddress::SetTo(const in6_addr& inet6Address, uint16 port)
 358 {
 359         memset(&fAddress, 0, sizeof(sockaddr_storage));
 360
 361         fAddress.ss_family = AF_INET6;
 362         fAddress.ss_len = sizeof(sockaddr_in6);
 363         SetAddress(inet6Address);
 364         SetPort(port);
 365
 366         fStatus = B_OK;
 367 }
 368
 369
 370 void
 371 BNetworkAddress::SetTo(const BNetworkAddress& other)
 372 {
 373         fAddress = other.fAddress;
 374         fStatus = other.fStatus;
 375         fHostName = other.fHostName;
 376 }
 377
 378
 379 status_t
 380 BNetworkAddress::SetToBroadcast(int family, uint16 port)
 381 {
 382         if (family != AF_INET)
 383                 return fStatus = B_NOT_SUPPORTED;
 384
 385         SetTo(INADDR_BROADCAST, port);
 386         return fStatus;
 387 }
 388
 389
 390 status_t
 391 BNetworkAddress::SetToLocal(int family, uint16 port)
 392 {
 393         // TODO: choose a local address from the network interfaces
 394         return fStatus = B_NOT_SUPPORTED;
 395 }
 396
 397
 398 status_t
 399 BNetworkAddress::SetToLoopback(int family, uint16 port)
 400 {
 401         switch (family) {
 402                 // TODO: choose family depending on availability of IPv6
 403                 case AF_UNSPEC:
 404                 case AF_INET:
 405                         SetTo(htonl(INADDR_LOOPBACK), port);
 406                         break;
 407
 408                 case AF_INET6:
 409                         SetTo(in6addr_loopback, port);
 410                         break;
 411
 412                 default:
 413                         return fStatus = B_NOT_SUPPORTED;
 414         }
 415
 416         return fStatus;
 417 }
 418
 419
 420 status_t
 421 BNetworkAddress::SetToMask(int family, uint32 prefixLength)
 422 {
 423         switch (family) {
 424                 case AF_INET:
 425                 {
 426                         if (prefixLength > 32)
 427                                 return B_BAD_VALUE;
 428
 429                         sockaddr_in& mask = (sockaddr_in&)fAddress;
 430                         memset(&fAddress, 0, sizeof(sockaddr_storage));
 431                         mask.sin_family = AF_INET;
 432                         mask.sin_len = sizeof(sockaddr_in);
 433
 434                         uint32 hostMask = 0;
 435                         for (uint8 i = 32; i > 32 - prefixLength; i--)
 436                                 hostMask |= 1 << (i - 1);
 437
 438                         mask.sin_addr.s_addr = htonl(hostMask);
 439                         break;
 440                 }
 441
 442                 case AF_INET6:
 443                 {
 444                         if (prefixLength > 128)
 445                                 return B_BAD_VALUE;
 446
 447                         sockaddr_in6& mask = (sockaddr_in6&)fAddress;
 448                         memset(&fAddress, 0, sizeof(sockaddr_storage));
 449                         mask.sin6_family = AF_INET6;
 450                         mask.sin6_len = sizeof(sockaddr_in6);
 451
 452                         for (uint8 i = 0; i < sizeof(in6_addr); i++, prefixLength -= 8) {
 453                                 if (prefixLength < 8) {
 454                                         mask.sin6_addr.s6_addr[i]
 455                                                 = (uint8)(0xff << (8 - prefixLength));
 456                                         break;
 457                                 }
 458
 459                                 mask.sin6_addr.s6_addr[i] = 0xff;
 460                         }
 461                         break;
 462                 }
 463
 464                 default:
 465                         return B_NOT_SUPPORTED;
 466         }
 467
 468         return fStatus = B_OK;
 469 }
 470
 471
 472 status_t
 473 BNetworkAddress::SetToWildcard(int family, uint16 port)
 474 {
 475         switch (family) {
 476                 case AF_INET:
 477                         SetTo(INADDR_ANY, port);
 478                         break;
 479
 480                 case AF_INET6:
 481                         SetTo(in6addr_any, port);
 482                         break;
 483
 484                 default:
 485                         return B_NOT_SUPPORTED;
 486         }
 487
 488         return fStatus;
 489 }
 490
 491
 492 status_t
 493 BNetworkAddress::SetAddress(in_addr_t inetAddress)
 494 {
 495         if (Family() != AF_INET)
 496                 return B_BAD_VALUE;
 497
 498         sockaddr_in& address = (sockaddr_in&)fAddress;
 499         address.sin_addr.s_addr = inetAddress;
 500         return B_OK;
 501 }
 502
 503
 504 status_t
 505 BNetworkAddress::SetAddress(const in6_addr& inet6Address)
 506 {
 507         if (Family() != AF_INET6)
 508                 return B_BAD_VALUE;
 509
 510         sockaddr_in6& address = (sockaddr_in6&)fAddress;
 511         memcpy(address.sin6_addr.s6_addr, &inet6Address,
 512                 sizeof(address.sin6_addr.s6_addr));
 513         return B_OK;
 514 }
 515
 516
 517 void
 518 BNetworkAddress::SetPort(uint16 port)
 519 {
 520         switch (fAddress.ss_family) {
 521                 case AF_INET:
 522                         ((sockaddr_in&)fAddress).sin_port = htons(port);
 523                         break;
 524
 525                 case AF_INET6:
 526                         ((sockaddr_in6&)fAddress).sin6_port = htons(port);
 527                         break;
 528
 529                 default:
 530                         break;
 531         }
 532 }
 533
 534
 535 void
 536 BNetworkAddress::SetToLinkLevel(uint8* address, size_t length)
 537 {
 538         sockaddr_dl& link = (sockaddr_dl&)fAddress;
 539         memset(&link, 0, sizeof(sockaddr_dl));
 540
 541         link.sdl_family = AF_LINK;
 542         link.sdl_alen = length;
 543         memcpy(LLADDR(&link), address, length);
 544
 545         link.sdl_len = sizeof(sockaddr_dl);
 546         if (length > sizeof(link.sdl_data))
 547                 link.sdl_len += length - sizeof(link.sdl_data);
 548
 549         fStatus = B_OK;
 550 }
 551
 552
 553 void
 554 BNetworkAddress::SetToLinkLevel(const char* name)
 555 {
 556         sockaddr_dl& link = (sockaddr_dl&)fAddress;
 557         memset(&link, 0, sizeof(sockaddr_dl));
 558
 559         size_t length = strlen(name);
 560         if (length > sizeof(fAddress) - sizeof(sockaddr_dl) + sizeof(link.sdl_data))
 561                 length = sizeof(fAddress) - sizeof(sockaddr_dl) + sizeof(link.sdl_data);
 562
 563         link.sdl_family = AF_LINK;
 564         link.sdl_nlen = length;
 565
 566         memcpy(link.sdl_data, name, link.sdl_nlen);
 567
 568         link.sdl_len = sizeof(sockaddr_dl);
 569         if (link.sdl_nlen > sizeof(link.sdl_data))
 570                 link.sdl_len += link.sdl_nlen - sizeof(link.sdl_data);
 571
 572         fStatus = B_OK;
 573 }
 574
 575
 576 void
 577 BNetworkAddress::SetToLinkLevel(uint32 index)
 578 {
 579         sockaddr_dl& link = (sockaddr_dl&)fAddress;
 580         memset(&link, 0, sizeof(sockaddr_dl));
 581
 582         link.sdl_family = AF_LINK;
 583         link.sdl_len = sizeof(sockaddr_dl);
 584         link.sdl_index = index;
 585
 586         fStatus = B_OK;
 587 }
 588
 589
 590 void
 591 BNetworkAddress::SetLinkLevelIndex(uint32 index)
 592 {
 593         sockaddr_dl& link = (sockaddr_dl&)fAddress;
 594         link.sdl_index = index;
 595 }
 596
 597
 598 void
 599 BNetworkAddress::SetLinkLevelType(uint8 type)
 600 {
 601         sockaddr_dl& link = (sockaddr_dl&)fAddress;
 602         link.sdl_type = type;
 603 }
 604
 605
 606 void
 607 BNetworkAddress::SetLinkLevelFrameType(uint16 frameType)
 608 {
 609         sockaddr_dl& link = (sockaddr_dl&)fAddress;
 610         link.sdl_e_type = htons(frameType);
 611 }
 612
 613
 614 int
 615 BNetworkAddress::Family() const
 616 {
 617         return fAddress.ss_family;
 618 }
 619
 620
 621 uint16
 622 BNetworkAddress::Port() const
 623 {
 624         switch (fAddress.ss_family) {
 625                 case AF_INET:
 626                         return ntohs(((sockaddr_in&)fAddress).sin_port);
 627
 628                 case AF_INET6:
 629                         return ntohs(((sockaddr_in6&)fAddress).sin6_port);
 630
 631                 default:
 632                         return 0;
 633         }
 634 }
 635
 636
 637 size_t
 638 BNetworkAddress::Length() const
 639 {
 640         return fAddress.ss_len;
 641 }
 642
 643
 644 const sockaddr&
 645 BNetworkAddress::SockAddr() const
 646 {
 647         return (const sockaddr&)fAddress;
 648 }
 649
 650
 651 sockaddr&
 652 BNetworkAddress::SockAddr()
 653 {
 654         return (sockaddr&)fAddress;
 655 }
 656
 657
 658 bool
 659 BNetworkAddress::IsEmpty() const
 660 {
 661         if (fAddress.ss_len == 0)
 662                 return true;
 663
 664         switch (fAddress.ss_family) {
 665                 case AF_UNSPEC:
 666                         return true;
 667                 case AF_INET:
 668                 {
 669                         sockaddr_in& sin = (sockaddr_in&)fAddress;
 670                         return sin.sin_addr.s_addr == INADDR_ANY && sin.sin_port == 0;
 671                 }
 672                 case AF_INET6:
 673                 {
 674                         sockaddr_in6& sin6 = (sockaddr_in6&)fAddress;
 675                         return IN6_IS_ADDR_UNSPECIFIED(&sin6.sin6_addr)
 676                                 && sin6.sin6_port == 0;
 677                 }
 678
 679                 default:
 680                         return false;
 681         }
 682 }
 683
 684
 685 bool
 686 BNetworkAddress::IsWildcard() const
 687 {
 688         switch (fAddress.ss_family) {
 689                 case AF_INET:
 690                         return ((sockaddr_in&)fAddress).sin_addr.s_addr == INADDR_ANY;
 691
 692                 case AF_INET6:
 693                         return !memcmp(&((sockaddr_in6&)fAddress).sin6_addr, &in6addr_any,
 694                                 sizeof(in6_addr));
 695
 696                 default:
 697                         return false;
 698         }
 699 }
 700
 701
 702 bool
 703 BNetworkAddress::IsBroadcast() const
 704 {
 705         switch (fAddress.ss_family) {
 706                 case AF_INET:
 707                         return ((sockaddr_in&)fAddress).sin_addr.s_addr == INADDR_BROADCAST;
 708
 709                 case AF_INET6:
 710                         // There is no broadcast in IPv6, only multicast/anycast
 711                         return IN6_IS_ADDR_MULTICAST(&((sockaddr_in6&)fAddress).sin6_addr);
 712
 713                 default:
 714                         return false;
 715         }
 716 }
 717
 718
 719 bool
 720 BNetworkAddress::IsMulticast() const
 721 {
 722         switch (fAddress.ss_family) {
 723                 case AF_INET:
 724                         return IN_MULTICAST(((sockaddr_in&)fAddress).sin_addr.s_addr);
 725
 726                 case AF_INET6:
 727                         return IN6_IS_ADDR_MULTICAST(&((sockaddr_in6&)fAddress).sin6_addr);
 728
 729                 default:
 730                         return false;
 731         }
 732 }
 733
 734
 735 bool
 736 BNetworkAddress::IsMulticastGlobal() const
 737 {
 738         switch (fAddress.ss_family) {
 739                 case AF_INET6:
 740                         return IN6_IS_ADDR_MC_GLOBAL(&((sockaddr_in6&)fAddress).sin6_addr);
 741
 742                 default:
 743                         return false;
 744         }
 745 }
 746
 747
 748 bool
 749 BNetworkAddress::IsMulticastNodeLocal() const
 750 {
 751         switch (fAddress.ss_family) {
 752                 case AF_INET6:
 753                         return IN6_IS_ADDR_MC_NODELOCAL(
 754                                 &((sockaddr_in6&)fAddress).sin6_addr);
 755
 756                 default:
 757                         return false;
 758         }
 759 }
 760
 761
 762 bool
 763 BNetworkAddress::IsMulticastLinkLocal() const
 764 {
 765         switch (fAddress.ss_family) {
 766                 case AF_INET6:
 767                         return IN6_IS_ADDR_MC_LINKLOCAL(
 768                                 &((sockaddr_in6&)fAddress).sin6_addr);
 769
 770                 default:
 771                         return false;
 772         }
 773 }
 774
 775
 776 bool
 777 BNetworkAddress::IsMulticastSiteLocal() const
 778 {
 779         switch (fAddress.ss_family) {
 780                 case AF_INET6:
 781                         return IN6_IS_ADDR_MC_SITELOCAL(
 782                                 &((sockaddr_in6&)fAddress).sin6_addr);
 783
 784                 default:
 785                         return false;
 786         }
 787 }
 788
 789
 790 bool
 791 BNetworkAddress::IsMulticastOrgLocal() const
 792 {
 793         switch (fAddress.ss_family) {
 794                 case AF_INET6:
 795                         return IN6_IS_ADDR_MC_ORGLOCAL(
 796                                 &((sockaddr_in6&)fAddress).sin6_addr);
 797
 798                 default:
 799                         return false;
 800         }
 801 }
 802
 803
 804 bool
 805 BNetworkAddress::IsLinkLocal() const
 806 {
 807         // TODO: ipv4
 808         switch (fAddress.ss_family) {
 809                 case AF_INET6:
 810                         return IN6_IS_ADDR_LINKLOCAL(&((sockaddr_in6&)fAddress).sin6_addr);
 811
 812                 default:
 813                         return false;
 814         }
 815 }
 816
 817
 818 bool
 819 BNetworkAddress::IsSiteLocal() const
 820 {
 821         switch (fAddress.ss_family) {
 822                 case AF_INET6:
 823                         return IN6_IS_ADDR_SITELOCAL(&((sockaddr_in6&)fAddress).sin6_addr);
 824
 825                 default:
 826                         return false;
 827         }
 828 }
 829
 830
 831 bool
 832 BNetworkAddress::IsLocal() const
 833 {
 834         BNetworkRoster& roster = BNetworkRoster::Default();
 835
 836         BNetworkInterface interface;
 837         uint32 cookie = 0;
 838
 839         while (roster.GetNextInterface(&cookie, interface) == B_OK) {
 840                 int32 count = interface.CountAddresses();
 841                 for (int32 j = 0; j < count; j++) {
 842                         BNetworkInterfaceAddress address;
 843                         if (interface.GetAddressAt(j, address) != B_OK)
 844                                 break;
 845
 846                         if (Equals(address.Address(), false))
 847                                 return true;
 848                 }
 849         }
 850
 851         return false;
 852 }
 853
 854
 855 ssize_t
 856 BNetworkAddress::PrefixLength() const
 857 {
 858         switch (fAddress.ss_family) {
 859                 case AF_INET:
 860                 {
 861                         sockaddr_in& mask = (sockaddr_in&)fAddress;
 862
 863                         uint32 hostMask = ntohl(mask.sin_addr.s_addr);
 864                         return addr_bitcount(hostMask);
 865                 }
 866
 867                 case AF_INET6:
 868                 {
 869                         sockaddr_in6& mask = (sockaddr_in6&)fAddress;
 870
 871                         // TODO : see if we can use the optimized addr_bitcount for this
 872                         ssize_t result = 0;
 873                         for (uint8 i = 0; i < sizeof(in6_addr); i++) {
 874                                 for (uint8 j = 0; j < 8; j++) {
 875                                         if (!(mask.sin6_addr.s6_addr[i] & (1 << j)))
 876                                                 return result;
 877                                         result++;
 878                                 }
 879                         }
 880
 881                         return 128;
 882                 }
 883
 884                 default:
 885                         return B_NOT_SUPPORTED;
 886         }
 887 }
 888
 889
 890 uint32
 891 BNetworkAddress::LinkLevelIndex() const
 892 {
 893         return ((sockaddr_dl&)fAddress).sdl_index;
 894 }
 895
 896
 897 BString
 898 BNetworkAddress::LinkLevelInterface() const
 899 {
 900         sockaddr_dl& address = (sockaddr_dl&)fAddress;
 901         if (address.sdl_nlen == 0)
 902                 return "";
 903
 904         BString name;
 905         name.SetTo((const char*)address.sdl_data, address.sdl_nlen);
 906
 907         return name;
 908 }
 909
 910
 911 uint8
 912 BNetworkAddress::LinkLevelType() const
 913 {
 914         return ((sockaddr_dl&)fAddress).sdl_type;
 915 }
 916
 917
 918 uint16
 919 BNetworkAddress::LinkLevelFrameType() const
 920 {
 921         return ntohs(((sockaddr_dl&)fAddress).sdl_e_type);
 922 }
 923
 924
 925 uint8*
 926 BNetworkAddress::LinkLevelAddress() const
 927 {
 928         return LLADDR(&(sockaddr_dl&)fAddress);
 929 }
 930
 931
 932 size_t
 933 BNetworkAddress::LinkLevelAddressLength() const
 934 {
 935         return ((sockaddr_dl&)fAddress).sdl_alen;
 936 }
 937
 938
 939 status_t
 940 BNetworkAddress::ResolveForDestination(const BNetworkAddress& destination)
 941 {
 942         if (!IsWildcard())
 943                 return B_OK;
 944         if (destination.fAddress.ss_family != fAddress.ss_family)
 945                 return B_BAD_VALUE;
 946
 947         char buffer[2048];
 948         memset(buffer, 0, sizeof(buffer));
 949
 950         route_entry* route = (route_entry*)buffer;
 951         route->destination = (sockaddr*)&destination.fAddress;
 952
 953         int socket = ::socket(fAddress.ss_family, SOCK_DGRAM, 0);
 954         if (socket < 0)
 955                 return errno;
 956
 957         if (ioctl(socket, SIOCGETRT, route, sizeof(buffer)) != 0) {
 958                 close(socket);
 959                 return errno;
 960         }
 961
 962         uint16 port = Port();
 963         memcpy(&fAddress, route->source, sizeof(sockaddr_storage));
 964         SetPort(port);
 965
 966         close(socket);
 967         return B_OK;
 968 }
 969
 970
 971 status_t
 972 BNetworkAddress::ResolveTo(const BNetworkAddress& address)
 973 {
 974         if (!IsWildcard())
 975                 return B_OK;
 976         if (address.fAddress.ss_family != fAddress.ss_family)
 977                 return B_BAD_VALUE;
 978
 979         uint16 port = Port();
 980         *this = address;
 981         SetPort(port);
 982
 983         return B_OK;
 984 }
 985
 986
 987 BString
 988 BNetworkAddress::ToString(bool includePort) const
 989 {
 990         char buffer[512];
 991
 992         switch (fAddress.ss_family) {
 993                 case AF_INET:
 994                         inet_ntop(AF_INET, &((sockaddr_in&)fAddress).sin_addr, buffer,
 995                                 sizeof(buffer));
 996                         break;
 997
 998                 case AF_INET6:
 999                         inet_ntop(AF_INET6, &((sockaddr_in6&)fAddress).sin6_addr,
1000                                 buffer, sizeof(buffer));
1001                         break;
1002
1003                 case AF_LINK:
1004                 {
1005                         uint8 *byte = LinkLevelAddress();
1006                         char* target = buffer;
1007                         int bytesLeft = sizeof(buffer);
1008                         target[0] = '\0';
1009
1010                         for (size_t i = 0; i < LinkLevelAddressLength(); i++) {
1011                                 if (i != 0 && bytesLeft > 1) {
1012                                         target[0] = ':';
1013                                         target[1] = '\0';
1014                                         target++;
1015                                         bytesLeft--;
1016                                 }
1017
1018                                 int bytesWritten = snprintf(target, bytesLeft, "%02x", byte[i]);
1019                                 if (bytesWritten >= bytesLeft)
1020                                         break;
1021
1022                                 target += bytesWritten;
1023                                 bytesLeft -= bytesWritten;
1024                         }
1025                         break;
1026                 }
1027
1028                 default:
1029                         return "";
1030         }
1031
1032         BString address = buffer;
1033         if (includePort && Port() != 0) {
1034                 if (fAddress.ss_family == AF_INET6) {
1035                         address = "[";
1036                         address += buffer;
1037                         address += "]";
1038                 }
1039
1040                 snprintf(buffer, sizeof(buffer), ":%u", Port());
1041                 address += buffer;
1042         }
1043
1044         return address;
1045 }
1046
1047
1048 BString
1049 BNetworkAddress::HostName() const
1050 {
1051         // TODO: implement host name lookup
1052         return fHostName;
1053 }
1054
1055
1056 BString
1057 BNetworkAddress::ServiceName() const
1058 {
1059         // TODO: implement service lookup
1060         BString portName;
1061         portName << Port();
1062         return portName;
1063 }
1064
1065
1066 bool
1067 BNetworkAddress::Equals(const BNetworkAddress& other, bool includePort) const
1068 {
1069         if (IsEmpty() && other.IsEmpty())
1070                 return true;
1071
1072         if (Family() != other.Family()
1073                         || (includePort && Port() != other.Port())) {
1074                 return false;
1075         }
1076
1077         switch (fAddress.ss_family) {
1078                 case AF_INET:
1079                 {
1080                         sockaddr_in& address = (sockaddr_in&)fAddress;
1081                         sockaddr_in& otherAddress = (sockaddr_in&)other.fAddress;
1082                         return memcmp(&address.sin_addr, &otherAddress.sin_addr,
1083                                 sizeof(address.sin_addr)) == 0;
1084                 }
1085
1086                 case AF_INET6:
1087                 {
1088                         sockaddr_in6& address = (sockaddr_in6&)fAddress;
1089                         sockaddr_in6& otherAddress = (sockaddr_in6&)other.fAddress;
1090                         return memcmp(&address.sin6_addr, &otherAddress.sin6_addr,
1091                                 sizeof(address.sin6_addr)) == 0;
1092                 }
1093
1094                 default:
1095                         if (fAddress.ss_len != other.fAddress.ss_len)
1096                                 return false;
1097
1098                         return memcmp(&fAddress, &other.fAddress, fAddress.ss_len);
1099         }
1100 }
1101
1102
1103 // #pragma mark - BFlattenable implementation
1104
1105
1106 bool
1107 BNetworkAddress::IsFixedSize() const
1108 {
1109         return false;
1110 }
1111
1112
1113 type_code
1114 BNetworkAddress::TypeCode() const
1115 {
1116         return B_NETWORK_ADDRESS_TYPE;
1117 }
1118
1119
1120 ssize_t
1121 BNetworkAddress::FlattenedSize() const
1122 {
1123         return Length();
1124 }
1125
1126
1127 status_t
1128 BNetworkAddress::Flatten(void* buffer, ssize_t size) const
1129 {
1130         if (buffer == NULL || size < FlattenedSize())
1131                 return B_BAD_VALUE;
1132
1133         memcpy(buffer, &fAddress, Length());
1134         return B_OK;
1135 }
1136
1137
1138 status_t
1139 BNetworkAddress::Unflatten(type_code code, const void* buffer, ssize_t size)
1140 {
1141         // 2 bytes minimum for family, and length
1142         if (buffer == NULL || size < 2)
1143                 return fStatus = B_BAD_VALUE;
1144         if (!AllowsTypeCode(code))
1145                 return fStatus = B_BAD_TYPE;
1146
1147         memcpy(&fAddress, buffer, min_c(size, (ssize_t)sizeof(fAddress)));
1148
1149         // check if this can contain a valid address
1150         if (fAddress.ss_family != AF_UNSPEC && size < (ssize_t)sizeof(sockaddr))
1151                 return fStatus = B_BAD_VALUE;
1152
1153         return fStatus = B_OK;
1154 }
1155
1156
1157 // #pragma mark - operators
1158
1159
1160 BNetworkAddress&
1161 BNetworkAddress::operator=(const BNetworkAddress& other)
1162 {
1163         memcpy(&fAddress, &other.fAddress, other.fAddress.ss_len);
1164         fHostName = other.fHostName;
1165         fStatus = other.fStatus;
1166
1167         return *this;
1168 }
1169
1170
1171 bool
1172 BNetworkAddress::operator==(const BNetworkAddress& other) const
1173 {
1174         return Equals(other);
1175 }
1176
1177
1178 bool
1179 BNetworkAddress::operator!=(const BNetworkAddress& other) const
1180 {
1181         return !Equals(other);
1182 }
1183
1184
1185 bool
1186 BNetworkAddress::operator<(const BNetworkAddress& other) const
1187 {
1188         if (Family() < other.Family())
1189                 return true;
1190         if (Family() > other.Family())
1191                 return false;
1192
1193         int compare;
1194
1195         switch (fAddress.ss_family) {
1196                 default:
1197                 case AF_INET:
1198                 {
1199                         sockaddr_in& address = (sockaddr_in&)fAddress;
1200                         sockaddr_in& otherAddress = (sockaddr_in&)other.fAddress;
1201                         compare = memcmp(&address.sin_addr, &otherAddress.sin_addr,
1202                                 sizeof(address.sin_addr));
1203                         break;
1204                 }
1205
1206                 case AF_INET6:
1207                 {
1208                         sockaddr_in6& address = (sockaddr_in6&)fAddress;
1209                         sockaddr_in6& otherAddress = (sockaddr_in6&)other.fAddress;
1210                         compare = memcmp(&address.sin6_addr, &otherAddress.sin6_addr,
1211                                 sizeof(address.sin6_addr));
1212                         break;
1213                 }
1214
1215                 case AF_LINK:
1216                         if (LinkLevelAddressLength() < other.LinkLevelAddressLength())
1217                                 return true;
1218                         if (LinkLevelAddressLength() > other.LinkLevelAddressLength())
1219                                 return true;
1220
1221                         // TODO: could compare index, and name, too
1222                         compare = memcmp(LinkLevelAddress(), other.LinkLevelAddress(),
1223                                 LinkLevelAddressLength());
1224                         break;
1225         }
1226
1227         if (compare < 0)
1228                 return true;
1229         if (compare > 0)
1230                 return false;
1231
1232         return Port() < other.Port();
1233 }
1234
1235
1236 BNetworkAddress::operator const sockaddr*() const
1237 {
1238         return (const sockaddr*)&fAddress;
1239 }
1240
1241
1242 BNetworkAddress::operator const sockaddr&() const
1243 {
1244         return (const sockaddr&)fAddress;
1245 }
1246
1247
1248 BNetworkAddress::operator sockaddr*()
1249 {
1250         return (sockaddr*)&fAddress;
1251 }
1252
1253
1254 BNetworkAddress::operator const sockaddr*()
1255 {
1256         return (sockaddr*)&fAddress;
1257 }
1258
1259
1260 BNetworkAddress::operator sockaddr&()
1261 {
1262         return (sockaddr&)fAddress;
1263 }
1264
1265
1266 BNetworkAddress::operator const sockaddr&()
1267 {
1268         return (sockaddr&)fAddress;
1269 }
1270
1271
1272 // #pragma mark - private
1273
1274
1275 status_t
1276 BNetworkAddress::_ParseLinkAddress(const char* address)
1277 {
1278         if (address == NULL)
1279                 return B_BAD_VALUE;
1280
1281         uint8 linkAddress[128];
1282         uint32 length = 0;
1283         while (length < sizeof(linkAddress)) {
1284                 if (!isxdigit(address[0]) || !isxdigit(address[1]))
1285                         return B_BAD_VALUE;
1286
1287                 linkAddress[length++] = (from_hex(address[0]) << 4)
1288                         | from_hex(address[1]);
1289
1290                 if (address[2] == '\0')
1291                         break;
1292                 if (address[2] != ':')
1293                         return B_BAD_VALUE;
1294
1295                 address += 3;
1296         }
1297
1298         fHostName = address;
1299
1300         SetToLinkLevel(linkAddress, length);
1301         return B_OK;
1302 }