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