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