LCOV - code coverage report
Current view: top level - source3/lib - interface.c (source / functions) Hit Total Coverage
Test: coverage report for abartlet/fix-coverage dd10fb34 Lines: 154 294 52.4 %
Date: 2021-09-23 10:06:22 Functions: 16 22 72.7 %

          Line data    Source code
       1             : /*
       2             :    Unix SMB/CIFS implementation.
       3             :    multiple interface handling
       4             :    Copyright (C) Andrew Tridgell 1992-1998
       5             :    Copyright (C) Jeremy Allison 2007
       6             : 
       7             :    This program is free software; you can redistribute it and/or modify
       8             :    it under the terms of the GNU General Public License as published by
       9             :    the Free Software Foundation; either version 3 of the License, or
      10             :    (at your option) any later version.
      11             : 
      12             :    This program is distributed in the hope that it will be useful,
      13             :    but WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      15             :    GNU General Public License for more details.
      16             : 
      17             :    You should have received a copy of the GNU General Public License
      18             :    along with this program.  If not, see <http://www.gnu.org/licenses/>.
      19             : */
      20             : 
      21             : #include "includes.h"
      22             : #include "lib/socket/interfaces.h"
      23             : #include "librpc/gen_ndr/ioctl.h"
      24             : #include "lib/util/smb_strtox.h"
      25             : 
      26             : static struct iface_struct *probed_ifaces;
      27             : static int total_probed;
      28             : 
      29             : static struct interface *local_interfaces;
      30             : 
      31             : /****************************************************************************
      32             :  Check if an IP is one of mine.
      33             : **************************************************************************/
      34             : 
      35        6932 : bool ismyaddr(const struct sockaddr *ip)
      36             : {
      37             :         struct interface *i;
      38       21186 :         for (i=local_interfaces;i;i=i->next) {
      39       15544 :                 if (sockaddr_equal((struct sockaddr *)&i->ip,ip)) {
      40        1290 :                         return true;
      41             :                 }
      42             :         }
      43        5642 :         return false;
      44             : }
      45             : 
      46        6438 : bool ismyip_v4(struct in_addr ip)
      47             : {
      48             :         struct sockaddr_storage ss;
      49        6438 :         in_addr_to_sockaddr_storage(&ss, ip);
      50        6438 :         return ismyaddr((struct sockaddr *)&ss);
      51             : }
      52             : 
      53             : /****************************************************************************
      54             :  Try and find an interface that matches an ip. If we cannot, return NULL.
      55             : **************************************************************************/
      56             : 
      57      111228 : static struct interface *iface_find(const struct sockaddr *ip,
      58             :                                 bool check_mask)
      59             : {
      60             :         struct interface *i;
      61             : 
      62      111228 :         if (is_address_any(ip)) {
      63           0 :                 return local_interfaces;
      64             :         }
      65             : 
      66      402448 :         for (i=local_interfaces;i;i=i->next) {
      67      291545 :                 if (check_mask) {
      68         650 :                         if (same_net(ip, (struct sockaddr *)&i->ip, (struct sockaddr *)&i->netmask)) {
      69         325 :                                 return i;
      70             :                         }
      71      290895 :                 } else if (sockaddr_equal((struct sockaddr *)&i->ip, ip)) {
      72           0 :                         return i;
      73             :                 }
      74             :         }
      75             : 
      76      110490 :         return NULL;
      77             : }
      78             : 
      79             : /****************************************************************************
      80             :  Check if a packet is from a local (known) net.
      81             : **************************************************************************/
      82             : 
      83           0 : bool is_local_net(const struct sockaddr *from)
      84             : {
      85             :         struct interface *i;
      86           0 :         for (i=local_interfaces;i;i=i->next) {
      87           0 :                 if (same_net(from, (struct sockaddr *)&i->ip, (struct sockaddr *)&i->netmask)) {
      88           0 :                         return true;
      89             :                 }
      90             :         }
      91           0 :         return false;
      92             : }
      93             : 
      94             : #if defined(HAVE_IPV6)
      95           0 : void setup_linklocal_scope_id(struct sockaddr *pss)
      96             : {
      97             :         struct interface *i;
      98           0 :         for (i=local_interfaces;i;i=i->next) {
      99           0 :                 if (sockaddr_equal((struct sockaddr *)&i->ip,pss)) {
     100           0 :                         struct sockaddr_in6 *psa6 =
     101             :                                 (struct sockaddr_in6 *)pss;
     102           0 :                         psa6->sin6_scope_id = if_nametoindex(i->name);
     103           0 :                         return;
     104             :                 }
     105             :         }
     106             : }
     107             : #endif
     108             : 
     109             : /****************************************************************************
     110             :  Check if a packet is from a local (known) net.
     111             : **************************************************************************/
     112             : 
     113           0 : bool is_local_net_v4(struct in_addr from)
     114             : {
     115             :         struct sockaddr_storage ss;
     116             : 
     117           0 :         in_addr_to_sockaddr_storage(&ss, from);
     118           0 :         return is_local_net((struct sockaddr *)&ss);
     119             : }
     120             : 
     121             : /****************************************************************************
     122             :  How many interfaces do we have ?
     123             : **************************************************************************/
     124             : 
     125         792 : int iface_count(void)
     126             : {
     127         792 :         int ret = 0;
     128             :         struct interface *i;
     129             : 
     130        2856 :         for (i=local_interfaces;i;i=i->next) {
     131        2064 :                 ret++;
     132             :         }
     133         792 :         return ret;
     134             : }
     135             : 
     136             : /****************************************************************************
     137             :  How many non-loopback IPv4 interfaces do we have ?
     138             : **************************************************************************/
     139             : 
     140          66 : int iface_count_v4_nl(void)
     141             : {
     142          66 :         int ret = 0;
     143             :         struct interface *i;
     144             : 
     145         198 :         for (i=local_interfaces;i;i=i->next) {
     146         132 :                 if (is_loopback_addr((struct sockaddr *)&i->ip)) {
     147           0 :                         continue;
     148             :                 }
     149         132 :                 if (i->ip.ss_family == AF_INET) {
     150          66 :                         ret++;
     151             :                 }
     152             :         }
     153          66 :         return ret;
     154             : }
     155             : 
     156             : /****************************************************************************
     157             :  Return a pointer to the in_addr of the first IPv4 interface that's
     158             :  not 0.0.0.0.
     159             : **************************************************************************/
     160             : 
     161           0 : const struct in_addr *first_ipv4_iface(void)
     162             : {
     163             :         struct interface *i;
     164             : 
     165           0 :         for (i=local_interfaces;i ;i=i->next) {
     166           0 :                 if ((i->ip.ss_family == AF_INET) &&
     167           0 :                     (!is_zero_ip_v4(((struct sockaddr_in *)&i->ip)->sin_addr)))
     168             :                 {
     169           0 :                         break;
     170             :                 }
     171             :         }
     172             : 
     173           0 :         if (!i) {
     174           0 :                 return NULL;
     175             :         }
     176           0 :         return &((const struct sockaddr_in *)&i->ip)->sin_addr;
     177             : }
     178             : 
     179             : /****************************************************************************
     180             :  Return the Nth interface.
     181             : **************************************************************************/
     182             : 
     183         150 : struct interface *get_interface(int n)
     184             : {
     185             :         struct interface *i;
     186             : 
     187         225 :         for (i=local_interfaces;i && n;i=i->next) {
     188          75 :                 n--;
     189             :         }
     190             : 
     191         150 :         if (i) {
     192         150 :                 return i;
     193             :         }
     194           0 :         return NULL;
     195             : }
     196             : 
     197             : /****************************************************************************
     198             :  Return IP sockaddr_storage of the Nth interface.
     199             : **************************************************************************/
     200             : 
     201         242 : const struct sockaddr_storage *iface_n_sockaddr_storage(int n)
     202             : {
     203             :         struct interface *i;
     204             : 
     205         713 :         for (i=local_interfaces;i && n;i=i->next) {
     206         471 :                 n--;
     207             :         }
     208             : 
     209         242 :         if (i) {
     210         242 :                 return &i->ip;
     211             :         }
     212           0 :         return NULL;
     213             : }
     214             : 
     215             : /****************************************************************************
     216             :  Return IPv4 of the Nth interface (if a v4 address). NULL otherwise.
     217             : **************************************************************************/
     218             : 
     219         270 : const struct in_addr *iface_n_ip_v4(int n)
     220             : {
     221             :         struct interface *i;
     222             : 
     223         405 :         for (i=local_interfaces;i && n;i=i->next) {
     224         135 :                 n--;
     225             :         }
     226             : 
     227         270 :         if (i && i->ip.ss_family == AF_INET) {
     228         135 :                 return &((const struct sockaddr_in *)&i->ip)->sin_addr;
     229             :         }
     230         135 :         return NULL;
     231             : }
     232             : 
     233             : /****************************************************************************
     234             :  Return IPv4 bcast of the Nth interface (if a v4 address). NULL otherwise.
     235             : **************************************************************************/
     236             : 
     237           0 : const struct in_addr *iface_n_bcast_v4(int n)
     238             : {
     239             :         struct interface *i;
     240             : 
     241           0 :         for (i=local_interfaces;i && n;i=i->next) {
     242           0 :                 n--;
     243             :         }
     244             : 
     245           0 :         if (i && i->ip.ss_family == AF_INET) {
     246           0 :                 return &((const struct sockaddr_in *)&i->bcast)->sin_addr;
     247             :         }
     248           0 :         return NULL;
     249             : }
     250             : 
     251             : /****************************************************************************
     252             :  Return bcast of the Nth interface.
     253             : **************************************************************************/
     254             : 
     255         936 : const struct sockaddr_storage *iface_n_bcast(int n)
     256             : {
     257             :         struct interface *i;
     258             : 
     259        2734 :         for (i=local_interfaces;i && n;i=i->next) {
     260        1798 :                 n--;
     261             :         }
     262             : 
     263         936 :         if (i) {
     264         936 :                 return &i->bcast;
     265             :         }
     266           0 :         return NULL;
     267             : }
     268             : 
     269             : /* these 3 functions return the ip/bcast/nmask for the interface
     270             :    most appropriate for the given ip address. If they can't find
     271             :    an appropriate interface they return the requested field of the
     272             :    first known interface. */
     273             : 
     274         273 : const struct sockaddr_storage *iface_ip(const struct sockaddr *ip)
     275             : {
     276         273 :         struct interface *i = iface_find(ip, true);
     277         273 :         if (i) {
     278         273 :                 return &i->ip;
     279             :         }
     280             : 
     281             :         /* Search for the first interface with
     282             :          * matching address family. */
     283             : 
     284           0 :         for (i=local_interfaces;i;i=i->next) {
     285           0 :                 if (i->ip.ss_family == ip->sa_family) {
     286           0 :                         return &i->ip;
     287             :                 }
     288             :         }
     289           0 :         return NULL;
     290             : }
     291             : 
     292             : /*
     293             :   return True if a IP is directly reachable on one of our interfaces
     294             : */
     295             : 
     296          52 : bool iface_local(const struct sockaddr *ip)
     297             : {
     298          52 :         return iface_find(ip, true) ? true : false;
     299             : }
     300             : 
     301             : /****************************************************************************
     302             :  Add an interface to the linked list of interfaces.
     303             : ****************************************************************************/
     304             : 
     305      110903 : static void add_interface(const struct iface_struct *ifs)
     306             : {
     307             :         char addr[INET6_ADDRSTRLEN];
     308             :         struct interface *iface;
     309             : 
     310      110903 :         if (iface_find((const struct sockaddr *)&ifs->ip, False)) {
     311           0 :                 DEBUG(3,("add_interface: not adding duplicate interface %s\n",
     312             :                         print_sockaddr(addr, sizeof(addr), &ifs->ip) ));
     313           0 :                 return;
     314             :         }
     315             : 
     316      110903 :         if (!(ifs->flags & (IFF_BROADCAST|IFF_LOOPBACK))) {
     317           0 :                 DEBUG(3,("not adding non-broadcast interface %s\n",
     318             :                                         ifs->name ));
     319           0 :                 return;
     320             :         }
     321             : 
     322      110903 :         iface = SMB_MALLOC_P(struct interface);
     323      110903 :         if (!iface) {
     324           0 :                 return;
     325             :         }
     326             : 
     327      110903 :         ZERO_STRUCTPN(iface);
     328             : 
     329      110903 :         iface->name = SMB_STRDUP(ifs->name);
     330      110903 :         if (!iface->name) {
     331           0 :                 SAFE_FREE(iface);
     332           0 :                 return;
     333             :         }
     334      110903 :         iface->flags = ifs->flags;
     335      110903 :         iface->ip = ifs->ip;
     336      110903 :         iface->netmask = ifs->netmask;
     337      110903 :         iface->bcast = ifs->bcast;
     338      110903 :         iface->linkspeed = ifs->linkspeed;
     339      110903 :         iface->capability = ifs->capability;
     340      110903 :         iface->if_index = ifs->if_index;
     341             : 
     342      110903 :         DLIST_ADD(local_interfaces, iface);
     343             : 
     344      110903 :         DEBUG(2,("added interface %s ip=%s ",
     345             :                 iface->name,
     346             :                 print_sockaddr(addr, sizeof(addr), &iface->ip) ));
     347      110903 :         DEBUG(2,("bcast=%s ",
     348             :                 print_sockaddr(addr, sizeof(addr),
     349             :                         &iface->bcast) ));
     350      110903 :         DEBUG(2,("netmask=%s\n",
     351             :                 print_sockaddr(addr, sizeof(addr),
     352             :                         &iface->netmask) ));
     353             : }
     354             : 
     355             : 
     356           0 : static void parse_extra_info(char *key, uint64_t *speed, uint32_t *cap,
     357             :                              uint32_t *if_index)
     358             : {
     359           0 :         while (key != NULL && *key != '\0') {
     360             :                 char *next_key;
     361             :                 char *val;
     362           0 :                 int error = 0;
     363             : 
     364           0 :                 next_key = strchr_m(key, ',');
     365           0 :                 if (next_key != NULL) {
     366           0 :                         *next_key++ = 0;
     367             :                 }
     368             : 
     369           0 :                 val = strchr_m(key, '=');
     370           0 :                 if (val != NULL) {
     371           0 :                         *val++ = 0;
     372             : 
     373           0 :                         if (strequal_m(key, "speed")) {
     374           0 :                                 *speed = (uint64_t)smb_strtoull(val,
     375             :                                                                 NULL,
     376             :                                                                 0,
     377             :                                                                 &error,
     378             :                                                                 SMB_STR_STANDARD);
     379           0 :                                 if (error != 0) {
     380           0 :                                         DBG_DEBUG("Invalid speed value (%s)\n", val);
     381             :                                 }
     382           0 :                         } else if (strequal_m(key, "capability")) {
     383           0 :                                 if (strequal_m(val, "RSS")) {
     384           0 :                                         *cap |= FSCTL_NET_IFACE_RSS_CAPABLE;
     385           0 :                                 } else if (strequal(val, "RDMA")) {
     386           0 :                                         *cap |= FSCTL_NET_IFACE_RDMA_CAPABLE;
     387             :                                 } else {
     388           0 :                                         DBG_WARNING("Capability unknown: "
     389             :                                                     "'%s'\n", val);
     390             :                                 }
     391           0 :                         } else if (strequal_m(key, "if_index")) {
     392           0 :                                 *if_index = (uint32_t)smb_strtoul(val,
     393             :                                                                   NULL,
     394             :                                                                   0,
     395             :                                                                   &error,
     396             :                                                                   SMB_STR_STANDARD);
     397           0 :                                 if (error != 0) {
     398           0 :                                         DBG_DEBUG("Invalid key value (%s)\n", val);
     399             :                                 }
     400             :                         } else {
     401           0 :                                 DBG_DEBUG("Key unknown: '%s'\n", key);
     402             :                         }
     403             :                 }
     404             : 
     405           0 :                 key = next_key;
     406             :         }
     407           0 : }
     408             : 
     409             : /****************************************************************************
     410             :  Interpret a single element from a interfaces= config line.
     411             : 
     412             :  This handles the following different forms:
     413             : 
     414             :  1) wildcard interface name
     415             :  2) DNS name
     416             :  3) IP/masklen
     417             :  4) ip/mask
     418             :  5) bcast/mask
     419             : 
     420             :  Additional information for an interface can be specified with
     421             :  this extended syntax:
     422             : 
     423             :     "interface[;key1=value1[,key2=value2[...]]]"
     424             : 
     425             :  Note: The double quoting is important for the
     426             :        smb.conf parser! Otherwise the ';' and ',' separates
     427             :        two interfaces.
     428             : 
     429             :  where
     430             :  - keys known: 'speed', 'capability', 'if_index'
     431             :  - speed is in bits per second
     432             :  - capabilites known: 'RSS', 'RDMA'
     433             :  - if_index should be used with care, because
     434             :    these indexes should not conicide with indexes
     435             :    the kernel sets...
     436             : 
     437             :  Note: The specified values overwrite the autodetected values!
     438             : 
     439             : ****************************************************************************/
     440             : 
     441      110760 : static void interpret_interface(char *token)
     442             : {
     443             :         struct sockaddr_storage ss;
     444             :         struct sockaddr_storage ss_mask;
     445             :         struct sockaddr_storage ss_net;
     446             :         struct sockaddr_storage ss_bcast;
     447             :         struct iface_struct ifs;
     448             :         char *p;
     449             :         int i;
     450      110760 :         bool added=false;
     451      110760 :         bool goodaddr = false;
     452      110760 :         uint64_t speed = 0;
     453      110760 :         uint32_t cap = FSCTL_NET_IFACE_NONE_CAPABLE;
     454      110760 :         uint32_t if_index = 0;
     455      110760 :         bool speed_set = false;
     456      110760 :         bool cap_set = false;
     457      110760 :         bool if_index_set = false;
     458             : 
     459             :         /*
     460             :          * extract speed / capability information if present
     461             :          */
     462      110760 :         p = strchr_m(token, ';');
     463      110760 :         if (p != NULL) {
     464           0 :                 *p++ = 0;
     465           0 :                 parse_extra_info(p, &speed, &cap, &if_index);
     466           0 :                 if (speed != 0) {
     467           0 :                         speed_set = true;
     468             :                 }
     469           0 :                 if (cap != FSCTL_NET_IFACE_NONE_CAPABLE) {
     470           0 :                         cap_set = true;
     471             :                 }
     472           0 :                 if (if_index != 0) {
     473           0 :                         if_index_set = true;
     474             :                 }
     475             :         }
     476             : 
     477             :         /* first check if it is an interface name */
     478      364418 :         for (i=0;i<total_probed;i++) {
     479      253658 :                 if (gen_fnmatch(token, probed_ifaces[i].name) == 0) {
     480           0 :                         if (speed_set) {
     481           0 :                                 probed_ifaces[i].linkspeed = speed;
     482             :                         }
     483           0 :                         if (cap_set) {
     484           0 :                                 probed_ifaces[i].capability = cap;
     485             :                         }
     486           0 :                         if (if_index_set) {
     487           0 :                                 probed_ifaces[i].if_index = if_index;
     488             :                         }
     489           0 :                         add_interface(&probed_ifaces[i]);
     490           0 :                         added = true;
     491             :                 }
     492             :         }
     493      110760 :         if (added) {
     494           0 :                 return;
     495             :         }
     496             : 
     497      110760 :         p = strchr_m(token,'/');
     498      110760 :         if (p == NULL) {
     499           0 :                 if (!interpret_string_addr(&ss, token, 0)) {
     500           0 :                         DEBUG(2, ("interpret_interface: Can't find address "
     501             :                                   "for %s\n", token));
     502           0 :                         return;
     503             :                 }
     504             : 
     505           0 :                 for (i=0;i<total_probed;i++) {
     506           0 :                         if (sockaddr_equal((struct sockaddr *)&ss,
     507           0 :                                 (struct sockaddr *)&probed_ifaces[i].ip))
     508             :                         {
     509           0 :                                 if (speed_set) {
     510           0 :                                         probed_ifaces[i].linkspeed = speed;
     511             :                                 }
     512           0 :                                 if (cap_set) {
     513           0 :                                         probed_ifaces[i].capability = cap;
     514             :                                 }
     515           0 :                                 if (if_index_set) {
     516           0 :                                         probed_ifaces[i].if_index = if_index;
     517             :                                 }
     518           0 :                                 add_interface(&probed_ifaces[i]);
     519           0 :                                 return;
     520             :                         }
     521             :                 }
     522           0 :                 DEBUG(2,("interpret_interface: "
     523             :                         "can't determine interface for %s\n",
     524             :                         token));
     525           0 :                 return;
     526             :         }
     527             : 
     528             :         /* parse it into an IP address/netmasklength pair */
     529      110760 :         *p = 0;
     530      110760 :         goodaddr = interpret_string_addr(&ss, token, 0);
     531      110760 :         *p++ = '/';
     532             : 
     533      110760 :         if (!goodaddr) {
     534           0 :                 DEBUG(2,("interpret_interface: "
     535             :                         "can't determine interface for %s\n",
     536             :                         token));
     537           0 :                 return;
     538             :         }
     539             : 
     540      110760 :         if (strlen(p) > 2) {
     541           0 :                 goodaddr = interpret_string_addr(&ss_mask, p, 0);
     542           0 :                 if (!goodaddr) {
     543           0 :                         DEBUG(2,("interpret_interface: "
     544             :                                 "can't determine netmask from %s\n",
     545             :                                 p));
     546           0 :                         return;
     547             :                 }
     548             :         } else {
     549      110760 :                 int error = 0;
     550             :                 unsigned long val;
     551             : 
     552      110760 :                 val = smb_strtoul(p, NULL, 0, &error, SMB_STR_FULL_STR_CONV);
     553      110760 :                 if (error != 0) {
     554           0 :                         DEBUG(2,("interpret_interface: "
     555             :                                 "can't determine netmask value from %s\n",
     556             :                                 p));
     557           0 :                         return;
     558             :                 }
     559      110760 :                 if (!make_netmask(&ss_mask, &ss, val)) {
     560           0 :                         DEBUG(2,("interpret_interface: "
     561             :                                 "can't apply netmask value %lu from %s\n",
     562             :                                 val,
     563             :                                 p));
     564           0 :                         return;
     565             :                 }
     566             :         }
     567             : 
     568      110760 :         make_bcast(&ss_bcast, &ss, &ss_mask);
     569      110760 :         make_net(&ss_net, &ss, &ss_mask);
     570             : 
     571             :         /* Maybe the first component was a broadcast address. */
     572      221520 :         if (sockaddr_equal((struct sockaddr *)&ss_bcast, (struct sockaddr *)&ss) ||
     573      110760 :                 sockaddr_equal((struct sockaddr *)&ss_net, (struct sockaddr *)&ss)) {
     574           0 :                 for (i=0;i<total_probed;i++) {
     575           0 :                         if (same_net((struct sockaddr *)&ss, 
     576           0 :                                                  (struct sockaddr *)&probed_ifaces[i].ip, 
     577             :                                                  (struct sockaddr *)&ss_mask)) {
     578             :                                 /* Temporarily replace netmask on
     579             :                                  * the detected interface - user knows
     580             :                                  * best.... */
     581           0 :                                 struct sockaddr_storage saved_mask =
     582           0 :                                         probed_ifaces[i].netmask;
     583           0 :                                 probed_ifaces[i].netmask = ss_mask;
     584           0 :                                 DEBUG(2,("interpret_interface: "
     585             :                                         "using netmask value %s from "
     586             :                                         "config file on interface %s\n",
     587             :                                         p,
     588             :                                         probed_ifaces[i].name));
     589           0 :                                 if (speed_set) {
     590           0 :                                         probed_ifaces[i].linkspeed = speed;
     591             :                                 }
     592           0 :                                 if (cap_set) {
     593           0 :                                         probed_ifaces[i].capability = cap;
     594             :                                 }
     595           0 :                                 if (if_index_set) {
     596           0 :                                         probed_ifaces[i].if_index = if_index;
     597             :                                 }
     598           0 :                                 add_interface(&probed_ifaces[i]);
     599           0 :                                 probed_ifaces[i].netmask = saved_mask;
     600           0 :                                 return;
     601             :                         }
     602             :                 }
     603           0 :                 DEBUG(2,("interpret_interface: Can't determine ip for "
     604             :                         "broadcast address %s\n",
     605             :                         token));
     606           0 :                 return;
     607             :         }
     608             : 
     609             :         /* Just fake up the interface definition. User knows best. */
     610             : 
     611      110760 :         DEBUG(2,("interpret_interface: Adding interface %s\n",
     612             :                 token));
     613             : 
     614      110760 :         ZERO_STRUCT(ifs);
     615      110760 :         (void)strlcpy(ifs.name, token, sizeof(ifs.name));
     616      110760 :         ifs.flags = IFF_BROADCAST;
     617      110760 :         ifs.ip = ss;
     618      110760 :         ifs.netmask = ss_mask;
     619      110760 :         ifs.bcast = ss_bcast;
     620      110760 :         if (if_index_set) {
     621           0 :                 ifs.if_index = if_index;
     622             :         }
     623      110760 :         if (speed_set) {
     624           0 :                 ifs.linkspeed = speed;
     625             :         } else {
     626      110760 :                 ifs.linkspeed = 1000 * 1000 * 1000;
     627             :         }
     628      110760 :         ifs.capability = cap;
     629      110760 :         add_interface(&ifs);
     630             : }
     631             : 
     632             : /****************************************************************************
     633             :  Load the list of network interfaces.
     634             : ****************************************************************************/
     635             : 
     636       21848 : void load_interfaces(void)
     637             : {
     638       21848 :         struct iface_struct *ifaces = NULL;
     639       21848 :         const char **ptr = lp_interfaces();
     640             :         int i;
     641             : 
     642       21848 :         gfree_interfaces();
     643             : 
     644             :         /* Probe the kernel for interfaces */
     645       21848 :         total_probed = get_interfaces(talloc_tos(), &ifaces);
     646             : 
     647       21848 :         if (total_probed > 0) {
     648       21848 :                 probed_ifaces = (struct iface_struct *)smb_memdup(ifaces,
     649             :                                 sizeof(ifaces[0])*total_probed);
     650       21848 :                 if (!probed_ifaces) {
     651           0 :                         DEBUG(0,("ERROR: smb_memdup failed\n"));
     652           0 :                         exit(1);
     653             :                 }
     654             :         }
     655       21848 :         TALLOC_FREE(ifaces);
     656             : 
     657             :         /* if we don't have a interfaces line then use all broadcast capable
     658             :            interfaces except loopback */
     659       21848 :         if (!ptr || !*ptr || !**ptr) {
     660         108 :                 if (total_probed <= 0) {
     661           0 :                         DEBUG(0,("ERROR: Could not determine network "
     662             :                         "interfaces, you must use a interfaces config line\n"));
     663           0 :                         exit(1);
     664             :                 }
     665         392 :                 for (i=0;i<total_probed;i++) {
     666         286 :                         if (probed_ifaces[i].flags & IFF_BROADCAST) {
     667         143 :                                 add_interface(&probed_ifaces[i]);
     668             :                         }
     669             :                 }
     670         108 :                 return;
     671             :         }
     672             : 
     673       21673 :         if (ptr) {
     674      151823 :                 while (*ptr) {
     675      110760 :                         char *ptr_cpy = SMB_STRDUP(*ptr);
     676      110760 :                         if (ptr_cpy) {
     677      110760 :                                 interpret_interface(ptr_cpy);
     678      110760 :                                 free(ptr_cpy);
     679             :                         }
     680      110760 :                         ptr++;
     681             :                 }
     682             :         }
     683             : 
     684       21740 :         if (!local_interfaces) {
     685           0 :                 DEBUG(0,("WARNING: no network interfaces found\n"));
     686             :         }
     687             : }
     688             : 
     689             : 
     690       22867 : void gfree_interfaces(void)
     691             : {
     692       67083 :         while (local_interfaces) {
     693       23835 :                 struct interface *iface = local_interfaces;
     694       23835 :                 DLIST_REMOVE(local_interfaces, local_interfaces);
     695       23835 :                 SAFE_FREE(iface->name);
     696       23835 :                 SAFE_FREE(iface);
     697             :         }
     698             : 
     699       22867 :         SAFE_FREE(probed_ifaces);
     700       22867 : }
     701             : 
     702             : /****************************************************************************
     703             :  Return True if the list of probed interfaces has changed.
     704             : ****************************************************************************/
     705             : 
     706         620 : bool interfaces_changed(void)
     707             : {
     708         620 :         bool ret = false;
     709             :         int n;
     710         620 :         struct iface_struct *ifaces = NULL;
     711             : 
     712         620 :         n = get_interfaces(talloc_tos(), &ifaces);
     713             : 
     714        1221 :         if ((n > 0 )&& (n != total_probed ||
     715         620 :                         memcmp(ifaces, probed_ifaces, sizeof(ifaces[0])*n))) {
     716           0 :                 ret = true;
     717             :         }
     718             : 
     719         620 :         TALLOC_FREE(ifaces);
     720         620 :         return ret;
     721             : }

Generated by: LCOV version 1.13