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
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.
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.
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/>.
27 #include "system/network.h"
28 #include "system/locale.h"
29 #include "system/filesys.h"
30 #include "lib/util/util_net.h"
33 /*******************************************************************
34 Set an address to INADDR_ANY.
35 ******************************************************************/
37 void zero_sockaddr(struct sockaddr_storage *pss)
40 /* Ensure we're at least a valid sockaddr-storage. */
41 pss->ss_family = AF_INET;
47 bool interpret_string_addr_internal(struct addrinfo **ppres,
48 const char *str, int flags)
51 struct addrinfo hints;
55 /* By default make sure it supports TCP. */
56 hints.ai_socktype = SOCK_STREAM;
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);
66 hints.ai_flags = flags;
68 /* Linux man page on getaddrinfo() says port will be
69 uninitialized when service string is NULL */
71 ret = getaddrinfo(str, NULL,
76 DEBUG(3, ("interpret_string_addr_internal: "
77 "getaddrinfo failed for name %s (flags %d) [%s]\n",
78 str, flags, gai_strerror(ret)));
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 ******************************************************************/
90 static bool interpret_string_addr_pref(struct sockaddr_storage *pss,
95 struct addrinfo *res = NULL;
96 #if defined(HAVE_IPV6)
97 char addr[INET6_ADDRSTRLEN];
98 unsigned int scope_id = 0;
101 if (strchr_m(str, ':')) {
102 char *p = strchr_m(str, '%');
105 * Cope with link-local.
106 * This is IP:v6:addr%ifname.
109 if (p && (p > str) && ((scope_id = if_nametoindex(p+1)) != 0)) {
111 MIN(PTR_DIFF(p,str)+1,
120 if (flags & AI_NUMERICHOST) {
123 int_flags = flags|AI_ADDRCONFIG;
126 if (!interpret_string_addr_internal(&res, str, int_flags)) {
136 for (p = res; p; p = p->ai_next) {
137 if (p->ai_family == AF_INET) {
138 memcpy(pss, p->ai_addr, p->ai_addrlen);
143 /* Copy the first sockaddr. */
144 memcpy(pss, res->ai_addr, res->ai_addrlen);
147 /* Copy the first sockaddr. */
148 memcpy(pss, res->ai_addr, res->ai_addrlen);
151 #if defined(HAVE_IPV6)
152 if (pss->ss_family == AF_INET6 && scope_id) {
153 struct sockaddr_in6 *ps6 = (struct sockaddr_in6 *)pss;
154 if (IN6_IS_ADDR_LINKLOCAL(&ps6->sin6_addr) &&
155 ps6->sin6_scope_id == 0) {
156 ps6->sin6_scope_id = scope_id;
165 /*******************************************************************
166 Map a text hostname or IP address (IPv4 or IPv6) into a
167 struct sockaddr_storage. Address agnostic version.
168 ******************************************************************/
170 bool interpret_string_addr(struct sockaddr_storage *pss,
174 return interpret_string_addr_pref(pss,
180 /*******************************************************************
181 Map a text hostname or IP address (IPv4 or IPv6) into a
182 struct sockaddr_storage. Version that prefers IPv4.
183 ******************************************************************/
185 bool interpret_string_addr_prefer_ipv4(struct sockaddr_storage *pss,
189 return interpret_string_addr_pref(pss,
196 * Interpret an internet address or name into an IP address in 4 byte form.
197 * RETURNS IN NETWORK BYTE ORDER (big endian).
200 uint32_t interpret_addr(const char *str)
204 /* If it's in the form of an IP address then
205 * get the lib to interpret it */
206 if (is_ipaddress_v4(str)) {
209 if (inet_pton(AF_INET, str, &dest) <= 0) {
210 /* Error - this shouldn't happen ! */
211 DEBUG(0,("interpret_addr: inet_pton failed "
216 ret = dest.s_addr; /* NETWORK BYTE ORDER ! */
218 /* Otherwise assume it's a network name of some sort and use
220 struct addrinfo *res = NULL;
221 struct addrinfo *res_list = NULL;
222 if (!interpret_string_addr_internal(&res_list,
225 DEBUG(3,("interpret_addr: Unknown host. %s\n",str));
229 /* Find the first IPv4 address. */
230 for (res = res_list; res; res = res->ai_next) {
231 if (res->ai_family != AF_INET) {
234 if (res->ai_addr == NULL) {
240 DEBUG(3,("interpret_addr: host address is "
241 "invalid for host %s\n",str));
243 freeaddrinfo(res_list);
248 &((struct sockaddr_in *)res->ai_addr)->sin_addr.s_addr,
251 freeaddrinfo(res_list);
255 /* This is so bogus - all callers need fixing... JRA. */
256 if (ret == (uint32_t)-1) {
264 A convenient addition to interpret_addr().
266 _PUBLIC_ struct in_addr interpret_addr2(const char *str)
269 uint32_t a = interpret_addr(str);
275 Check if an IP is the 0.0.0.0.
278 _PUBLIC_ bool is_zero_ip_v4(struct in_addr ip)
280 return ip.s_addr == 0;
284 Are two IPs on the same subnet?
287 _PUBLIC_ bool same_net_v4(struct in_addr ip1, struct in_addr ip2, struct in_addr mask)
289 uint32_t net1,net2,nmask;
291 nmask = ntohl(mask.s_addr);
292 net1 = ntohl(ip1.s_addr);
293 net2 = ntohl(ip2.s_addr);
295 return((net1 & nmask) == (net2 & nmask));
299 * Return true if a string could be an IPv4 address.
302 bool is_ipaddress_v4(const char *str)
307 ret = inet_pton(AF_INET, str, &dest);
315 * Return true if a string could be a IPv6 address.
318 bool is_ipaddress_v6(const char *str)
320 #if defined(HAVE_IPV6)
323 if (strchr_m(str, ':')) {
324 char addr[INET6_ADDRSTRLEN];
325 struct in6_addr dest6;
326 const char *sp = str;
327 char *p = strchr_m(str, '%');
330 * Cope with link-local.
331 * This is IP:v6:addr%ifname.
334 if (p && (p > str) && (if_nametoindex(p+1) != 0)) {
336 MIN(PTR_DIFF(p,str)+1,
340 ret = inet_pton(AF_INET6, sp, &dest6);
350 * Return true if a string could be an IPv4 or IPv6 address.
353 bool is_ipaddress(const char *str)
355 return is_ipaddress_v4(str) || is_ipaddress_v6(str);
359 * Is a sockaddr a broadcast address ?
362 bool is_broadcast_addr(const struct sockaddr *pss)
364 #if defined(HAVE_IPV6)
365 if (pss->sa_family == AF_INET6) {
366 const struct in6_addr *sin6 =
367 &((const struct sockaddr_in6 *)pss)->sin6_addr;
368 return IN6_IS_ADDR_MULTICAST(sin6);
371 if (pss->sa_family == AF_INET) {
373 ntohl(((const struct sockaddr_in *)pss)->sin_addr.s_addr);
374 return addr == INADDR_BROADCAST;
380 * Check if an IPv7 is 127.0.0.1
382 bool is_loopback_ip_v4(struct in_addr ip)
385 a.s_addr = htonl(INADDR_LOOPBACK);
386 return(ip.s_addr == a.s_addr);
390 * Check if a struct sockaddr is the loopback address.
392 bool is_loopback_addr(const struct sockaddr *pss)
394 #if defined(HAVE_IPV6)
395 if (pss->sa_family == AF_INET6) {
396 const struct in6_addr *pin6 =
397 &((const struct sockaddr_in6 *)pss)->sin6_addr;
398 return IN6_IS_ADDR_LOOPBACK(pin6);
401 if (pss->sa_family == AF_INET) {
402 const struct in_addr *pin = &((const struct sockaddr_in *)pss)->sin_addr;
403 return is_loopback_ip_v4(*pin);
409 * Check if a struct sockaddr has an unspecified address.
411 bool is_zero_addr(const struct sockaddr_storage *pss)
413 #if defined(HAVE_IPV6)
414 if (pss->ss_family == AF_INET6) {
415 const struct in6_addr *pin6 =
416 &((const struct sockaddr_in6 *)pss)->sin6_addr;
417 return IN6_IS_ADDR_UNSPECIFIED(pin6);
420 if (pss->ss_family == AF_INET) {
421 const struct in_addr *pin = &((const struct sockaddr_in *)pss)->sin_addr;
422 return is_zero_ip_v4(*pin);
428 * Set an IP to 0.0.0.0.
430 void zero_ip_v4(struct in_addr *ip)
435 bool is_linklocal_addr(const struct sockaddr_storage *pss)
438 if (pss->ss_family == AF_INET6) {
439 const struct in6_addr *pin6 =
440 &((const struct sockaddr_in6 *)pss)->sin6_addr;
441 return IN6_IS_ADDR_LINKLOCAL(pin6);
444 if (pss->ss_family == AF_INET) {
445 const struct in_addr *pin =
446 &((const struct sockaddr_in *)pss)->sin_addr;
447 struct in_addr ll_addr;
448 struct in_addr mask_addr;
450 /* 169.254.0.0/16, is link local, see RFC 3927 */
451 ll_addr.s_addr = 0xa9fe0000;
452 mask_addr.s_addr = 0xffff0000;
453 return same_net_v4(*pin, ll_addr, mask_addr);
459 * Convert an IPv4 struct in_addr to a struct sockaddr_storage.
461 void in_addr_to_sockaddr_storage(struct sockaddr_storage *ss,
464 struct sockaddr_in *sa = (struct sockaddr_in *)ss;
466 sa->sin_family = AF_INET;
470 #if defined(HAVE_IPV6)
472 * Convert an IPv6 struct in_addr to a struct sockaddr_storage.
474 void in6_addr_to_sockaddr_storage(struct sockaddr_storage *ss,
477 struct sockaddr_in6 *sa = (struct sockaddr_in6 *)ss;
478 memset(ss, '\0', sizeof(*ss));
479 sa->sin6_family = AF_INET6;
485 * Are two IPs on the same subnet?
487 bool same_net(const struct sockaddr *ip1,
488 const struct sockaddr *ip2,
489 const struct sockaddr *mask)
491 if (ip1->sa_family != ip2->sa_family) {
492 /* Never on the same net. */
496 #if defined(HAVE_IPV6)
497 if (ip1->sa_family == AF_INET6) {
498 struct sockaddr_in6 ip1_6 = *(const struct sockaddr_in6 *)ip1;
499 struct sockaddr_in6 ip2_6 = *(const struct sockaddr_in6 *)ip2;
500 struct sockaddr_in6 mask_6 = *(const struct sockaddr_in6 *)mask;
501 char *p1 = (char *)&ip1_6.sin6_addr;
502 char *p2 = (char *)&ip2_6.sin6_addr;
503 char *m = (char *)&mask_6.sin6_addr;
506 for (i = 0; i < sizeof(struct in6_addr); i++) {
511 return (memcmp(&ip1_6.sin6_addr,
513 sizeof(struct in6_addr)) == 0);
516 if (ip1->sa_family == AF_INET) {
517 return same_net_v4(((const struct sockaddr_in *)ip1)->sin_addr,
518 ((const struct sockaddr_in *)ip2)->sin_addr,
519 ((const struct sockaddr_in *)mask)->sin_addr);
525 * Are two sockaddr 's the same family and address ? Ignore port etc.
528 bool sockaddr_equal(const struct sockaddr *ip1,
529 const struct sockaddr *ip2)
531 if (ip1->sa_family != ip2->sa_family) {
532 /* Never the same. */
536 #if defined(HAVE_IPV6)
537 if (ip1->sa_family == AF_INET6) {
538 return (memcmp(&((const struct sockaddr_in6 *)ip1)->sin6_addr,
539 &((const struct sockaddr_in6 *)ip2)->sin6_addr,
540 sizeof(struct in6_addr)) == 0);
543 if (ip1->sa_family == AF_INET) {
544 return (memcmp(&((const struct sockaddr_in *)ip1)->sin_addr,
545 &((const struct sockaddr_in *)ip2)->sin_addr,
546 sizeof(struct in_addr)) == 0);
552 * Is an IP address the INADDR_ANY or in6addr_any value ?
554 bool is_address_any(const struct sockaddr *psa)
556 #if defined(HAVE_IPV6)
557 if (psa->sa_family == AF_INET6) {
558 const struct sockaddr_in6 *si6 = (const struct sockaddr_in6 *)psa;
559 if (memcmp(&in6addr_any,
561 sizeof(in6addr_any)) == 0) {
567 if (psa->sa_family == AF_INET) {
568 const struct sockaddr_in *si = (const struct sockaddr_in *)psa;
569 if (si->sin_addr.s_addr == INADDR_ANY) {
577 void set_sockaddr_port(struct sockaddr *psa, uint16_t port)
579 #if defined(HAVE_IPV6)
580 if (psa->sa_family == AF_INET6) {
581 ((struct sockaddr_in6 *)psa)->sin6_port = htons(port);
584 if (psa->sa_family == AF_INET) {
585 ((struct sockaddr_in *)psa)->sin_port = htons(port);
590 /****************************************************************************
591 Get a port number in host byte order from a sockaddr_storage.
592 ****************************************************************************/
594 uint16_t get_sockaddr_port(const struct sockaddr_storage *pss)
598 if (pss->ss_family != AF_INET) {
599 #if defined(HAVE_IPV6)
601 const struct sockaddr_in6 *sa6 =
602 (const struct sockaddr_in6 *)pss;
603 port = ntohs(sa6->sin6_port);
606 const struct sockaddr_in *sa =
607 (const struct sockaddr_in *)pss;
608 port = ntohs(sa->sin_port);
613 /****************************************************************************
614 Print out an IPv4 or IPv6 address from a struct sockaddr_storage.
615 ****************************************************************************/
617 char *print_sockaddr_len(char *dest,
619 const struct sockaddr *psa,
625 (void)sys_getnameinfo(psa,
633 /****************************************************************************
634 Print out an IPv4 or IPv6 address from a struct sockaddr_storage.
635 ****************************************************************************/
637 char *print_sockaddr(char *dest,
639 const struct sockaddr_storage *psa)
641 return print_sockaddr_len(dest, destlen, (const struct sockaddr *)psa,
642 sizeof(struct sockaddr_storage));
645 /****************************************************************************
646 Print out a canonical IPv4 or IPv6 address from a struct sockaddr_storage.
647 ****************************************************************************/
649 char *print_canonical_sockaddr(TALLOC_CTX *ctx,
650 const struct sockaddr_storage *pss)
652 char addr[INET6_ADDRSTRLEN];
656 /* Linux getnameinfo() man pages says port is unitialized if
657 service name is NULL. */
659 ret = sys_getnameinfo((const struct sockaddr *)pss,
660 sizeof(struct sockaddr_storage),
668 if (pss->ss_family != AF_INET) {
669 #if defined(HAVE_IPV6)
670 dest = talloc_asprintf(ctx, "[%s]", addr);
675 dest = talloc_asprintf(ctx, "%s", addr);
681 /****************************************************************************
682 Return the port number we've bound to on a socket.
683 ****************************************************************************/
685 int get_socket_port(int fd)
687 struct sockaddr_storage sa;
688 socklen_t length = sizeof(sa);
694 if (getsockname(fd, (struct sockaddr *)&sa, &length) < 0) {
695 int level = (errno == ENOTCONN) ? 2 : 0;
696 DEBUG(level, ("getsockname failed. Error was %s\n",
701 #if defined(HAVE_IPV6)
702 if (sa.ss_family == AF_INET6) {
703 return ntohs(((struct sockaddr_in6 *)&sa)->sin6_port);
706 if (sa.ss_family == AF_INET) {
707 return ntohs(((struct sockaddr_in *)&sa)->sin_port);
712 /****************************************************************************
713 Return the string of an IP address (IPv4 or IPv6).
714 ****************************************************************************/
716 static const char *get_socket_addr(int fd, char *addr_buf, size_t addr_len)
718 struct sockaddr_storage sa;
719 socklen_t length = sizeof(sa);
721 /* Ok, returning a hard coded IPv4 address
722 * is bogus, but it's just as bogus as a
723 * zero IPv6 address. No good choice here.
726 strlcpy(addr_buf, "0.0.0.0", addr_len);
732 if (getsockname(fd, (struct sockaddr *)&sa, &length) < 0) {
733 DEBUG(0,("getsockname failed. Error was %s\n",
738 return print_sockaddr_len(addr_buf, addr_len, (struct sockaddr *)&sa, length);
741 const char *client_socket_addr(int fd, char *addr, size_t addr_len)
743 return get_socket_addr(fd, addr, addr_len);
747 enum SOCK_OPT_TYPES {OPT_BOOL,OPT_INT,OPT_ON};
749 typedef struct smb_socket_option {
757 static const smb_socket_option socket_options[] = {
758 {"SO_KEEPALIVE", SOL_SOCKET, SO_KEEPALIVE, 0, OPT_BOOL},
759 {"SO_REUSEADDR", SOL_SOCKET, SO_REUSEADDR, 0, OPT_BOOL},
760 {"SO_BROADCAST", SOL_SOCKET, SO_BROADCAST, 0, OPT_BOOL},
762 {"TCP_NODELAY", IPPROTO_TCP, TCP_NODELAY, 0, OPT_BOOL},
765 {"TCP_KEEPCNT", IPPROTO_TCP, TCP_KEEPCNT, 0, OPT_INT},
768 {"TCP_KEEPIDLE", IPPROTO_TCP, TCP_KEEPIDLE, 0, OPT_INT},
771 {"TCP_KEEPINTVL", IPPROTO_TCP, TCP_KEEPINTVL, 0, OPT_INT},
773 #ifdef IPTOS_LOWDELAY
774 {"IPTOS_LOWDELAY", IPPROTO_IP, IP_TOS, IPTOS_LOWDELAY, OPT_ON},
776 #ifdef IPTOS_THROUGHPUT
777 {"IPTOS_THROUGHPUT", IPPROTO_IP, IP_TOS, IPTOS_THROUGHPUT, OPT_ON},
780 {"SO_REUSEPORT", SOL_SOCKET, SO_REUSEPORT, 0, OPT_BOOL},
783 {"SO_SNDBUF", SOL_SOCKET, SO_SNDBUF, 0, OPT_INT},
786 {"SO_RCVBUF", SOL_SOCKET, SO_RCVBUF, 0, OPT_INT},
789 {"SO_SNDLOWAT", SOL_SOCKET, SO_SNDLOWAT, 0, OPT_INT},
792 {"SO_RCVLOWAT", SOL_SOCKET, SO_RCVLOWAT, 0, OPT_INT},
795 {"SO_SNDTIMEO", SOL_SOCKET, SO_SNDTIMEO, 0, OPT_INT},
798 {"SO_RCVTIMEO", SOL_SOCKET, SO_RCVTIMEO, 0, OPT_INT},
801 {"TCP_FASTACK", IPPROTO_TCP, TCP_FASTACK, 0, OPT_INT},
804 {"TCP_QUICKACK", IPPROTO_TCP, TCP_QUICKACK, 0, OPT_BOOL},
806 #ifdef TCP_NODELAYACK
807 {"TCP_NODELAYACK", IPPROTO_TCP, TCP_NODELAYACK, 0, OPT_BOOL},
809 #ifdef TCP_KEEPALIVE_THRESHOLD
810 {"TCP_KEEPALIVE_THRESHOLD", IPPROTO_TCP, TCP_KEEPALIVE_THRESHOLD, 0, OPT_INT},
812 #ifdef TCP_KEEPALIVE_ABORT_THRESHOLD
813 {"TCP_KEEPALIVE_ABORT_THRESHOLD", IPPROTO_TCP, TCP_KEEPALIVE_ABORT_THRESHOLD, 0, OPT_INT},
815 #ifdef TCP_DEFER_ACCEPT
816 {"TCP_DEFER_ACCEPT", IPPROTO_TCP, TCP_DEFER_ACCEPT, 0, OPT_INT},
820 /****************************************************************************
821 Print socket options.
822 ****************************************************************************/
824 static void print_socket_options(int s)
828 const smb_socket_option *p = &socket_options[0];
830 /* wrapped in if statement to prevent streams
831 * leak in SCO Openserver 5.0 */
832 /* reported on samba-technical --jerry */
833 if ( DEBUGLEVEL >= 5 ) {
834 DEBUG(5,("Socket options:\n"));
835 for (; p->name != NULL; p++) {
836 if (getsockopt(s, p->level, p->option,
837 (void *)&value, &vlen) == -1) {
838 DEBUGADD(5,("\tCould not test socket option %s.\n",
841 DEBUGADD(5,("\t%s = %d\n",
848 /****************************************************************************
849 Set user socket options.
850 ****************************************************************************/
852 void set_socket_options(int fd, const char *options)
854 TALLOC_CTX *ctx = talloc_new(NULL);
857 while (next_token_talloc(ctx, &options, &tok," \t,")) {
861 bool got_value = false;
863 if ((p = strchr_m(tok,'='))) {
869 for (i=0;socket_options[i].name;i++)
870 if (strequal(socket_options[i].name,tok))
873 if (!socket_options[i].name) {
874 DEBUG(0,("Unknown socket option %s\n",tok));
878 switch (socket_options[i].opttype) {
881 ret = setsockopt(fd,socket_options[i].level,
882 socket_options[i].option,
883 (char *)&value,sizeof(int));
888 DEBUG(0,("syntax error - %s "
889 "does not take a value\n",tok));
892 int on = socket_options[i].value;
893 ret = setsockopt(fd,socket_options[i].level,
894 socket_options[i].option,
895 (char *)&on,sizeof(int));
901 /* be aware that some systems like Solaris return
902 * EINVAL to a setsockopt() call when the client
903 * sent a RST previously - no need to worry */
904 DEBUG(2,("Failed to set socket option %s (Error %s)\n",
905 tok, strerror(errno) ));
910 print_socket_options(fd);