lib/util/util_net.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Samba utility functions
   4    Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2008
   5    Copyright (C) Andrew Tridgell 1992-1998
   6    Copyright (C) Jeremy Allison  1992-2007
   7    Copyright (C) Simo Sorce 2001
   8    Copyright (C) Jim McDonough (jmcd@us.ibm.com)  2003.
   9    Copyright (C) James J Myers 2003
  10    Copyright (C) Tim Potter      2000-2001
  11
  12    This program is free software; you can redistribute it and/or modify
  13    it under the terms of the GNU General Public License as published by
  14    the Free Software Foundation; either version 3 of the License, or
  15    (at your option) any later version.
  16
  17    This program is distributed in the hope that it will be useful,
  18    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20    GNU General Public License for more details.
  21
  22    You should have received a copy of the GNU General Public License
  23    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  24 */
  25
  26 #include "includes.h"
  27 #include "system/network.h"
  28 #include "system/locale.h"
  29 #include "system/filesys.h"
  30 #include "lib/util/util_net.h"
  31 #undef strcasecmp
  32
  33 /*******************************************************************
  34  Set an address to INADDR_ANY.
  35 ******************************************************************/
  36
  37 void zero_sockaddr(struct sockaddr_storage *pss)
  38 {
  39         /* Ensure we're at least a valid sockaddr-storage. */
  40         *pss = (struct sockaddr_storage) { .ss_family = AF_INET };
  41 }
  42
  43 static char *normalize_ipv6_literal(const char *str, char *buf, size_t *_len)
  44 {
  45 #define IPv6_LITERAL_NET ".ipv6-literal.net"
  46         const size_t llen = sizeof(IPv6_LITERAL_NET) - 1;
  47         size_t len = *_len;
  48         int cmp;
  49         size_t i;
  50         size_t idx_chars = 0;
  51         size_t cnt_delimiter = 0;
  52         size_t cnt_chars = 0;
  53
  54         if (len <= llen) {
  55                 return NULL;
  56         }
  57
  58         /* ignore a trailing '.' */
  59         if (str[len - 1] == '.') {
  60                 len -= 1;
  61         }
  62
  63         len -= llen;
  64         if (len >= INET6_ADDRSTRLEN) {
  65                 return NULL;
  66         }
  67         if (len < 2) {
  68                 return NULL;
  69         }
  70
  71         cmp = strncasecmp(&str[len], IPv6_LITERAL_NET, llen);
  72         if (cmp != 0) {
  73                 return NULL;
  74         }
  75
  76         for (i = 0; i < len; i++) {
  77                 if (idx_chars != 0) {
  78                         break;
  79                 }
  80
  81                 switch (str[i]) {
  82                 case '-':
  83                         buf[i] = ':';
  84                         cnt_chars = 0;
  85                         cnt_delimiter += 1;
  86                         break;
  87                 case 's':
  88                         buf[i] = SCOPE_DELIMITER;
  89                         idx_chars += 1;
  90                         break;
  91                 case '0':
  92                 case '1':
  93                 case '2':
  94                 case '3':
  95                 case '4':
  96                 case '5':
  97                 case '6':
  98                 case '7':
  99                 case '8':
 100                 case '9':
 101                 case 'a':
 102                 case 'A':
 103                 case 'b':
 104                 case 'B':
 105                 case 'c':
 106                 case 'C':
 107                 case 'd':
 108                 case 'D':
 109                 case 'e':
 110                 case 'E':
 111                 case 'f':
 112                 case 'F':
 113                         buf[i] = str[i];
 114                         cnt_chars += 1;
 115                         break;
 116                 default:
 117                         return NULL;
 118                 }
 119                 if (cnt_chars > 4) {
 120                         return NULL;
 121                 }
 122                 if (cnt_delimiter > 7) {
 123                         return NULL;
 124                 }
 125         }
 126
 127         if (cnt_delimiter < 2) {
 128                 return NULL;
 129         }
 130
 131         for (; idx_chars != 0 && i < len; i++) {
 132                 switch (str[i]) {
 133                 case SCOPE_DELIMITER:
 134                 case ':':
 135                         return NULL;
 136                 default:
 137                         buf[i] = str[i];
 138                         idx_chars += 1;
 139                         break;
 140                 }
 141         }
 142
 143         if (idx_chars == 1) {
 144                 return NULL;
 145         }
 146
 147         buf[i] = '\0';
 148         *_len = len;
 149         return buf;
 150 }
 151
 152 /**
 153  * Wrap getaddrinfo...
 154  */
 155 bool interpret_string_addr_internal(struct addrinfo **ppres,
 156                                         const char *str, int flags)
 157 {
 158         int ret;
 159         struct addrinfo hints;
 160 #if defined(HAVE_IPV6)
 161         char addr[INET6_ADDRSTRLEN*2] = { 0, };
 162         unsigned int scope_id = 0;
 163         size_t len = strlen(str);
 164 #endif
 165
 166         ZERO_STRUCT(hints);
 167
 168         /* By default make sure it supports TCP. */
 169         hints.ai_socktype = SOCK_STREAM;
 170
 171         /* always try as a numeric host first. This prevents unnecessary name
 172          * lookups, and also ensures we accept IPv6 addresses */
 173         hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST;
 174
 175 #if defined(HAVE_IPV6)
 176         if (len < sizeof(addr)) {
 177                 char *p = NULL;
 178
 179                 p = normalize_ipv6_literal(str, addr, &len);
 180                 if (p != NULL) {
 181                         hints.ai_family = AF_INET6;
 182                         str = p;
 183                 }
 184         }
 185
 186         if (strchr_m(str, ':')) {
 187                 char *p = strchr_m(str, SCOPE_DELIMITER);
 188
 189                 /*
 190                  * Cope with link-local.
 191                  * This is IP:v6:addr%ifname.
 192                  */
 193
 194                 if (p && (p > str) && ((scope_id = if_nametoindex(p+1)) != 0)) {
 195                         /* Length of string we want to copy.
 196                            This is IP:v6:addr (removing the %ifname).
 197                          */
 198                         len = PTR_DIFF(p,str);
 199
 200                         if (len+1 > sizeof(addr)) {
 201                                 /* string+nul too long for array. */
 202                                 return false;
 203                         }
 204                         if (str != addr) {
 205                                 memcpy(addr, str, len);
 206                         }
 207                         addr[len] = '\0';
 208
 209                         str = addr;
 210                 }
 211         }
 212 #endif
 213
 214         ret = getaddrinfo(str, NULL, &hints, ppres);
 215         if (ret == 0) {
 216 #if defined(HAVE_IPV6)
 217                 struct sockaddr_in6 *ps6 = NULL;
 218
 219                 if (scope_id == 0) {
 220                         return true;
 221                 }
 222                 if (ppres == NULL) {
 223                         return true;
 224                 }
 225                 if ((*ppres) == NULL) {
 226                         return true;
 227                 }
 228                 if ((*ppres)->ai_addr->sa_family != AF_INET6) {
 229                         return true;
 230                 }
 231
 232                 ps6 = (struct sockaddr_in6 *)(*ppres)->ai_addr;
 233
 234                 if (IN6_IS_ADDR_LINKLOCAL(&ps6->sin6_addr) &&
 235                                 ps6->sin6_scope_id == 0) {
 236                         ps6->sin6_scope_id = scope_id;
 237                 }
 238 #endif
 239
 240                 return true;
 241         }
 242
 243         hints.ai_flags = flags;
 244
 245         /* Linux man page on getaddrinfo() says port will be
 246            uninitialized when service string is NULL */
 247
 248         ret = getaddrinfo(str, NULL,
 249                         &hints,
 250                         ppres);
 251
 252         if (ret) {
 253                 DEBUG(3, ("interpret_string_addr_internal: "
 254                           "getaddrinfo failed for name %s (flags %d) [%s]\n",
 255                           str, flags, gai_strerror(ret)));
 256                 return false;
 257         }
 258         return true;
 259 }
 260
 261 /*******************************************************************
 262  Map a text hostname or IP address (IPv4 or IPv6) into a
 263  struct sockaddr_storage. Takes a flag which allows it to
 264  prefer an IPv4 address (needed for DC's).
 265 ******************************************************************/
 266
 267 static bool interpret_string_addr_pref(struct sockaddr_storage *pss,
 268                 const char *str,
 269                 int flags,
 270                 bool prefer_ipv4)
 271 {
 272         struct addrinfo *res = NULL;
 273         int int_flags;
 274
 275         zero_sockaddr(pss);
 276
 277         if (flags & AI_NUMERICHOST) {
 278                 int_flags = flags;
 279         } else {
 280                 int_flags = flags|AI_ADDRCONFIG;
 281         }
 282
 283         if (!interpret_string_addr_internal(&res, str, int_flags)) {
 284                 return false;
 285         }
 286         if (!res) {
 287                 return false;
 288         }
 289
 290         if (prefer_ipv4) {
 291                 struct addrinfo *p;
 292
 293                 for (p = res; p; p = p->ai_next) {
 294                         if (p->ai_family == AF_INET) {
 295                                 memcpy(pss, p->ai_addr, p->ai_addrlen);
 296                                 break;
 297                         }
 298                 }
 299                 if (p == NULL) {
 300                         /* Copy the first sockaddr. */
 301                         memcpy(pss, res->ai_addr, res->ai_addrlen);
 302                 }
 303         } else {
 304                 /* Copy the first sockaddr. */
 305                 memcpy(pss, res->ai_addr, res->ai_addrlen);
 306         }
 307
 308         freeaddrinfo(res);
 309         return true;
 310 }
 311
 312 /*******************************************************************
 313  Map a text hostname or IP address (IPv4 or IPv6) into a
 314  struct sockaddr_storage. Address agnostic version.
 315 ******************************************************************/
 316
 317 bool interpret_string_addr(struct sockaddr_storage *pss,
 318                 const char *str,
 319                 int flags)
 320 {
 321         return interpret_string_addr_pref(pss,
 322                                         str,
 323                                         flags,
 324                                         false);
 325 }
 326
 327 /*******************************************************************
 328  Map a text hostname or IP address (IPv4 or IPv6) into a
 329  struct sockaddr_storage. Version that prefers IPv4.
 330 ******************************************************************/
 331
 332 bool interpret_string_addr_prefer_ipv4(struct sockaddr_storage *pss,
 333                 const char *str,
 334                 int flags)
 335 {
 336         return interpret_string_addr_pref(pss,
 337                                         str,
 338                                         flags,
 339                                         true);
 340 }
 341
 342 /**
 343  * Interpret an internet address or name into an IP address in 4 byte form.
 344  * RETURNS IN NETWORK BYTE ORDER (big endian).
 345  */
 346
 347 uint32_t interpret_addr(const char *str)
 348 {
 349         uint32_t ret;
 350
 351         /* If it's in the form of an IP address then
 352          * get the lib to interpret it */
 353         if (is_ipaddress_v4(str)) {
 354                 struct in_addr dest;
 355
 356                 if (inet_pton(AF_INET, str, &dest) <= 0) {
 357                         /* Error - this shouldn't happen ! */
 358                         DEBUG(0,("interpret_addr: inet_pton failed "
 359                                 "host %s\n",
 360                                 str));
 361                         return 0;
 362                 }
 363                 ret = dest.s_addr; /* NETWORK BYTE ORDER ! */
 364         } else {
 365                 /* Otherwise assume it's a network name of some sort and use
 366                         getadddrinfo. */
 367                 struct addrinfo *res = NULL;
 368                 struct addrinfo *res_list = NULL;
 369                 if (!interpret_string_addr_internal(&res_list,
 370                                         str,
 371                                         AI_ADDRCONFIG)) {
 372                         DEBUG(3,("interpret_addr: Unknown host. %s\n",str));
 373                         return 0;
 374                 }
 375
 376                 /* Find the first IPv4 address. */
 377                 for (res = res_list; res; res = res->ai_next) {
 378                         if (res->ai_family != AF_INET) {
 379                                 continue;
 380                         }
 381                         if (res->ai_addr == NULL) {
 382                                 continue;
 383                         }
 384                         break;
 385                 }
 386                 if(res == NULL) {
 387                         DEBUG(3,("interpret_addr: host address is "
 388                                 "invalid for host %s\n",str));
 389                         if (res_list) {
 390                                 freeaddrinfo(res_list);
 391                         }
 392                         return 0;
 393                 }
 394                 memcpy((char *)&ret,
 395                         &((struct sockaddr_in *)res->ai_addr)->sin_addr.s_addr,
 396                         sizeof(ret));
 397                 if (res_list) {
 398                         freeaddrinfo(res_list);
 399                 }
 400         }
 401
 402         /* This is so bogus - all callers need fixing... JRA. */
 403         if (ret == (uint32_t)-1) {
 404                 return 0;
 405         }
 406
 407         return ret;
 408 }
 409
 410 /**
 411  A convenient addition to interpret_addr().
 412 **/
 413 _PUBLIC_ struct in_addr interpret_addr2(const char *str)
 414 {
 415         struct in_addr ret;
 416         uint32_t a = interpret_addr(str);
 417         ret.s_addr = a;
 418         return ret;
 419 }
 420
 421 /**
 422  Check if an IP is the 0.0.0.0.
 423 **/
 424
 425 _PUBLIC_ bool is_zero_ip_v4(struct in_addr ip)
 426 {
 427         return ip.s_addr == 0;
 428 }
 429
 430 /**
 431  Are two IPs on the same subnet?
 432 **/
 433
 434 _PUBLIC_ bool same_net_v4(struct in_addr ip1, struct in_addr ip2, struct in_addr mask)
 435 {
 436         uint32_t net1,net2,nmask;
 437
 438         nmask = ntohl(mask.s_addr);
 439         net1  = ntohl(ip1.s_addr);
 440         net2  = ntohl(ip2.s_addr);
 441
 442         return((net1 & nmask) == (net2 & nmask));
 443 }
 444
 445 /**
 446  * Return true if a string could be an IPv4 address.
 447  */
 448
 449 bool is_ipaddress_v4(const char *str)
 450 {
 451         int ret = -1;
 452         struct in_addr dest;
 453
 454         ret = inet_pton(AF_INET, str, &dest);
 455         if (ret > 0) {
 456                 return true;
 457         }
 458         return false;
 459 }
 460
 461 bool is_ipv6_literal(const char *str)
 462 {
 463 #if defined(HAVE_IPV6)
 464         char buf[INET6_ADDRSTRLEN*2] = { 0, };
 465         size_t len = strlen(str);
 466         char *p = NULL;
 467
 468         if (len >= sizeof(buf)) {
 469                 return false;
 470         }
 471
 472         p = normalize_ipv6_literal(str, buf, &len);
 473         if (p == NULL) {
 474                 return false;
 475         }
 476
 477         return true;
 478 #else
 479         return false;
 480 #endif
 481 }
 482
 483 /**
 484  * Return true if a string could be a IPv6 address.
 485  */
 486
 487 bool is_ipaddress_v6(const char *str)
 488 {
 489 #if defined(HAVE_IPV6)
 490         int ret = -1;
 491         char *p = NULL;
 492         char buf[INET6_ADDRSTRLEN] = { 0, };
 493         size_t len;
 494         const char *addr = str;
 495         const char *idxs = NULL;
 496         unsigned int idx = 0;
 497         struct in6_addr ip6;
 498
 499         p = strchr_m(str, ':');
 500         if (p == NULL) {
 501                 return is_ipv6_literal(str);
 502         }
 503
 504         p = strchr_m(str, SCOPE_DELIMITER);
 505         if (p && (p > str)) {
 506                 len = PTR_DIFF(p, str);
 507                 idxs = p + 1;
 508         } else {
 509                 len = strlen(str);
 510         }
 511
 512         if (len >= sizeof(buf)) {
 513                 return false;
 514         }
 515         if (idxs != NULL) {
 516                 strncpy(buf, str, len);
 517                 addr = buf;
 518         }
 519
 520         /*
 521          * Cope with link-local.
 522          * This is IP:v6:addr%ifidx.
 523          */
 524         if (idxs != NULL) {
 525                 char c;
 526
 527                 ret = sscanf(idxs, "%5u%c", &idx, &c);
 528                 if (ret != 1) {
 529                         idx = 0;
 530                 }
 531
 532                 if (idx > 0 && idx < UINT16_MAX) {
 533                         /* a valid index */
 534                         idxs = NULL;
 535                 }
 536         }
 537
 538         /*
 539          * Cope with link-local.
 540          * This is IP:v6:addr%ifname.
 541          */
 542         if (idxs != NULL) {
 543                 idx = if_nametoindex(idxs);
 544
 545                 if (idx > 0) {
 546                         /* a valid index */
 547                         idxs = NULL;
 548                 }
 549         }
 550
 551         if (idxs != NULL) {
 552                 return false;
 553         }
 554
 555         ret = inet_pton(AF_INET6, addr, &ip6);
 556         if (ret <= 0) {
 557                 return false;
 558         }
 559
 560         return true;
 561 #endif
 562         return false;
 563 }
 564
 565 /**
 566  * Return true if a string could be an IPv4 or IPv6 address.
 567  */
 568
 569 bool is_ipaddress(const char *str)
 570 {
 571         return is_ipaddress_v4(str) || is_ipaddress_v6(str);
 572 }
 573
 574 /**
 575  * Is a sockaddr a broadcast address ?
 576  */
 577
 578 bool is_broadcast_addr(const struct sockaddr *pss)
 579 {
 580 #if defined(HAVE_IPV6)
 581         if (pss->sa_family == AF_INET6) {
 582                 const struct in6_addr *sin6 =
 583                         &((const struct sockaddr_in6 *)pss)->sin6_addr;
 584                 return IN6_IS_ADDR_MULTICAST(sin6);
 585         }
 586 #endif
 587         if (pss->sa_family == AF_INET) {
 588                 uint32_t addr =
 589                 ntohl(((const struct sockaddr_in *)pss)->sin_addr.s_addr);
 590                 return addr == INADDR_BROADCAST;
 591         }
 592         return false;
 593 }
 594
 595 /**
 596  * Check if an IPv7 is 127.0.0.1
 597  */
 598 bool is_loopback_ip_v4(struct in_addr ip)
 599 {
 600         struct in_addr a;
 601         a.s_addr = htonl(INADDR_LOOPBACK);
 602         return(ip.s_addr == a.s_addr);
 603 }
 604
 605 /**
 606  * Check if a struct sockaddr is the loopback address.
 607  */
 608 bool is_loopback_addr(const struct sockaddr *pss)
 609 {
 610 #if defined(HAVE_IPV6)
 611         if (pss->sa_family == AF_INET6) {
 612                 const struct in6_addr *pin6 =
 613                         &((const struct sockaddr_in6 *)pss)->sin6_addr;
 614                 return IN6_IS_ADDR_LOOPBACK(pin6);
 615         }
 616 #endif
 617         if (pss->sa_family == AF_INET) {
 618                 const struct in_addr *pin = &((const struct sockaddr_in *)pss)->sin_addr;
 619                 return is_loopback_ip_v4(*pin);
 620         }
 621         return false;
 622 }
 623
 624 /**
 625  * Check if a struct sockaddr has an unspecified address.
 626  */
 627 bool is_zero_addr(const struct sockaddr_storage *pss)
 628 {
 629 #if defined(HAVE_IPV6)
 630         if (pss->ss_family == AF_INET6) {
 631                 const struct in6_addr *pin6 =
 632                         &((const struct sockaddr_in6 *)pss)->sin6_addr;
 633                 return IN6_IS_ADDR_UNSPECIFIED(pin6);
 634         }
 635 #endif
 636         if (pss->ss_family == AF_INET) {
 637                 const struct in_addr *pin = &((const struct sockaddr_in *)pss)->sin_addr;
 638                 return is_zero_ip_v4(*pin);
 639         }
 640         return false;
 641 }
 642
 643 /**
 644  * Set an IP to 0.0.0.0.
 645  */
 646 void zero_ip_v4(struct in_addr *ip)
 647 {
 648         ZERO_STRUCTP(ip);
 649 }
 650
 651 bool is_linklocal_addr(const struct sockaddr_storage *pss)
 652 {
 653 #ifdef HAVE_IPV6
 654         if (pss->ss_family == AF_INET6) {
 655                 const struct in6_addr *pin6 =
 656                         &((const struct sockaddr_in6 *)pss)->sin6_addr;
 657                 return IN6_IS_ADDR_LINKLOCAL(pin6);
 658         }
 659 #endif
 660         if (pss->ss_family == AF_INET) {
 661                 const struct in_addr *pin =
 662                         &((const struct sockaddr_in *)pss)->sin_addr;
 663                 struct in_addr ll_addr;
 664                 struct in_addr mask_addr;
 665
 666                 /* 169.254.0.0/16, is link local, see RFC 3927 */
 667                 ll_addr.s_addr = 0xa9fe0000;
 668                 mask_addr.s_addr = 0xffff0000;
 669                 return same_net_v4(*pin, ll_addr, mask_addr);
 670         }
 671         return false;
 672 }
 673
 674 /**
 675  * Convert an IPv4 struct in_addr to a struct sockaddr_storage.
 676  */
 677 void in_addr_to_sockaddr_storage(struct sockaddr_storage *ss,
 678                 struct in_addr ip)
 679 {
 680         struct sockaddr_in *sa = (struct sockaddr_in *)ss;
 681         ZERO_STRUCTP(ss);
 682         sa->sin_family = AF_INET;
 683         sa->sin_addr = ip;
 684 }
 685
 686 #if defined(HAVE_IPV6)
 687 /**
 688  * Convert an IPv6 struct in_addr to a struct sockaddr_storage.
 689  */
 690 void in6_addr_to_sockaddr_storage(struct sockaddr_storage *ss,
 691                 struct in6_addr ip)
 692 {
 693         struct sockaddr_in6 *sa = (struct sockaddr_in6 *)ss;
 694         memset(ss, '\0', sizeof(*ss));
 695         sa->sin6_family = AF_INET6;
 696         sa->sin6_addr = ip;
 697 }
 698 #endif
 699
 700 /**
 701  * Are two IPs on the same subnet?
 702  */
 703 bool same_net(const struct sockaddr *ip1,
 704                 const struct sockaddr *ip2,
 705                 const struct sockaddr *mask)
 706 {
 707         if (ip1->sa_family != ip2->sa_family) {
 708                 /* Never on the same net. */
 709                 return false;
 710         }
 711
 712 #if defined(HAVE_IPV6)
 713         if (ip1->sa_family == AF_INET6) {
 714                 struct sockaddr_in6 ip1_6 = *(const struct sockaddr_in6 *)ip1;
 715                 struct sockaddr_in6 ip2_6 = *(const struct sockaddr_in6 *)ip2;
 716                 struct sockaddr_in6 mask_6 = *(const struct sockaddr_in6 *)mask;
 717                 char *p1 = (char *)&ip1_6.sin6_addr;
 718                 char *p2 = (char *)&ip2_6.sin6_addr;
 719                 char *m = (char *)&mask_6.sin6_addr;
 720                 int i;
 721
 722                 for (i = 0; i < sizeof(struct in6_addr); i++) {
 723                         *p1++ &= *m;
 724                         *p2++ &= *m;
 725                         m++;
 726                 }
 727                 return (memcmp(&ip1_6.sin6_addr,
 728                                 &ip2_6.sin6_addr,
 729                                 sizeof(struct in6_addr)) == 0);
 730         }
 731 #endif
 732         if (ip1->sa_family == AF_INET) {
 733                 return same_net_v4(((const struct sockaddr_in *)ip1)->sin_addr,
 734                                 ((const struct sockaddr_in *)ip2)->sin_addr,
 735                                 ((const struct sockaddr_in *)mask)->sin_addr);
 736         }
 737         return false;
 738 }
 739
 740 /**
 741  * Are two sockaddr 's the same family and address ? Ignore port etc.
 742  */
 743
 744 bool sockaddr_equal(const struct sockaddr *ip1,
 745                 const struct sockaddr *ip2)
 746 {
 747         if (ip1->sa_family != ip2->sa_family) {
 748                 /* Never the same. */
 749                 return false;
 750         }
 751
 752 #if defined(HAVE_IPV6)
 753         if (ip1->sa_family == AF_INET6) {
 754                 return (memcmp(&((const struct sockaddr_in6 *)ip1)->sin6_addr,
 755                                 &((const struct sockaddr_in6 *)ip2)->sin6_addr,
 756                                 sizeof(struct in6_addr)) == 0);
 757         }
 758 #endif
 759         if (ip1->sa_family == AF_INET) {
 760                 return (memcmp(&((const struct sockaddr_in *)ip1)->sin_addr,
 761                                 &((const struct sockaddr_in *)ip2)->sin_addr,
 762                                 sizeof(struct in_addr)) == 0);
 763         }
 764         return false;
 765 }
 766
 767 /**
 768  * Is an IP address the INADDR_ANY or in6addr_any value ?
 769  */
 770 bool is_address_any(const struct sockaddr *psa)
 771 {
 772 #if defined(HAVE_IPV6)
 773         if (psa->sa_family == AF_INET6) {
 774                 const struct sockaddr_in6 *si6 = (const struct sockaddr_in6 *)psa;
 775                 if (memcmp(&in6addr_any,
 776                                 &si6->sin6_addr,
 777                                 sizeof(in6addr_any)) == 0) {
 778                         return true;
 779                 }
 780                 return false;
 781         }
 782 #endif
 783         if (psa->sa_family == AF_INET) {
 784                 const struct sockaddr_in *si = (const struct sockaddr_in *)psa;
 785                 if (si->sin_addr.s_addr == INADDR_ANY) {
 786                         return true;
 787                 }
 788                 return false;
 789         }
 790         return false;
 791 }
 792
 793 void set_sockaddr_port(struct sockaddr *psa, uint16_t port)
 794 {
 795 #if defined(HAVE_IPV6)
 796         if (psa->sa_family == AF_INET6) {
 797                 ((struct sockaddr_in6 *)psa)->sin6_port = htons(port);
 798         }
 799 #endif
 800         if (psa->sa_family == AF_INET) {
 801                 ((struct sockaddr_in *)psa)->sin_port = htons(port);
 802         }
 803 }
 804
 805
 806 /****************************************************************************
 807  Get a port number in host byte order from a sockaddr_storage.
 808 ****************************************************************************/
 809
 810 uint16_t get_sockaddr_port(const struct sockaddr_storage *pss)
 811 {
 812         uint16_t port = 0;
 813
 814         if (pss->ss_family != AF_INET) {
 815 #if defined(HAVE_IPV6)
 816                 /* IPv6 */
 817                 const struct sockaddr_in6 *sa6 =
 818                         (const struct sockaddr_in6 *)pss;
 819                 port = ntohs(sa6->sin6_port);
 820 #endif
 821         } else {
 822                 const struct sockaddr_in *sa =
 823                         (const struct sockaddr_in *)pss;
 824                 port = ntohs(sa->sin_port);
 825         }
 826         return port;
 827 }
 828
 829 /****************************************************************************
 830  Print out an IPv4 or IPv6 address from a struct sockaddr_storage.
 831 ****************************************************************************/
 832
 833 char *print_sockaddr_len(char *dest,
 834                          size_t destlen,
 835                         const struct sockaddr *psa,
 836                         socklen_t psalen)
 837 {
 838         if (destlen > 0) {
 839                 dest[0] = '\0';
 840         }
 841         (void)sys_getnameinfo(psa,
 842                         psalen,
 843                         dest, destlen,
 844                         NULL, 0,
 845                         NI_NUMERICHOST);
 846         return dest;
 847 }
 848
 849 /****************************************************************************
 850  Print out an IPv4 or IPv6 address from a struct sockaddr_storage.
 851 ****************************************************************************/
 852
 853 char *print_sockaddr(char *dest,
 854                         size_t destlen,
 855                         const struct sockaddr_storage *psa)
 856 {
 857         return print_sockaddr_len(dest, destlen, (const struct sockaddr *)psa,
 858                         sizeof(struct sockaddr_storage));
 859 }
 860
 861 /****************************************************************************
 862  Print out a canonical IPv4 or IPv6 address from a struct sockaddr_storage.
 863 ****************************************************************************/
 864
 865 char *print_canonical_sockaddr(TALLOC_CTX *ctx,
 866                         const struct sockaddr_storage *pss)
 867 {
 868         char addr[INET6_ADDRSTRLEN];
 869         char *dest = NULL;
 870         int ret;
 871
 872         /* Linux getnameinfo() man pages says port is unitialized if
 873            service name is NULL. */
 874
 875         ret = sys_getnameinfo((const struct sockaddr *)pss,
 876                         sizeof(struct sockaddr_storage),
 877                         addr, sizeof(addr),
 878                         NULL, 0,
 879                         NI_NUMERICHOST);
 880         if (ret != 0) {
 881                 return NULL;
 882         }
 883
 884         if (pss->ss_family != AF_INET) {
 885 #if defined(HAVE_IPV6)
 886                 dest = talloc_asprintf(ctx, "[%s]", addr);
 887 #else
 888                 return NULL;
 889 #endif
 890         } else {
 891                 dest = talloc_asprintf(ctx, "%s", addr);
 892         }
 893
 894         return dest;
 895 }
 896
 897 /****************************************************************************
 898  Return the port number we've bound to on a socket.
 899 ****************************************************************************/
 900
 901 int get_socket_port(int fd)
 902 {
 903         struct sockaddr_storage sa;
 904         socklen_t length = sizeof(sa);
 905
 906         if (fd == -1) {
 907                 return -1;
 908         }
 909
 910         if (getsockname(fd, (struct sockaddr *)&sa, &length) < 0) {
 911                 int level = (errno == ENOTCONN) ? 2 : 0;
 912                 DEBUG(level, ("getsockname failed. Error was %s\n",
 913                                strerror(errno)));
 914                 return -1;
 915         }
 916
 917 #if defined(HAVE_IPV6)
 918         if (sa.ss_family == AF_INET6) {
 919                 struct sockaddr_in6 *sa_in6 = (struct sockaddr_in6 *)&sa;
 920                 return ntohs(sa_in6->sin6_port);
 921         }
 922 #endif
 923         if (sa.ss_family == AF_INET) {
 924                 struct sockaddr_in *sa_in = (struct sockaddr_in *)&sa;
 925                 return ntohs(sa_in->sin_port);
 926         }
 927         return -1;
 928 }
 929
 930 /****************************************************************************
 931  Return the string of an IP address (IPv4 or IPv6).
 932 ****************************************************************************/
 933
 934 static const char *get_socket_addr(int fd, char *addr_buf, size_t addr_len)
 935 {
 936         struct sockaddr_storage sa;
 937         socklen_t length = sizeof(sa);
 938
 939         /* Ok, returning a hard coded IPv4 address
 940          * is bogus, but it's just as bogus as a
 941          * zero IPv6 address. No good choice here.
 942          */
 943
 944         if (strlcpy(addr_buf, "0.0.0.0", addr_len) >= addr_len) {
 945                 /* Truncate ! */
 946                 return NULL;
 947         }
 948
 949         if (fd == -1) {
 950                 return addr_buf;
 951         }
 952
 953         if (getsockname(fd, (struct sockaddr *)&sa, &length) < 0) {
 954                 DEBUG(0,("getsockname failed. Error was %s\n",
 955                         strerror(errno) ));
 956                 return addr_buf;
 957         }
 958
 959         return print_sockaddr_len(addr_buf, addr_len, (struct sockaddr *)&sa, length);
 960 }
 961
 962 const char *client_socket_addr(int fd, char *addr, size_t addr_len)
 963 {
 964         return get_socket_addr(fd, addr, addr_len);
 965 }
 966
 967
 968 enum SOCK_OPT_TYPES {OPT_BOOL,OPT_INT,OPT_ON};
 969
 970 typedef struct smb_socket_option {
 971         const char *name;
 972         int level;
 973         int option;
 974         int value;
 975         int opttype;
 976 } smb_socket_option;
 977
 978 static const smb_socket_option socket_options[] = {
 979   {"SO_KEEPALIVE", SOL_SOCKET, SO_KEEPALIVE, 0, OPT_BOOL},
 980   {"SO_REUSEADDR", SOL_SOCKET, SO_REUSEADDR, 0, OPT_BOOL},
 981   {"SO_BROADCAST", SOL_SOCKET, SO_BROADCAST, 0, OPT_BOOL},
 982 #ifdef TCP_NODELAY
 983   {"TCP_NODELAY", IPPROTO_TCP, TCP_NODELAY, 0, OPT_BOOL},
 984 #endif
 985 #ifdef TCP_KEEPCNT
 986   {"TCP_KEEPCNT", IPPROTO_TCP, TCP_KEEPCNT, 0, OPT_INT},
 987 #endif
 988 #ifdef TCP_KEEPIDLE
 989   {"TCP_KEEPIDLE", IPPROTO_TCP, TCP_KEEPIDLE, 0, OPT_INT},
 990 #endif
 991 #ifdef TCP_KEEPINTVL
 992   {"TCP_KEEPINTVL", IPPROTO_TCP, TCP_KEEPINTVL, 0, OPT_INT},
 993 #endif
 994 #ifdef IPTOS_LOWDELAY
 995   {"IPTOS_LOWDELAY", IPPROTO_IP, IP_TOS, IPTOS_LOWDELAY, OPT_ON},
 996 #endif
 997 #ifdef IPTOS_THROUGHPUT
 998   {"IPTOS_THROUGHPUT", IPPROTO_IP, IP_TOS, IPTOS_THROUGHPUT, OPT_ON},
 999 #endif
1000 #ifdef SO_REUSEPORT
1001   {"SO_REUSEPORT", SOL_SOCKET, SO_REUSEPORT, 0, OPT_BOOL},
1002 #endif
1003 #ifdef SO_SNDBUF
1004   {"SO_SNDBUF", SOL_SOCKET, SO_SNDBUF, 0, OPT_INT},
1005 #endif
1006 #ifdef SO_RCVBUF
1007   {"SO_RCVBUF", SOL_SOCKET, SO_RCVBUF, 0, OPT_INT},
1008 #endif
1009 #ifdef SO_SNDLOWAT
1010   {"SO_SNDLOWAT", SOL_SOCKET, SO_SNDLOWAT, 0, OPT_INT},
1011 #endif
1012 #ifdef SO_RCVLOWAT
1013   {"SO_RCVLOWAT", SOL_SOCKET, SO_RCVLOWAT, 0, OPT_INT},
1014 #endif
1015 #ifdef SO_SNDTIMEO
1016   {"SO_SNDTIMEO", SOL_SOCKET, SO_SNDTIMEO, 0, OPT_INT},
1017 #endif
1018 #ifdef SO_RCVTIMEO
1019   {"SO_RCVTIMEO", SOL_SOCKET, SO_RCVTIMEO, 0, OPT_INT},
1020 #endif
1021 #ifdef TCP_FASTACK
1022   {"TCP_FASTACK", IPPROTO_TCP, TCP_FASTACK, 0, OPT_INT},
1023 #endif
1024 #ifdef TCP_QUICKACK
1025   {"TCP_QUICKACK", IPPROTO_TCP, TCP_QUICKACK, 0, OPT_BOOL},
1026 #endif
1027 #ifdef TCP_NODELAYACK
1028   {"TCP_NODELAYACK", IPPROTO_TCP, TCP_NODELAYACK, 0, OPT_BOOL},
1029 #endif
1030 #ifdef TCP_KEEPALIVE_THRESHOLD
1031   {"TCP_KEEPALIVE_THRESHOLD", IPPROTO_TCP, TCP_KEEPALIVE_THRESHOLD, 0, OPT_INT},
1032 #endif
1033 #ifdef TCP_KEEPALIVE_ABORT_THRESHOLD
1034   {"TCP_KEEPALIVE_ABORT_THRESHOLD", IPPROTO_TCP, TCP_KEEPALIVE_ABORT_THRESHOLD, 0, OPT_INT},
1035 #endif
1036 #ifdef TCP_DEFER_ACCEPT
1037   {"TCP_DEFER_ACCEPT", IPPROTO_TCP, TCP_DEFER_ACCEPT, 0, OPT_INT},
1038 #endif
1039   {NULL,0,0,0,0}};
1040
1041 /****************************************************************************
1042  Print socket options.
1043 ****************************************************************************/
1044
1045 static void print_socket_options(int s)
1046 {
1047         int value;
1048         socklen_t vlen = 4;
1049         const smb_socket_option *p = &socket_options[0];
1050
1051         /* wrapped in if statement to prevent streams
1052          * leak in SCO Openserver 5.0 */
1053         /* reported on samba-technical  --jerry */
1054         if ( DEBUGLEVEL >= 5 ) {
1055                 DEBUG(5,("Socket options:\n"));
1056                 for (; p->name != NULL; p++) {
1057                         if (getsockopt(s, p->level, p->option,
1058                                                 (void *)&value, &vlen) == -1) {
1059                                 DEBUGADD(5,("\tCould not test socket option %s.\n",
1060                                                         p->name));
1061                         } else {
1062                                 DEBUGADD(5,("\t%s = %d\n",
1063                                                         p->name,value));
1064                         }
1065                 }
1066         }
1067  }
1068
1069 /****************************************************************************
1070  Set user socket options.
1071 ****************************************************************************/
1072
1073 void set_socket_options(int fd, const char *options)
1074 {
1075         TALLOC_CTX *ctx = talloc_new(NULL);
1076         char *tok;
1077
1078         while (next_token_talloc(ctx, &options, &tok," \t,")) {
1079                 int ret=0,i;
1080                 int value = 1;
1081                 char *p;
1082                 bool got_value = false;
1083
1084                 if ((p = strchr_m(tok,'='))) {
1085                         *p = 0;
1086                         value = atoi(p+1);
1087                         got_value = true;
1088                 }
1089
1090                 for (i=0;socket_options[i].name;i++)
1091                         if (strequal(socket_options[i].name,tok))
1092                                 break;
1093
1094                 if (!socket_options[i].name) {
1095                         DEBUG(0,("Unknown socket option %s\n",tok));
1096                         continue;
1097                 }
1098
1099                 switch (socket_options[i].opttype) {
1100                 case OPT_BOOL:
1101                 case OPT_INT:
1102                         ret = setsockopt(fd,socket_options[i].level,
1103                                         socket_options[i].option,
1104                                         (char *)&value,sizeof(int));
1105                         break;
1106
1107                 case OPT_ON:
1108                         if (got_value)
1109                                 DEBUG(0,("syntax error - %s "
1110                                         "does not take a value\n",tok));
1111
1112                         {
1113                                 int on = socket_options[i].value;
1114                                 ret = setsockopt(fd,socket_options[i].level,
1115                                         socket_options[i].option,
1116                                         (char *)&on,sizeof(int));
1117                         }
1118                         break;
1119                 }
1120
1121                 if (ret != 0) {
1122                         /* be aware that some systems like Solaris return
1123                          * EINVAL to a setsockopt() call when the client
1124                          * sent a RST previously - no need to worry */
1125                         DEBUG(2,("Failed to set socket option %s (Error %s)\n",
1126                                 tok, strerror(errno) ));
1127                 }
1128         }
1129
1130         TALLOC_FREE(ctx);
1131         print_socket_options(fd);
1132 }