57db4fae4d81593a3ece0448a39575f4980d17f7
[nivanova/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 static char *normalize_ipv6_literal(const char *str, char *buf, size_t *_len)
45 {
46 #define IPv6_LITERAL_NET ".ipv6-literal.net"
47         const size_t llen = sizeof(IPv6_LITERAL_NET) - 1;
48         size_t len = *_len;
49         int cmp;
50         size_t i;
51         size_t idx_chars = 0;
52         size_t cnt_delimiter = 0;
53         size_t cnt_chars = 0;
54
55         if (len <= llen) {
56                 return NULL;
57         }
58
59         /* ignore a trailing '.' */
60         if (str[len - 1] == '.') {
61                 len -= 1;
62         }
63
64         len -= llen;
65         if (len >= INET6_ADDRSTRLEN) {
66                 return NULL;
67         }
68         if (len < 2) {
69                 return NULL;
70         }
71
72         cmp = strncasecmp(&str[len], IPv6_LITERAL_NET, llen);
73         if (cmp != 0) {
74                 return NULL;
75         }
76
77         for (i = 0; i < len; i++) {
78                 if (idx_chars != 0) {
79                         break;
80                 }
81
82                 switch (str[i]) {
83                 case '-':
84                         buf[i] = ':';
85                         cnt_chars = 0;
86                         cnt_delimiter += 1;
87                         break;
88                 case 's':
89                         buf[i] = SCOPE_DELIMITER;
90                         idx_chars += 1;
91                         break;
92                 case '0':
93                 case '1':
94                 case '2':
95                 case '3':
96                 case '4':
97                 case '5':
98                 case '6':
99                 case '7':
100                 case '8':
101                 case '9':
102                 case 'a':
103                 case 'A':
104                 case 'b':
105                 case 'B':
106                 case 'c':
107                 case 'C':
108                 case 'd':
109                 case 'D':
110                 case 'e':
111                 case 'E':
112                 case 'f':
113                 case 'F':
114                         buf[i] = str[i];
115                         cnt_chars += 1;
116                         break;
117                 default:
118                         return NULL;
119                 }
120                 if (cnt_chars > 4) {
121                         return NULL;
122                 }
123                 if (cnt_delimiter > 7) {
124                         return NULL;
125                 }
126         }
127
128         if (cnt_delimiter < 2) {
129                 return NULL;
130         }
131
132         for (; idx_chars != 0 && i < len; i++) {
133                 switch (str[i]) {
134                 case SCOPE_DELIMITER:
135                 case ':':
136                         return NULL;
137                 default:
138                         buf[i] = str[i];
139                         idx_chars += 1;
140                         break;
141                 }
142         }
143
144         if (idx_chars == 1) {
145                 return NULL;
146         }
147
148         buf[i] = '\0';
149         *_len = len;
150         return buf;
151 }
152
153 /**
154  * Wrap getaddrinfo...
155  */
156 bool interpret_string_addr_internal(struct addrinfo **ppres,
157                                         const char *str, int flags)
158 {
159         int ret;
160         struct addrinfo hints;
161 #if defined(HAVE_IPV6)
162         char addr[INET6_ADDRSTRLEN*2] = { 0, };
163         unsigned int scope_id = 0;
164         size_t len = strlen(str);
165 #endif
166
167         ZERO_STRUCT(hints);
168
169         /* By default make sure it supports TCP. */
170         hints.ai_socktype = SOCK_STREAM;
171
172         /* always try as a numeric host first. This prevents unnecessary name
173          * lookups, and also ensures we accept IPv6 addresses */
174         hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST;
175
176 #if defined(HAVE_IPV6)
177         if (len < sizeof(addr)) {
178                 char *p = NULL;
179
180                 p = normalize_ipv6_literal(str, addr, &len);
181                 if (p != NULL) {
182                         hints.ai_family = AF_INET6;
183                         str = p;
184                 }
185         }
186
187         if (strchr_m(str, ':')) {
188                 char *p = strchr_m(str, SCOPE_DELIMITER);
189
190                 /*
191                  * Cope with link-local.
192                  * This is IP:v6:addr%ifname.
193                  */
194
195                 if (p && (p > str) && ((scope_id = if_nametoindex(p+1)) != 0)) {
196                         /* Length of string we want to copy.
197                            This is IP:v6:addr (removing the %ifname).
198                          */
199                         len = PTR_DIFF(p,str);
200
201                         if (len+1 > sizeof(addr)) {
202                                 /* string+nul too long for array. */
203                                 return false;
204                         }
205                         if (str != addr) {
206                                 memcpy(addr, str, len);
207                         }
208                         addr[len] = '\0';
209
210                         str = addr;
211                 }
212         }
213 #endif
214
215         ret = getaddrinfo(str, NULL, &hints, ppres);
216         if (ret == 0) {
217 #if defined(HAVE_IPV6)
218                 struct sockaddr_in6 *ps6 = NULL;
219
220                 if (scope_id == 0) {
221                         return true;
222                 }
223                 if (ppres == NULL) {
224                         return true;
225                 }
226                 if ((*ppres) == NULL) {
227                         return true;
228                 }
229                 if ((*ppres)->ai_addr->sa_family != AF_INET6) {
230                         return true;
231                 }
232
233                 ps6 = (struct sockaddr_in6 *)(*ppres)->ai_addr;
234
235                 if (IN6_IS_ADDR_LINKLOCAL(&ps6->sin6_addr) &&
236                                 ps6->sin6_scope_id == 0) {
237                         ps6->sin6_scope_id = scope_id;
238                 }
239 #endif
240
241                 return true;
242         }
243
244         hints.ai_flags = flags;
245
246         /* Linux man page on getaddrinfo() says port will be
247            uninitialized when service string is NULL */
248
249         ret = getaddrinfo(str, NULL,
250                         &hints,
251                         ppres);
252
253         if (ret) {
254                 DEBUG(3, ("interpret_string_addr_internal: "
255                           "getaddrinfo failed for name %s (flags %d) [%s]\n",
256                           str, flags, gai_strerror(ret)));
257                 return false;
258         }
259         return true;
260 }
261
262 /*******************************************************************
263  Map a text hostname or IP address (IPv4 or IPv6) into a
264  struct sockaddr_storage. Takes a flag which allows it to
265  prefer an IPv4 address (needed for DC's).
266 ******************************************************************/
267
268 static bool interpret_string_addr_pref(struct sockaddr_storage *pss,
269                 const char *str,
270                 int flags,
271                 bool prefer_ipv4)
272 {
273         struct addrinfo *res = NULL;
274         int int_flags;
275
276         zero_sockaddr(pss);
277
278         if (flags & AI_NUMERICHOST) {
279                 int_flags = flags;
280         } else {
281                 int_flags = flags|AI_ADDRCONFIG;
282         }
283
284         if (!interpret_string_addr_internal(&res, str, int_flags)) {
285                 return false;
286         }
287         if (!res) {
288                 return false;
289         }
290
291         if (prefer_ipv4) {
292                 struct addrinfo *p;
293
294                 for (p = res; p; p = p->ai_next) {
295                         if (p->ai_family == AF_INET) {
296                                 memcpy(pss, p->ai_addr, p->ai_addrlen);
297                                 break;
298                         }
299                 }
300                 if (p == NULL) {
301                         /* Copy the first sockaddr. */
302                         memcpy(pss, res->ai_addr, res->ai_addrlen);
303                 }
304         } else {
305                 /* Copy the first sockaddr. */
306                 memcpy(pss, res->ai_addr, res->ai_addrlen);
307         }
308
309         freeaddrinfo(res);
310         return true;
311 }
312
313 /*******************************************************************
314  Map a text hostname or IP address (IPv4 or IPv6) into a
315  struct sockaddr_storage. Address agnostic version.
316 ******************************************************************/
317
318 bool interpret_string_addr(struct sockaddr_storage *pss,
319                 const char *str,
320                 int flags)
321 {
322         return interpret_string_addr_pref(pss,
323                                         str,
324                                         flags,
325                                         false);
326 }
327
328 /*******************************************************************
329  Map a text hostname or IP address (IPv4 or IPv6) into a
330  struct sockaddr_storage. Version that prefers IPv4.
331 ******************************************************************/
332
333 bool interpret_string_addr_prefer_ipv4(struct sockaddr_storage *pss,
334                 const char *str,
335                 int flags)
336 {
337         return interpret_string_addr_pref(pss,
338                                         str,
339                                         flags,
340                                         true);
341 }
342
343 /**
344  * Interpret an internet address or name into an IP address in 4 byte form.
345  * RETURNS IN NETWORK BYTE ORDER (big endian).
346  */
347
348 uint32_t interpret_addr(const char *str)
349 {
350         uint32_t ret;
351
352         /* If it's in the form of an IP address then
353          * get the lib to interpret it */
354         if (is_ipaddress_v4(str)) {
355                 struct in_addr dest;
356
357                 if (inet_pton(AF_INET, str, &dest) <= 0) {
358                         /* Error - this shouldn't happen ! */
359                         DEBUG(0,("interpret_addr: inet_pton failed "
360                                 "host %s\n",
361                                 str));
362                         return 0;
363                 }
364                 ret = dest.s_addr; /* NETWORK BYTE ORDER ! */
365         } else {
366                 /* Otherwise assume it's a network name of some sort and use
367                         getadddrinfo. */
368                 struct addrinfo *res = NULL;
369                 struct addrinfo *res_list = NULL;
370                 if (!interpret_string_addr_internal(&res_list,
371                                         str,
372                                         AI_ADDRCONFIG)) {
373                         DEBUG(3,("interpret_addr: Unknown host. %s\n",str));
374                         return 0;
375                 }
376
377                 /* Find the first IPv4 address. */
378                 for (res = res_list; res; res = res->ai_next) {
379                         if (res->ai_family != AF_INET) {
380                                 continue;
381                         }
382                         if (res->ai_addr == NULL) {
383                                 continue;
384                         }
385                         break;
386                 }
387                 if(res == NULL) {
388                         DEBUG(3,("interpret_addr: host address is "
389                                 "invalid for host %s\n",str));
390                         if (res_list) {
391                                 freeaddrinfo(res_list);
392                         }
393                         return 0;
394                 }
395                 memcpy((char *)&ret,
396                         &((struct sockaddr_in *)res->ai_addr)->sin_addr.s_addr,
397                         sizeof(ret));
398                 if (res_list) {
399                         freeaddrinfo(res_list);
400                 }
401         }
402
403         /* This is so bogus - all callers need fixing... JRA. */
404         if (ret == (uint32_t)-1) {
405                 return 0;
406         }
407
408         return ret;
409 }
410
411 /**
412  A convenient addition to interpret_addr().
413 **/
414 _PUBLIC_ struct in_addr interpret_addr2(const char *str)
415 {
416         struct in_addr ret;
417         uint32_t a = interpret_addr(str);
418         ret.s_addr = a;
419         return ret;
420 }
421
422 /**
423  Check if an IP is the 0.0.0.0.
424 **/
425
426 _PUBLIC_ bool is_zero_ip_v4(struct in_addr ip)
427 {
428         return ip.s_addr == 0;
429 }
430
431 /**
432  Are two IPs on the same subnet?
433 **/
434
435 _PUBLIC_ bool same_net_v4(struct in_addr ip1, struct in_addr ip2, struct in_addr mask)
436 {
437         uint32_t net1,net2,nmask;
438
439         nmask = ntohl(mask.s_addr);
440         net1  = ntohl(ip1.s_addr);
441         net2  = ntohl(ip2.s_addr);
442             
443         return((net1 & nmask) == (net2 & nmask));
444 }
445
446 /**
447  * Return true if a string could be an IPv4 address.
448  */
449
450 bool is_ipaddress_v4(const char *str)
451 {
452         int ret = -1;
453         struct in_addr dest;
454
455         ret = inet_pton(AF_INET, str, &dest);
456         if (ret > 0) {
457                 return true;
458         }
459         return false;
460 }
461
462 bool is_ipv6_literal(const char *str)
463 {
464 #if defined(HAVE_IPV6)
465         char buf[INET6_ADDRSTRLEN*2] = { 0, };
466         size_t len = strlen(str);
467         char *p = NULL;
468
469         if (len >= sizeof(buf)) {
470                 return false;
471         }
472
473         p = normalize_ipv6_literal(str, buf, &len);
474         if (p == NULL) {
475                 return false;
476         }
477
478         return true;
479 #else
480         return false;
481 #endif
482 }
483
484 /**
485  * Return true if a string could be a IPv6 address.
486  */
487
488 bool is_ipaddress_v6(const char *str)
489 {
490 #if defined(HAVE_IPV6)
491         int ret = -1;
492         char *p = NULL;
493         char buf[INET6_ADDRSTRLEN] = { 0, };
494         size_t len;
495         const char *addr = str;
496         const char *idxs = NULL;
497         unsigned int idx = 0;
498         struct in6_addr ip6;
499
500         p = strchr_m(str, ':');
501         if (p == NULL) {
502                 return is_ipv6_literal(str);
503         }
504
505         p = strchr_m(str, SCOPE_DELIMITER);
506         if (p && (p > str)) {
507                 len = PTR_DIFF(p, str);
508                 idxs = p + 1;
509         } else {
510                 len = strlen(str);
511         }
512
513         if (len >= sizeof(buf)) {
514                 return false;
515         }
516         if (idxs != NULL) {
517                 strncpy(buf, str, len);
518                 addr = buf;
519         }
520
521         /*
522          * Cope with link-local.
523          * This is IP:v6:addr%ifidx.
524          */
525         if (idxs != NULL) {
526                 char c;
527
528                 ret = sscanf(idxs, "%5u%c", &idx, &c);
529                 if (ret != 1) {
530                         idx = 0;
531                 }
532
533                 if (idx > 0 && idx < UINT16_MAX) {
534                         /* a valid index */
535                         idxs = NULL;
536                 }
537         }
538
539         /*
540          * Cope with link-local.
541          * This is IP:v6:addr%ifname.
542          */
543         if (idxs != NULL) {
544                 idx = if_nametoindex(idxs);
545
546                 if (idx > 0) {
547                         /* a valid index */
548                         idxs = NULL;
549                 }
550         }
551
552         if (idxs != NULL) {
553                 return false;
554         }
555
556         ret = inet_pton(AF_INET6, addr, &ip6);
557         if (ret <= 0) {
558                 return false;
559         }
560
561         return true;
562 #endif
563         return false;
564 }
565
566 /**
567  * Return true if a string could be an IPv4 or IPv6 address.
568  */
569
570 bool is_ipaddress(const char *str)
571 {
572         return is_ipaddress_v4(str) || is_ipaddress_v6(str);
573 }
574
575 /**
576  * Is a sockaddr a broadcast address ?
577  */
578
579 bool is_broadcast_addr(const struct sockaddr *pss)
580 {
581 #if defined(HAVE_IPV6)
582         if (pss->sa_family == AF_INET6) {
583                 const struct in6_addr *sin6 =
584                         &((const struct sockaddr_in6 *)pss)->sin6_addr;
585                 return IN6_IS_ADDR_MULTICAST(sin6);
586         }
587 #endif
588         if (pss->sa_family == AF_INET) {
589                 uint32_t addr =
590                 ntohl(((const struct sockaddr_in *)pss)->sin_addr.s_addr);
591                 return addr == INADDR_BROADCAST;
592         }
593         return false;
594 }
595
596 /**
597  * Check if an IPv7 is 127.0.0.1
598  */
599 bool is_loopback_ip_v4(struct in_addr ip)
600 {
601         struct in_addr a;
602         a.s_addr = htonl(INADDR_LOOPBACK);
603         return(ip.s_addr == a.s_addr);
604 }
605
606 /**
607  * Check if a struct sockaddr is the loopback address.
608  */
609 bool is_loopback_addr(const struct sockaddr *pss)
610 {
611 #if defined(HAVE_IPV6)
612         if (pss->sa_family == AF_INET6) {
613                 const struct in6_addr *pin6 =
614                         &((const struct sockaddr_in6 *)pss)->sin6_addr;
615                 return IN6_IS_ADDR_LOOPBACK(pin6);
616         }
617 #endif
618         if (pss->sa_family == AF_INET) {
619                 const struct in_addr *pin = &((const struct sockaddr_in *)pss)->sin_addr;
620                 return is_loopback_ip_v4(*pin);
621         }
622         return false;
623 }
624
625 /**
626  * Check if a struct sockaddr has an unspecified address.
627  */
628 bool is_zero_addr(const struct sockaddr_storage *pss)
629 {
630 #if defined(HAVE_IPV6)
631         if (pss->ss_family == AF_INET6) {
632                 const struct in6_addr *pin6 =
633                         &((const struct sockaddr_in6 *)pss)->sin6_addr;
634                 return IN6_IS_ADDR_UNSPECIFIED(pin6);
635         }
636 #endif
637         if (pss->ss_family == AF_INET) {
638                 const struct in_addr *pin = &((const struct sockaddr_in *)pss)->sin_addr;
639                 return is_zero_ip_v4(*pin);
640         }
641         return false;
642 }
643
644 /**
645  * Set an IP to 0.0.0.0.
646  */
647 void zero_ip_v4(struct in_addr *ip)
648 {
649         ZERO_STRUCTP(ip);
650 }
651
652 bool is_linklocal_addr(const struct sockaddr_storage *pss)
653 {
654 #ifdef HAVE_IPV6
655         if (pss->ss_family == AF_INET6) {
656                 const struct in6_addr *pin6 =
657                         &((const struct sockaddr_in6 *)pss)->sin6_addr;
658                 return IN6_IS_ADDR_LINKLOCAL(pin6);
659         }
660 #endif
661         if (pss->ss_family == AF_INET) {
662                 const struct in_addr *pin =
663                         &((const struct sockaddr_in *)pss)->sin_addr;
664                 struct in_addr ll_addr;
665                 struct in_addr mask_addr;
666
667                 /* 169.254.0.0/16, is link local, see RFC 3927 */
668                 ll_addr.s_addr = 0xa9fe0000;
669                 mask_addr.s_addr = 0xffff0000;
670                 return same_net_v4(*pin, ll_addr, mask_addr);
671         }
672         return false;
673 }
674
675 /**
676  * Convert an IPv4 struct in_addr to a struct sockaddr_storage.
677  */
678 void in_addr_to_sockaddr_storage(struct sockaddr_storage *ss,
679                 struct in_addr ip)
680 {
681         struct sockaddr_in *sa = (struct sockaddr_in *)ss;
682         ZERO_STRUCTP(ss);
683         sa->sin_family = AF_INET;
684         sa->sin_addr = ip;
685 }
686
687 #if defined(HAVE_IPV6)
688 /**
689  * Convert an IPv6 struct in_addr to a struct sockaddr_storage.
690  */
691 void in6_addr_to_sockaddr_storage(struct sockaddr_storage *ss,
692                 struct in6_addr ip)
693 {
694         struct sockaddr_in6 *sa = (struct sockaddr_in6 *)ss;
695         memset(ss, '\0', sizeof(*ss));
696         sa->sin6_family = AF_INET6;
697         sa->sin6_addr = ip;
698 }
699 #endif
700
701 /**
702  * Are two IPs on the same subnet?
703  */
704 bool same_net(const struct sockaddr *ip1,
705                 const struct sockaddr *ip2,
706                 const struct sockaddr *mask)
707 {
708         if (ip1->sa_family != ip2->sa_family) {
709                 /* Never on the same net. */
710                 return false;
711         }
712
713 #if defined(HAVE_IPV6)
714         if (ip1->sa_family == AF_INET6) {
715                 struct sockaddr_in6 ip1_6 = *(const struct sockaddr_in6 *)ip1;
716                 struct sockaddr_in6 ip2_6 = *(const struct sockaddr_in6 *)ip2;
717                 struct sockaddr_in6 mask_6 = *(const struct sockaddr_in6 *)mask;
718                 char *p1 = (char *)&ip1_6.sin6_addr;
719                 char *p2 = (char *)&ip2_6.sin6_addr;
720                 char *m = (char *)&mask_6.sin6_addr;
721                 int i;
722
723                 for (i = 0; i < sizeof(struct in6_addr); i++) {
724                         *p1++ &= *m;
725                         *p2++ &= *m;
726                         m++;
727                 }
728                 return (memcmp(&ip1_6.sin6_addr,
729                                 &ip2_6.sin6_addr,
730                                 sizeof(struct in6_addr)) == 0);
731         }
732 #endif
733         if (ip1->sa_family == AF_INET) {
734                 return same_net_v4(((const struct sockaddr_in *)ip1)->sin_addr,
735                                 ((const struct sockaddr_in *)ip2)->sin_addr,
736                                 ((const struct sockaddr_in *)mask)->sin_addr);
737         }
738         return false;
739 }
740
741 /**
742  * Are two sockaddr 's the same family and address ? Ignore port etc.
743  */
744
745 bool sockaddr_equal(const struct sockaddr *ip1,
746                 const struct sockaddr *ip2)
747 {
748         if (ip1->sa_family != ip2->sa_family) {
749                 /* Never the same. */
750                 return false;
751         }
752
753 #if defined(HAVE_IPV6)
754         if (ip1->sa_family == AF_INET6) {
755                 return (memcmp(&((const struct sockaddr_in6 *)ip1)->sin6_addr,
756                                 &((const struct sockaddr_in6 *)ip2)->sin6_addr,
757                                 sizeof(struct in6_addr)) == 0);
758         }
759 #endif
760         if (ip1->sa_family == AF_INET) {
761                 return (memcmp(&((const struct sockaddr_in *)ip1)->sin_addr,
762                                 &((const struct sockaddr_in *)ip2)->sin_addr,
763                                 sizeof(struct in_addr)) == 0);
764         }
765         return false;
766 }
767
768 /**
769  * Is an IP address the INADDR_ANY or in6addr_any value ?
770  */
771 bool is_address_any(const struct sockaddr *psa)
772 {
773 #if defined(HAVE_IPV6)
774         if (psa->sa_family == AF_INET6) {
775                 const struct sockaddr_in6 *si6 = (const struct sockaddr_in6 *)psa;
776                 if (memcmp(&in6addr_any,
777                                 &si6->sin6_addr,
778                                 sizeof(in6addr_any)) == 0) {
779                         return true;
780                 }
781                 return false;
782         }
783 #endif
784         if (psa->sa_family == AF_INET) {
785                 const struct sockaddr_in *si = (const struct sockaddr_in *)psa;
786                 if (si->sin_addr.s_addr == INADDR_ANY) {
787                         return true;
788                 }
789                 return false;
790         }
791         return false;
792 }
793
794 void set_sockaddr_port(struct sockaddr *psa, uint16_t port)
795 {
796 #if defined(HAVE_IPV6)
797         if (psa->sa_family == AF_INET6) {
798                 ((struct sockaddr_in6 *)psa)->sin6_port = htons(port);
799         }
800 #endif
801         if (psa->sa_family == AF_INET) {
802                 ((struct sockaddr_in *)psa)->sin_port = htons(port);
803         }
804 }
805
806
807 /****************************************************************************
808  Get a port number in host byte order from a sockaddr_storage.
809 ****************************************************************************/
810
811 uint16_t get_sockaddr_port(const struct sockaddr_storage *pss)
812 {
813         uint16_t port = 0;
814
815         if (pss->ss_family != AF_INET) {
816 #if defined(HAVE_IPV6)
817                 /* IPv6 */
818                 const struct sockaddr_in6 *sa6 =
819                         (const struct sockaddr_in6 *)pss;
820                 port = ntohs(sa6->sin6_port);
821 #endif
822         } else {
823                 const struct sockaddr_in *sa =
824                         (const struct sockaddr_in *)pss;
825                 port = ntohs(sa->sin_port);
826         }
827         return port;
828 }
829
830 /****************************************************************************
831  Print out an IPv4 or IPv6 address from a struct sockaddr_storage.
832 ****************************************************************************/
833
834 char *print_sockaddr_len(char *dest,
835                          size_t destlen,
836                         const struct sockaddr *psa,
837                         socklen_t psalen)
838 {
839         if (destlen > 0) {
840                 dest[0] = '\0';
841         }
842         (void)sys_getnameinfo(psa,
843                         psalen,
844                         dest, destlen,
845                         NULL, 0,
846                         NI_NUMERICHOST);
847         return dest;
848 }
849
850 /****************************************************************************
851  Print out an IPv4 or IPv6 address from a struct sockaddr_storage.
852 ****************************************************************************/
853
854 char *print_sockaddr(char *dest,
855                         size_t destlen,
856                         const struct sockaddr_storage *psa)
857 {
858         return print_sockaddr_len(dest, destlen, (const struct sockaddr *)psa,
859                         sizeof(struct sockaddr_storage));
860 }
861
862 /****************************************************************************
863  Print out a canonical IPv4 or IPv6 address from a struct sockaddr_storage.
864 ****************************************************************************/
865
866 char *print_canonical_sockaddr(TALLOC_CTX *ctx,
867                         const struct sockaddr_storage *pss)
868 {
869         char addr[INET6_ADDRSTRLEN];
870         char *dest = NULL;
871         int ret;
872
873         /* Linux getnameinfo() man pages says port is unitialized if
874            service name is NULL. */
875
876         ret = sys_getnameinfo((const struct sockaddr *)pss,
877                         sizeof(struct sockaddr_storage),
878                         addr, sizeof(addr),
879                         NULL, 0,
880                         NI_NUMERICHOST);
881         if (ret != 0) {
882                 return NULL;
883         }
884
885         if (pss->ss_family != AF_INET) {
886 #if defined(HAVE_IPV6)
887                 dest = talloc_asprintf(ctx, "[%s]", addr);
888 #else
889                 return NULL;
890 #endif
891         } else {
892                 dest = talloc_asprintf(ctx, "%s", addr);
893         }
894
895         return dest;
896 }
897
898 /****************************************************************************
899  Return the port number we've bound to on a socket.
900 ****************************************************************************/
901
902 int get_socket_port(int fd)
903 {
904         struct sockaddr_storage sa;
905         socklen_t length = sizeof(sa);
906
907         if (fd == -1) {
908                 return -1;
909         }
910
911         if (getsockname(fd, (struct sockaddr *)&sa, &length) < 0) {
912                 int level = (errno == ENOTCONN) ? 2 : 0;
913                 DEBUG(level, ("getsockname failed. Error was %s\n",
914                                strerror(errno)));
915                 return -1;
916         }
917
918 #if defined(HAVE_IPV6)
919         if (sa.ss_family == AF_INET6) {
920                 struct sockaddr_in6 *sa_in6 = (struct sockaddr_in6 *)&sa;
921                 return ntohs(sa_in6->sin6_port);
922         }
923 #endif
924         if (sa.ss_family == AF_INET) {
925                 struct sockaddr_in *sa_in = (struct sockaddr_in *)&sa;
926                 return ntohs(sa_in->sin_port);
927         }
928         return -1;
929 }
930
931 /****************************************************************************
932  Return the string of an IP address (IPv4 or IPv6).
933 ****************************************************************************/
934
935 static const char *get_socket_addr(int fd, char *addr_buf, size_t addr_len)
936 {
937         struct sockaddr_storage sa;
938         socklen_t length = sizeof(sa);
939
940         /* Ok, returning a hard coded IPv4 address
941          * is bogus, but it's just as bogus as a
942          * zero IPv6 address. No good choice here.
943          */
944
945         if (strlcpy(addr_buf, "0.0.0.0", addr_len) >= addr_len) {
946                 /* Truncate ! */
947                 return NULL;
948         }
949
950         if (fd == -1) {
951                 return addr_buf;
952         }
953
954         if (getsockname(fd, (struct sockaddr *)&sa, &length) < 0) {
955                 DEBUG(0,("getsockname failed. Error was %s\n",
956                         strerror(errno) ));
957                 return addr_buf;
958         }
959
960         return print_sockaddr_len(addr_buf, addr_len, (struct sockaddr *)&sa, length);
961 }
962
963 const char *client_socket_addr(int fd, char *addr, size_t addr_len)
964 {
965         return get_socket_addr(fd, addr, addr_len);
966 }
967
968
969 enum SOCK_OPT_TYPES {OPT_BOOL,OPT_INT,OPT_ON};
970
971 typedef struct smb_socket_option {
972         const char *name;
973         int level;
974         int option;
975         int value;
976         int opttype;
977 } smb_socket_option;
978
979 static const smb_socket_option socket_options[] = {
980   {"SO_KEEPALIVE", SOL_SOCKET, SO_KEEPALIVE, 0, OPT_BOOL},
981   {"SO_REUSEADDR", SOL_SOCKET, SO_REUSEADDR, 0, OPT_BOOL},
982   {"SO_BROADCAST", SOL_SOCKET, SO_BROADCAST, 0, OPT_BOOL},
983 #ifdef TCP_NODELAY
984   {"TCP_NODELAY", IPPROTO_TCP, TCP_NODELAY, 0, OPT_BOOL},
985 #endif
986 #ifdef TCP_KEEPCNT
987   {"TCP_KEEPCNT", IPPROTO_TCP, TCP_KEEPCNT, 0, OPT_INT},
988 #endif
989 #ifdef TCP_KEEPIDLE
990   {"TCP_KEEPIDLE", IPPROTO_TCP, TCP_KEEPIDLE, 0, OPT_INT},
991 #endif
992 #ifdef TCP_KEEPINTVL
993   {"TCP_KEEPINTVL", IPPROTO_TCP, TCP_KEEPINTVL, 0, OPT_INT},
994 #endif
995 #ifdef IPTOS_LOWDELAY
996   {"IPTOS_LOWDELAY", IPPROTO_IP, IP_TOS, IPTOS_LOWDELAY, OPT_ON},
997 #endif
998 #ifdef IPTOS_THROUGHPUT
999   {"IPTOS_THROUGHPUT", IPPROTO_IP, IP_TOS, IPTOS_THROUGHPUT, OPT_ON},
1000 #endif
1001 #ifdef SO_REUSEPORT
1002   {"SO_REUSEPORT", SOL_SOCKET, SO_REUSEPORT, 0, OPT_BOOL},
1003 #endif
1004 #ifdef SO_SNDBUF
1005   {"SO_SNDBUF", SOL_SOCKET, SO_SNDBUF, 0, OPT_INT},
1006 #endif
1007 #ifdef SO_RCVBUF
1008   {"SO_RCVBUF", SOL_SOCKET, SO_RCVBUF, 0, OPT_INT},
1009 #endif
1010 #ifdef SO_SNDLOWAT
1011   {"SO_SNDLOWAT", SOL_SOCKET, SO_SNDLOWAT, 0, OPT_INT},
1012 #endif
1013 #ifdef SO_RCVLOWAT
1014   {"SO_RCVLOWAT", SOL_SOCKET, SO_RCVLOWAT, 0, OPT_INT},
1015 #endif
1016 #ifdef SO_SNDTIMEO
1017   {"SO_SNDTIMEO", SOL_SOCKET, SO_SNDTIMEO, 0, OPT_INT},
1018 #endif
1019 #ifdef SO_RCVTIMEO
1020   {"SO_RCVTIMEO", SOL_SOCKET, SO_RCVTIMEO, 0, OPT_INT},
1021 #endif
1022 #ifdef TCP_FASTACK
1023   {"TCP_FASTACK", IPPROTO_TCP, TCP_FASTACK, 0, OPT_INT},
1024 #endif
1025 #ifdef TCP_QUICKACK
1026   {"TCP_QUICKACK", IPPROTO_TCP, TCP_QUICKACK, 0, OPT_BOOL},
1027 #endif
1028 #ifdef TCP_NODELAYACK
1029   {"TCP_NODELAYACK", IPPROTO_TCP, TCP_NODELAYACK, 0, OPT_BOOL},
1030 #endif
1031 #ifdef TCP_KEEPALIVE_THRESHOLD
1032   {"TCP_KEEPALIVE_THRESHOLD", IPPROTO_TCP, TCP_KEEPALIVE_THRESHOLD, 0, OPT_INT},
1033 #endif
1034 #ifdef TCP_KEEPALIVE_ABORT_THRESHOLD
1035   {"TCP_KEEPALIVE_ABORT_THRESHOLD", IPPROTO_TCP, TCP_KEEPALIVE_ABORT_THRESHOLD, 0, OPT_INT},
1036 #endif
1037 #ifdef TCP_DEFER_ACCEPT
1038   {"TCP_DEFER_ACCEPT", IPPROTO_TCP, TCP_DEFER_ACCEPT, 0, OPT_INT},
1039 #endif
1040   {NULL,0,0,0,0}};
1041
1042 /****************************************************************************
1043  Print socket options.
1044 ****************************************************************************/
1045
1046 static void print_socket_options(int s)
1047 {
1048         int value;
1049         socklen_t vlen = 4;
1050         const smb_socket_option *p = &socket_options[0];
1051
1052         /* wrapped in if statement to prevent streams
1053          * leak in SCO Openserver 5.0 */
1054         /* reported on samba-technical  --jerry */
1055         if ( DEBUGLEVEL >= 5 ) {
1056                 DEBUG(5,("Socket options:\n"));
1057                 for (; p->name != NULL; p++) {
1058                         if (getsockopt(s, p->level, p->option,
1059                                                 (void *)&value, &vlen) == -1) {
1060                                 DEBUGADD(5,("\tCould not test socket option %s.\n",
1061                                                         p->name));
1062                         } else {
1063                                 DEBUGADD(5,("\t%s = %d\n",
1064                                                         p->name,value));
1065                         }
1066                 }
1067         }
1068  }
1069
1070 /****************************************************************************
1071  Set user socket options.
1072 ****************************************************************************/
1073
1074 void set_socket_options(int fd, const char *options)
1075 {
1076         TALLOC_CTX *ctx = talloc_new(NULL);
1077         char *tok;
1078
1079         while (next_token_talloc(ctx, &options, &tok," \t,")) {
1080                 int ret=0,i;
1081                 int value = 1;
1082                 char *p;
1083                 bool got_value = false;
1084
1085                 if ((p = strchr_m(tok,'='))) {
1086                         *p = 0;
1087                         value = atoi(p+1);
1088                         got_value = true;
1089                 }
1090
1091                 for (i=0;socket_options[i].name;i++)
1092                         if (strequal(socket_options[i].name,tok))
1093                                 break;
1094
1095                 if (!socket_options[i].name) {
1096                         DEBUG(0,("Unknown socket option %s\n",tok));
1097                         continue;
1098                 }
1099
1100                 switch (socket_options[i].opttype) {
1101                 case OPT_BOOL:
1102                 case OPT_INT:
1103                         ret = setsockopt(fd,socket_options[i].level,
1104                                         socket_options[i].option,
1105                                         (char *)&value,sizeof(int));
1106                         break;
1107
1108                 case OPT_ON:
1109                         if (got_value)
1110                                 DEBUG(0,("syntax error - %s "
1111                                         "does not take a value\n",tok));
1112
1113                         {
1114                                 int on = socket_options[i].value;
1115                                 ret = setsockopt(fd,socket_options[i].level,
1116                                         socket_options[i].option,
1117                                         (char *)&on,sizeof(int));
1118                         }
1119                         break;
1120                 }
1121
1122                 if (ret != 0) {
1123                         /* be aware that some systems like Solaris return
1124                          * EINVAL to a setsockopt() call when the client
1125                          * sent a RST previously - no need to worry */
1126                         DEBUG(2,("Failed to set socket option %s (Error %s)\n",
1127                                 tok, strerror(errno) ));
1128                 }
1129         }
1130
1131         TALLOC_FREE(ctx);
1132         print_socket_options(fd);
1133 }