s3: allow to set TCP_NODELAYACK socket option on AIX
[sfrench/samba-autobuild/.git] / 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   {NULL,0,0,0,0}};
816
817 /****************************************************************************
818  Print socket options.
819 ****************************************************************************/
820
821 static void print_socket_options(int s)
822 {
823         int value;
824         socklen_t vlen = 4;
825         const smb_socket_option *p = &socket_options[0];
826
827         /* wrapped in if statement to prevent streams
828          * leak in SCO Openserver 5.0 */
829         /* reported on samba-technical  --jerry */
830         if ( DEBUGLEVEL >= 5 ) {
831                 DEBUG(5,("Socket options:\n"));
832                 for (; p->name != NULL; p++) {
833                         if (getsockopt(s, p->level, p->option,
834                                                 (void *)&value, &vlen) == -1) {
835                                 DEBUGADD(5,("\tCould not test socket option %s.\n",
836                                                         p->name));
837                         } else {
838                                 DEBUGADD(5,("\t%s = %d\n",
839                                                         p->name,value));
840                         }
841                 }
842         }
843  }
844
845 /****************************************************************************
846  Set user socket options.
847 ****************************************************************************/
848
849 void set_socket_options(int fd, const char *options)
850 {
851         TALLOC_CTX *ctx = talloc_new(NULL);
852         char *tok;
853
854         while (next_token_talloc(ctx, &options, &tok," \t,")) {
855                 int ret=0,i;
856                 int value = 1;
857                 char *p;
858                 bool got_value = false;
859
860                 if ((p = strchr_m(tok,'='))) {
861                         *p = 0;
862                         value = atoi(p+1);
863                         got_value = true;
864                 }
865
866                 for (i=0;socket_options[i].name;i++)
867                         if (strequal(socket_options[i].name,tok))
868                                 break;
869
870                 if (!socket_options[i].name) {
871                         DEBUG(0,("Unknown socket option %s\n",tok));
872                         continue;
873                 }
874
875                 switch (socket_options[i].opttype) {
876                 case OPT_BOOL:
877                 case OPT_INT:
878                         ret = setsockopt(fd,socket_options[i].level,
879                                         socket_options[i].option,
880                                         (char *)&value,sizeof(int));
881                         break;
882
883                 case OPT_ON:
884                         if (got_value)
885                                 DEBUG(0,("syntax error - %s "
886                                         "does not take a value\n",tok));
887
888                         {
889                                 int on = socket_options[i].value;
890                                 ret = setsockopt(fd,socket_options[i].level,
891                                         socket_options[i].option,
892                                         (char *)&on,sizeof(int));
893                         }
894                         break;
895                 }
896
897                 if (ret != 0) {
898                         /* be aware that some systems like Solaris return
899                          * EINVAL to a setsockopt() call when the client
900                          * sent a RST previously - no need to worry */
901                         DEBUG(2,("Failed to set socket option %s (Error %s)\n",
902                                 tok, strerror(errno) ));
903                 }
904         }
905
906         TALLOC_FREE(ctx);
907         print_socket_options(fd);
908 }