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         ZERO_STRUCTP(pss);
  40         /* Ensure we're at least a valid sockaddr-storage. */
  41         pss->ss_family = AF_INET;
  42 }
  43
  44 /**
  45  * Wrap getaddrinfo...
  46  */
  47 bool interpret_string_addr_internal(struct addrinfo **ppres,
  48                                         const char *str, int flags)
  49 {
  50         int ret;
  51         struct addrinfo hints;
  52
  53         ZERO_STRUCT(hints);
  54
  55         /* By default make sure it supports TCP. */
  56         hints.ai_socktype = SOCK_STREAM;
  57
  58         /* always try as a numeric host first. This prevents unnecessary name
  59          * lookups, and also ensures we accept IPv6 addresses */
  60         hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST;
  61         ret = getaddrinfo(str, NULL, &hints, ppres);
  62         if (ret == 0) {
  63                 return true;
  64         }
  65
  66         hints.ai_flags = flags;
  67
  68         /* Linux man page on getaddrinfo() says port will be
  69            uninitialized when service string is NULL */
  70
  71         ret = getaddrinfo(str, NULL,
  72                         &hints,
  73                         ppres);
  74
  75         if (ret) {
  76                 DEBUG(3, ("interpret_string_addr_internal: "
  77                           "getaddrinfo failed for name %s (flags %d) [%s]\n",
  78                           str, flags, gai_strerror(ret)));
  79                 return false;
  80         }
  81         return true;
  82 }
  83
  84 /*******************************************************************
  85  Map a text hostname or IP address (IPv4 or IPv6) into a
  86  struct sockaddr_storage. Takes a flag which allows it to
  87  prefer an IPv4 address (needed for DC's).
  88 ******************************************************************/
  89
  90 static bool interpret_string_addr_pref(struct sockaddr_storage *pss,
  91                 const char *str,
  92                 int flags,
  93                 bool prefer_ipv4)
  94 {
  95         struct addrinfo *res = NULL;
  96 #if defined(HAVE_IPV6)
  97         char addr[INET6_ADDRSTRLEN];
  98         unsigned int scope_id = 0;
  99         int int_flags;
 100
 101         if (strchr_m(str, ':')) {
 102                 char *p = strchr_m(str, '%');
 103
 104                 /*
 105                  * Cope with link-local.
 106                  * This is IP:v6:addr%ifname.
 107                  */
 108
 109                 if (p && (p > str) && ((scope_id = if_nametoindex(p+1)) != 0)) {
 110                         strlcpy(addr, str,
 111                                 MIN(PTR_DIFF(p,str)+1,
 112                                         sizeof(addr)));
 113                         str = addr;
 114                 }
 115         }
 116 #endif
 117
 118         zero_sockaddr(pss);
 119
 120         if (flags & AI_NUMERICHOST) {
 121                 int_flags = flags;
 122         } else {
 123                 int_flags = flags|AI_ADDRCONFIG;
 124         }
 125
 126         if (!interpret_string_addr_internal(&res, str, int_flags)) {
 127                 return false;
 128         }
 129         if (!res) {
 130                 return false;
 131         }
 132
 133         if (prefer_ipv4) {
 134                 struct addrinfo *p;
 135
 136                 for (p = res; p; p = p->ai_next) {
 137                         if (p->ai_family == AF_INET) {
 138                                 memcpy(pss, p->ai_addr, p->ai_addrlen);
 139                                 break;
 140                         }
 141                 }
 142                 if (p == NULL) {
 143                         /* Copy the first sockaddr. */
 144                         memcpy(pss, res->ai_addr, res->ai_addrlen);
 145                 }
 146         } else {
 147                 /* Copy the first sockaddr. */
 148                 memcpy(pss, res->ai_addr, res->ai_addrlen);
 149         }
 150
 151 #if defined(HAVE_IPV6)
 152         if (pss->ss_family == AF_INET6 && scope_id) {
 153                 struct sockaddr_in6 *ps6 = (struct sockaddr_in6 *)pss;
 154                 if (IN6_IS_ADDR_LINKLOCAL(&ps6->sin6_addr) &&
 155                                 ps6->sin6_scope_id == 0) {
 156                         ps6->sin6_scope_id = scope_id;
 157                 }
 158         }
 159 #endif
 160
 161         freeaddrinfo(res);
 162         return true;
 163 }
 164
 165 /*******************************************************************
 166  Map a text hostname or IP address (IPv4 or IPv6) into a
 167  struct sockaddr_storage. Address agnostic version.
 168 ******************************************************************/
 169
 170 bool interpret_string_addr(struct sockaddr_storage *pss,
 171                 const char *str,
 172                 int flags)
 173 {
 174         return interpret_string_addr_pref(pss,
 175                                         str,
 176                                         flags,
 177                                         false);
 178 }
 179
 180 /*******************************************************************
 181  Map a text hostname or IP address (IPv4 or IPv6) into a
 182  struct sockaddr_storage. Version that prefers IPv4.
 183 ******************************************************************/
 184
 185 bool interpret_string_addr_prefer_ipv4(struct sockaddr_storage *pss,
 186                 const char *str,
 187                 int flags)
 188 {
 189         return interpret_string_addr_pref(pss,
 190                                         str,
 191                                         flags,
 192                                         true);
 193 }
 194
 195 /**
 196  * Interpret an internet address or name into an IP address in 4 byte form.
 197  * RETURNS IN NETWORK BYTE ORDER (big endian).
 198  */
 199
 200 uint32_t interpret_addr(const char *str)
 201 {
 202         uint32_t ret;
 203
 204         /* If it's in the form of an IP address then
 205          * get the lib to interpret it */
 206         if (is_ipaddress_v4(str)) {
 207                 struct in_addr dest;
 208
 209                 if (inet_pton(AF_INET, str, &dest) <= 0) {
 210                         /* Error - this shouldn't happen ! */
 211                         DEBUG(0,("interpret_addr: inet_pton failed "
 212                                 "host %s\n",
 213                                 str));
 214                         return 0;
 215                 }
 216                 ret = dest.s_addr; /* NETWORK BYTE ORDER ! */
 217         } else {
 218                 /* Otherwise assume it's a network name of some sort and use
 219                         getadddrinfo. */
 220                 struct addrinfo *res = NULL;
 221                 struct addrinfo *res_list = NULL;
 222                 if (!interpret_string_addr_internal(&res_list,
 223                                         str,
 224                                         AI_ADDRCONFIG)) {
 225                         DEBUG(3,("interpret_addr: Unknown host. %s\n",str));
 226                         return 0;
 227                 }
 228
 229                 /* Find the first IPv4 address. */
 230                 for (res = res_list; res; res = res->ai_next) {
 231                         if (res->ai_family != AF_INET) {
 232                                 continue;
 233                         }
 234                         if (res->ai_addr == NULL) {
 235                                 continue;
 236                         }
 237                         break;
 238                 }
 239                 if(res == NULL) {
 240                         DEBUG(3,("interpret_addr: host address is "
 241                                 "invalid for host %s\n",str));
 242                         if (res_list) {
 243                                 freeaddrinfo(res_list);
 244                         }
 245                         return 0;
 246                 }
 247                 memcpy((char *)&ret,
 248                         &((struct sockaddr_in *)res->ai_addr)->sin_addr.s_addr,
 249                         sizeof(ret));
 250                 if (res_list) {
 251                         freeaddrinfo(res_list);
 252                 }
 253         }
 254
 255         /* This is so bogus - all callers need fixing... JRA. */
 256         if (ret == (uint32_t)-1) {
 257                 return 0;
 258         }
 259
 260         return ret;
 261 }
 262
 263 /**
 264  A convenient addition to interpret_addr().
 265 **/
 266 _PUBLIC_ struct in_addr interpret_addr2(const char *str)
 267 {
 268         struct in_addr ret;
 269         uint32_t a = interpret_addr(str);
 270         ret.s_addr = a;
 271         return ret;
 272 }
 273
 274 /**
 275  Check if an IP is the 0.0.0.0.
 276 **/
 277
 278 _PUBLIC_ bool is_zero_ip_v4(struct in_addr ip)
 279 {
 280         return ip.s_addr == 0;
 281 }
 282
 283 /**
 284  Are two IPs on the same subnet?
 285 **/
 286
 287 _PUBLIC_ bool same_net_v4(struct in_addr ip1, struct in_addr ip2, struct in_addr mask)
 288 {
 289         uint32_t net1,net2,nmask;
 290
 291         nmask = ntohl(mask.s_addr);
 292         net1  = ntohl(ip1.s_addr);
 293         net2  = ntohl(ip2.s_addr);
 294
 295         return((net1 & nmask) == (net2 & nmask));
 296 }
 297
 298 /**
 299  * Return true if a string could be an IPv4 address.
 300  */
 301
 302 bool is_ipaddress_v4(const char *str)
 303 {
 304         int ret = -1;
 305         struct in_addr dest;
 306
 307         ret = inet_pton(AF_INET, str, &dest);
 308         if (ret > 0) {
 309                 return true;
 310         }
 311         return false;
 312 }
 313
 314 /**
 315  * Return true if a string could be a IPv6 address.
 316  */
 317
 318 bool is_ipaddress_v6(const char *str)
 319 {
 320 #if defined(HAVE_IPV6)
 321         int ret = -1;
 322
 323         if (strchr_m(str, ':')) {
 324                 char addr[INET6_ADDRSTRLEN];
 325                 struct in6_addr dest6;
 326                 const char *sp = str;
 327                 char *p = strchr_m(str, '%');
 328
 329                 /*
 330                  * Cope with link-local.
 331                  * This is IP:v6:addr%ifname.
 332                  */
 333
 334                 if (p && (p > str) && (if_nametoindex(p+1) != 0)) {
 335                         strlcpy(addr, str,
 336                                 MIN(PTR_DIFF(p,str)+1,
 337                                         sizeof(addr)));
 338                         sp = addr;
 339                 }
 340                 ret = inet_pton(AF_INET6, sp, &dest6);
 341                 if (ret > 0) {
 342                         return true;
 343                 }
 344         }
 345 #endif
 346         return false;
 347 }
 348
 349 /**
 350  * Return true if a string could be an IPv4 or IPv6 address.
 351  */
 352
 353 bool is_ipaddress(const char *str)
 354 {
 355         return is_ipaddress_v4(str) || is_ipaddress_v6(str);
 356 }
 357
 358 /**
 359  * Is a sockaddr a broadcast address ?
 360  */
 361
 362 bool is_broadcast_addr(const struct sockaddr *pss)
 363 {
 364 #if defined(HAVE_IPV6)
 365         if (pss->sa_family == AF_INET6) {
 366                 const struct in6_addr *sin6 =
 367                         &((const struct sockaddr_in6 *)pss)->sin6_addr;
 368                 return IN6_IS_ADDR_MULTICAST(sin6);
 369         }
 370 #endif
 371         if (pss->sa_family == AF_INET) {
 372                 uint32_t addr =
 373                 ntohl(((const struct sockaddr_in *)pss)->sin_addr.s_addr);
 374                 return addr == INADDR_BROADCAST;
 375         }
 376         return false;
 377 }
 378
 379 /**
 380  * Check if an IPv7 is 127.0.0.1
 381  */
 382 bool is_loopback_ip_v4(struct in_addr ip)
 383 {
 384         struct in_addr a;
 385         a.s_addr = htonl(INADDR_LOOPBACK);
 386         return(ip.s_addr == a.s_addr);
 387 }
 388
 389 /**
 390  * Check if a struct sockaddr is the loopback address.
 391  */
 392 bool is_loopback_addr(const struct sockaddr *pss)
 393 {
 394 #if defined(HAVE_IPV6)
 395         if (pss->sa_family == AF_INET6) {
 396                 const struct in6_addr *pin6 =
 397                         &((const struct sockaddr_in6 *)pss)->sin6_addr;
 398                 return IN6_IS_ADDR_LOOPBACK(pin6);
 399         }
 400 #endif
 401         if (pss->sa_family == AF_INET) {
 402                 const struct in_addr *pin = &((const struct sockaddr_in *)pss)->sin_addr;
 403                 return is_loopback_ip_v4(*pin);
 404         }
 405         return false;
 406 }
 407
 408 /**
 409  * Check if a struct sockaddr has an unspecified address.
 410  */
 411 bool is_zero_addr(const struct sockaddr_storage *pss)
 412 {
 413 #if defined(HAVE_IPV6)
 414         if (pss->ss_family == AF_INET6) {
 415                 const struct in6_addr *pin6 =
 416                         &((const struct sockaddr_in6 *)pss)->sin6_addr;
 417                 return IN6_IS_ADDR_UNSPECIFIED(pin6);
 418         }
 419 #endif
 420         if (pss->ss_family == AF_INET) {
 421                 const struct in_addr *pin = &((const struct sockaddr_in *)pss)->sin_addr;
 422                 return is_zero_ip_v4(*pin);
 423         }
 424         return false;
 425 }
 426
 427 /**
 428  * Set an IP to 0.0.0.0.
 429  */
 430 void zero_ip_v4(struct in_addr *ip)
 431 {
 432         ZERO_STRUCTP(ip);
 433 }
 434
 435 bool is_linklocal_addr(const struct sockaddr_storage *pss)
 436 {
 437 #ifdef HAVE_IPV6
 438         if (pss->ss_family == AF_INET6) {
 439                 const struct in6_addr *pin6 =
 440                         &((const struct sockaddr_in6 *)pss)->sin6_addr;
 441                 return IN6_IS_ADDR_LINKLOCAL(pin6);
 442         }
 443 #endif
 444         if (pss->ss_family == AF_INET) {
 445                 const struct in_addr *pin =
 446                         &((const struct sockaddr_in *)pss)->sin_addr;
 447                 struct in_addr ll_addr;
 448                 struct in_addr mask_addr;
 449
 450                 /* 169.254.0.0/16, is link local, see RFC 3927 */
 451                 ll_addr.s_addr = 0xa9fe0000;
 452                 mask_addr.s_addr = 0xffff0000;
 453                 return same_net_v4(*pin, ll_addr, mask_addr);
 454         }
 455         return false;
 456 }
 457
 458 /**
 459  * Convert an IPv4 struct in_addr to a struct sockaddr_storage.
 460  */
 461 void in_addr_to_sockaddr_storage(struct sockaddr_storage *ss,
 462                 struct in_addr ip)
 463 {
 464         struct sockaddr_in *sa = (struct sockaddr_in *)ss;
 465         ZERO_STRUCTP(ss);
 466         sa->sin_family = AF_INET;
 467         sa->sin_addr = ip;
 468 }
 469
 470 #if defined(HAVE_IPV6)
 471 /**
 472  * Convert an IPv6 struct in_addr to a struct sockaddr_storage.
 473  */
 474 void in6_addr_to_sockaddr_storage(struct sockaddr_storage *ss,
 475                 struct in6_addr ip)
 476 {
 477         struct sockaddr_in6 *sa = (struct sockaddr_in6 *)ss;
 478         memset(ss, '\0', sizeof(*ss));
 479         sa->sin6_family = AF_INET6;
 480         sa->sin6_addr = ip;
 481 }
 482 #endif
 483
 484 /**
 485  * Are two IPs on the same subnet?
 486  */
 487 bool same_net(const struct sockaddr *ip1,
 488                 const struct sockaddr *ip2,
 489                 const struct sockaddr *mask)
 490 {
 491         if (ip1->sa_family != ip2->sa_family) {
 492                 /* Never on the same net. */
 493                 return false;
 494         }
 495
 496 #if defined(HAVE_IPV6)
 497         if (ip1->sa_family == AF_INET6) {
 498                 struct sockaddr_in6 ip1_6 = *(const struct sockaddr_in6 *)ip1;
 499                 struct sockaddr_in6 ip2_6 = *(const struct sockaddr_in6 *)ip2;
 500                 struct sockaddr_in6 mask_6 = *(const struct sockaddr_in6 *)mask;
 501                 char *p1 = (char *)&ip1_6.sin6_addr;
 502                 char *p2 = (char *)&ip2_6.sin6_addr;
 503                 char *m = (char *)&mask_6.sin6_addr;
 504                 int i;
 505
 506                 for (i = 0; i < sizeof(struct in6_addr); i++) {
 507                         *p1++ &= *m;
 508                         *p2++ &= *m;
 509                         m++;
 510                 }
 511                 return (memcmp(&ip1_6.sin6_addr,
 512                                 &ip2_6.sin6_addr,
 513                                 sizeof(struct in6_addr)) == 0);
 514         }
 515 #endif
 516         if (ip1->sa_family == AF_INET) {
 517                 return same_net_v4(((const struct sockaddr_in *)ip1)->sin_addr,
 518                                 ((const struct sockaddr_in *)ip2)->sin_addr,
 519                                 ((const struct sockaddr_in *)mask)->sin_addr);
 520         }
 521         return false;
 522 }
 523
 524 /**
 525  * Are two sockaddr 's the same family and address ? Ignore port etc.
 526  */
 527
 528 bool sockaddr_equal(const struct sockaddr *ip1,
 529                 const struct sockaddr *ip2)
 530 {
 531         if (ip1->sa_family != ip2->sa_family) {
 532                 /* Never the same. */
 533                 return false;
 534         }
 535
 536 #if defined(HAVE_IPV6)
 537         if (ip1->sa_family == AF_INET6) {
 538                 return (memcmp(&((const struct sockaddr_in6 *)ip1)->sin6_addr,
 539                                 &((const struct sockaddr_in6 *)ip2)->sin6_addr,
 540                                 sizeof(struct in6_addr)) == 0);
 541         }
 542 #endif
 543         if (ip1->sa_family == AF_INET) {
 544                 return (memcmp(&((const struct sockaddr_in *)ip1)->sin_addr,
 545                                 &((const struct sockaddr_in *)ip2)->sin_addr,
 546                                 sizeof(struct in_addr)) == 0);
 547         }
 548         return false;
 549 }
 550
 551 /**
 552  * Is an IP address the INADDR_ANY or in6addr_any value ?
 553  */
 554 bool is_address_any(const struct sockaddr *psa)
 555 {
 556 #if defined(HAVE_IPV6)
 557         if (psa->sa_family == AF_INET6) {
 558                 const struct sockaddr_in6 *si6 = (const struct sockaddr_in6 *)psa;
 559                 if (memcmp(&in6addr_any,
 560                                 &si6->sin6_addr,
 561                                 sizeof(in6addr_any)) == 0) {
 562                         return true;
 563                 }
 564                 return false;
 565         }
 566 #endif
 567         if (psa->sa_family == AF_INET) {
 568                 const struct sockaddr_in *si = (const struct sockaddr_in *)psa;
 569                 if (si->sin_addr.s_addr == INADDR_ANY) {
 570                         return true;
 571                 }
 572                 return false;
 573         }
 574         return false;
 575 }
 576
 577 void set_sockaddr_port(struct sockaddr *psa, uint16_t port)
 578 {
 579 #if defined(HAVE_IPV6)
 580         if (psa->sa_family == AF_INET6) {
 581                 ((struct sockaddr_in6 *)psa)->sin6_port = htons(port);
 582         }
 583 #endif
 584         if (psa->sa_family == AF_INET) {
 585                 ((struct sockaddr_in *)psa)->sin_port = htons(port);
 586         }
 587 }
 588
 589
 590 /****************************************************************************
 591  Get a port number in host byte order from a sockaddr_storage.
 592 ****************************************************************************/
 593
 594 uint16_t get_sockaddr_port(const struct sockaddr_storage *pss)
 595 {
 596         uint16_t port = 0;
 597
 598         if (pss->ss_family != AF_INET) {
 599 #if defined(HAVE_IPV6)
 600                 /* IPv6 */
 601                 const struct sockaddr_in6 *sa6 =
 602                         (const struct sockaddr_in6 *)pss;
 603                 port = ntohs(sa6->sin6_port);
 604 #endif
 605         } else {
 606                 const struct sockaddr_in *sa =
 607                         (const struct sockaddr_in *)pss;
 608                 port = ntohs(sa->sin_port);
 609         }
 610         return port;
 611 }
 612
 613 /****************************************************************************
 614  Print out an IPv4 or IPv6 address from a struct sockaddr_storage.
 615 ****************************************************************************/
 616
 617 char *print_sockaddr_len(char *dest,
 618                          size_t destlen,
 619                         const struct sockaddr *psa,
 620                         socklen_t psalen)
 621 {
 622         if (destlen > 0) {
 623                 dest[0] = '\0';
 624         }
 625         (void)sys_getnameinfo(psa,
 626                         psalen,
 627                         dest, destlen,
 628                         NULL, 0,
 629                         NI_NUMERICHOST);
 630         return dest;
 631 }
 632
 633 /****************************************************************************
 634  Print out an IPv4 or IPv6 address from a struct sockaddr_storage.
 635 ****************************************************************************/
 636
 637 char *print_sockaddr(char *dest,
 638                         size_t destlen,
 639                         const struct sockaddr_storage *psa)
 640 {
 641         return print_sockaddr_len(dest, destlen, (const struct sockaddr *)psa,
 642                         sizeof(struct sockaddr_storage));
 643 }
 644
 645 /****************************************************************************
 646  Print out a canonical IPv4 or IPv6 address from a struct sockaddr_storage.
 647 ****************************************************************************/
 648
 649 char *print_canonical_sockaddr(TALLOC_CTX *ctx,
 650                         const struct sockaddr_storage *pss)
 651 {
 652         char addr[INET6_ADDRSTRLEN];
 653         char *dest = NULL;
 654         int ret;
 655
 656         /* Linux getnameinfo() man pages says port is unitialized if
 657            service name is NULL. */
 658
 659         ret = sys_getnameinfo((const struct sockaddr *)pss,
 660                         sizeof(struct sockaddr_storage),
 661                         addr, sizeof(addr),
 662                         NULL, 0,
 663                         NI_NUMERICHOST);
 664         if (ret != 0) {
 665                 return NULL;
 666         }
 667
 668         if (pss->ss_family != AF_INET) {
 669 #if defined(HAVE_IPV6)
 670                 dest = talloc_asprintf(ctx, "[%s]", addr);
 671 #else
 672                 return NULL;
 673 #endif
 674         } else {
 675                 dest = talloc_asprintf(ctx, "%s", addr);
 676         }
 677
 678         return dest;
 679 }
 680
 681 /****************************************************************************
 682  Return the port number we've bound to on a socket.
 683 ****************************************************************************/
 684
 685 int get_socket_port(int fd)
 686 {
 687         struct sockaddr_storage sa;
 688         socklen_t length = sizeof(sa);
 689
 690         if (fd == -1) {
 691                 return -1;
 692         }
 693
 694         if (getsockname(fd, (struct sockaddr *)&sa, &length) < 0) {
 695                 int level = (errno == ENOTCONN) ? 2 : 0;
 696                 DEBUG(level, ("getsockname failed. Error was %s\n",
 697                                strerror(errno)));
 698                 return -1;
 699         }
 700
 701 #if defined(HAVE_IPV6)
 702         if (sa.ss_family == AF_INET6) {
 703                 return ntohs(((struct sockaddr_in6 *)&sa)->sin6_port);
 704         }
 705 #endif
 706         if (sa.ss_family == AF_INET) {
 707                 return ntohs(((struct sockaddr_in *)&sa)->sin_port);
 708         }
 709         return -1;
 710 }
 711
 712 /****************************************************************************
 713  Return the string of an IP address (IPv4 or IPv6).
 714 ****************************************************************************/
 715
 716 static const char *get_socket_addr(int fd, char *addr_buf, size_t addr_len)
 717 {
 718         struct sockaddr_storage sa;
 719         socklen_t length = sizeof(sa);
 720
 721         /* Ok, returning a hard coded IPv4 address
 722          * is bogus, but it's just as bogus as a
 723          * zero IPv6 address. No good choice here.
 724          */
 725
 726         strlcpy(addr_buf, "0.0.0.0", addr_len);
 727
 728         if (fd == -1) {
 729                 return addr_buf;
 730         }
 731
 732         if (getsockname(fd, (struct sockaddr *)&sa, &length) < 0) {
 733                 DEBUG(0,("getsockname failed. Error was %s\n",
 734                         strerror(errno) ));
 735                 return addr_buf;
 736         }
 737
 738         return print_sockaddr_len(addr_buf, addr_len, (struct sockaddr *)&sa, length);
 739 }
 740
 741 const char *client_socket_addr(int fd, char *addr, size_t addr_len)
 742 {
 743         return get_socket_addr(fd, addr, addr_len);
 744 }
 745
 746
 747 enum SOCK_OPT_TYPES {OPT_BOOL,OPT_INT,OPT_ON};
 748
 749 typedef struct smb_socket_option {
 750         const char *name;
 751         int level;
 752         int option;
 753         int value;
 754         int opttype;
 755 } smb_socket_option;
 756
 757 static const smb_socket_option socket_options[] = {
 758   {"SO_KEEPALIVE", SOL_SOCKET, SO_KEEPALIVE, 0, OPT_BOOL},
 759   {"SO_REUSEADDR", SOL_SOCKET, SO_REUSEADDR, 0, OPT_BOOL},
 760   {"SO_BROADCAST", SOL_SOCKET, SO_BROADCAST, 0, OPT_BOOL},
 761 #ifdef TCP_NODELAY
 762   {"TCP_NODELAY", IPPROTO_TCP, TCP_NODELAY, 0, OPT_BOOL},
 763 #endif
 764 #ifdef TCP_KEEPCNT
 765   {"TCP_KEEPCNT", IPPROTO_TCP, TCP_KEEPCNT, 0, OPT_INT},
 766 #endif
 767 #ifdef TCP_KEEPIDLE
 768   {"TCP_KEEPIDLE", IPPROTO_TCP, TCP_KEEPIDLE, 0, OPT_INT},
 769 #endif
 770 #ifdef TCP_KEEPINTVL
 771   {"TCP_KEEPINTVL", IPPROTO_TCP, TCP_KEEPINTVL, 0, OPT_INT},
 772 #endif
 773 #ifdef IPTOS_LOWDELAY
 774   {"IPTOS_LOWDELAY", IPPROTO_IP, IP_TOS, IPTOS_LOWDELAY, OPT_ON},
 775 #endif
 776 #ifdef IPTOS_THROUGHPUT
 777   {"IPTOS_THROUGHPUT", IPPROTO_IP, IP_TOS, IPTOS_THROUGHPUT, OPT_ON},
 778 #endif
 779 #ifdef SO_REUSEPORT
 780   {"SO_REUSEPORT", SOL_SOCKET, SO_REUSEPORT, 0, OPT_BOOL},
 781 #endif
 782 #ifdef SO_SNDBUF
 783   {"SO_SNDBUF", SOL_SOCKET, SO_SNDBUF, 0, OPT_INT},
 784 #endif
 785 #ifdef SO_RCVBUF
 786   {"SO_RCVBUF", SOL_SOCKET, SO_RCVBUF, 0, OPT_INT},
 787 #endif
 788 #ifdef SO_SNDLOWAT
 789   {"SO_SNDLOWAT", SOL_SOCKET, SO_SNDLOWAT, 0, OPT_INT},
 790 #endif
 791 #ifdef SO_RCVLOWAT
 792   {"SO_RCVLOWAT", SOL_SOCKET, SO_RCVLOWAT, 0, OPT_INT},
 793 #endif
 794 #ifdef SO_SNDTIMEO
 795   {"SO_SNDTIMEO", SOL_SOCKET, SO_SNDTIMEO, 0, OPT_INT},
 796 #endif
 797 #ifdef SO_RCVTIMEO
 798   {"SO_RCVTIMEO", SOL_SOCKET, SO_RCVTIMEO, 0, OPT_INT},
 799 #endif
 800 #ifdef TCP_FASTACK
 801   {"TCP_FASTACK", IPPROTO_TCP, TCP_FASTACK, 0, OPT_INT},
 802 #endif
 803 #ifdef TCP_QUICKACK
 804   {"TCP_QUICKACK", IPPROTO_TCP, TCP_QUICKACK, 0, OPT_BOOL},
 805 #endif
 806 #ifdef TCP_NODELAYACK
 807   {"TCP_NODELAYACK", IPPROTO_TCP, TCP_NODELAYACK, 0, OPT_BOOL},
 808 #endif
 809 #ifdef TCP_KEEPALIVE_THRESHOLD
 810   {"TCP_KEEPALIVE_THRESHOLD", IPPROTO_TCP, TCP_KEEPALIVE_THRESHOLD, 0, OPT_INT},
 811 #endif
 812 #ifdef TCP_KEEPALIVE_ABORT_THRESHOLD
 813   {"TCP_KEEPALIVE_ABORT_THRESHOLD", IPPROTO_TCP, TCP_KEEPALIVE_ABORT_THRESHOLD, 0, OPT_INT},
 814 #endif
 815 #ifdef TCP_DEFER_ACCEPT
 816   {"TCP_DEFER_ACCEPT", IPPROTO_TCP, TCP_DEFER_ACCEPT, 0, OPT_INT},
 817 #endif
 818   {NULL,0,0,0,0}};
 819
 820 /****************************************************************************
 821  Print socket options.
 822 ****************************************************************************/
 823
 824 static void print_socket_options(int s)
 825 {
 826         int value;
 827         socklen_t vlen = 4;
 828         const smb_socket_option *p = &socket_options[0];
 829
 830         /* wrapped in if statement to prevent streams
 831          * leak in SCO Openserver 5.0 */
 832         /* reported on samba-technical  --jerry */
 833         if ( DEBUGLEVEL >= 5 ) {
 834                 DEBUG(5,("Socket options:\n"));
 835                 for (; p->name != NULL; p++) {
 836                         if (getsockopt(s, p->level, p->option,
 837                                                 (void *)&value, &vlen) == -1) {
 838                                 DEBUGADD(5,("\tCould not test socket option %s.\n",
 839                                                         p->name));
 840                         } else {
 841                                 DEBUGADD(5,("\t%s = %d\n",
 842                                                         p->name,value));
 843                         }
 844                 }
 845         }
 846  }
 847
 848 /****************************************************************************
 849  Set user socket options.
 850 ****************************************************************************/
 851
 852 void set_socket_options(int fd, const char *options)
 853 {
 854         TALLOC_CTX *ctx = talloc_new(NULL);
 855         char *tok;
 856
 857         while (next_token_talloc(ctx, &options, &tok," \t,")) {
 858                 int ret=0,i;
 859                 int value = 1;
 860                 char *p;
 861                 bool got_value = false;
 862
 863                 if ((p = strchr_m(tok,'='))) {
 864                         *p = 0;
 865                         value = atoi(p+1);
 866                         got_value = true;
 867                 }
 868
 869                 for (i=0;socket_options[i].name;i++)
 870                         if (strequal(socket_options[i].name,tok))
 871                                 break;
 872
 873                 if (!socket_options[i].name) {
 874                         DEBUG(0,("Unknown socket option %s\n",tok));
 875                         continue;
 876                 }
 877
 878                 switch (socket_options[i].opttype) {
 879                 case OPT_BOOL:
 880                 case OPT_INT:
 881                         ret = setsockopt(fd,socket_options[i].level,
 882                                         socket_options[i].option,
 883                                         (char *)&value,sizeof(int));
 884                         break;
 885
 886                 case OPT_ON:
 887                         if (got_value)
 888                                 DEBUG(0,("syntax error - %s "
 889                                         "does not take a value\n",tok));
 890
 891                         {
 892                                 int on = socket_options[i].value;
 893                                 ret = setsockopt(fd,socket_options[i].level,
 894                                         socket_options[i].option,
 895                                         (char *)&on,sizeof(int));
 896                         }
 897                         break;
 898                 }
 899
 900                 if (ret != 0) {
 901                         /* be aware that some systems like Solaris return
 902                          * EINVAL to a setsockopt() call when the client
 903                          * sent a RST previously - no need to worry */
 904                         DEBUG(2,("Failed to set socket option %s (Error %s)\n",
 905                                 tok, strerror(errno) ));
 906                 }
 907         }
 908
 909         TALLOC_FREE(ctx);
 910         print_socket_options(fd);
 911 }