LCOV - code coverage report
Current view: top level - lib/util - util_net.c (source / functions) Hit Total Coverage
Test: coverage report for abartlet/fix-coverage dd10fb34 Lines: 338 437 77.3 %
Date: 2021-09-23 10:06:22 Functions: 32 35 91.4 %

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

Generated by: LCOV version 1.13