LCOV - code coverage report
Current view: top level - lib/util - util_net.c (source / functions) Hit Total Coverage
Test: coverage report for master 2b515b7d Lines: 392 500 78.4 %
Date: 2024-02-28 12:06:22 Functions: 36 38 94.7 %

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

Generated by: LCOV version 1.14