lib/util Move set_socket_options() into common code.
[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         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         memset(ip, '\0', sizeof(struct in_addr));
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         memset(ss, '\0', sizeof(*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, (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 }