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