LCOV - code coverage report
Current view: top level - source4/heimdal/lib/krb5 - get_addrs.c (source / functions) Hit Total Coverage
Test: coverage report for abartlet/fix-coverage dd10fb34 Lines: 0 129 0.0 %
Date: 2021-09-23 10:06:22 Functions: 0 5 0.0 %

          Line data    Source code
       1             : /*
       2             :  * Copyright (c) 1997 - 2002 Kungliga Tekniska Högskolan
       3             :  * (Royal Institute of Technology, Stockholm, Sweden).
       4             :  * All rights reserved.
       5             :  *
       6             :  * Redistribution and use in source and binary forms, with or without
       7             :  * modification, are permitted provided that the following conditions
       8             :  * are met:
       9             :  *
      10             :  * 1. Redistributions of source code must retain the above copyright
      11             :  *    notice, this list of conditions and the following disclaimer.
      12             :  *
      13             :  * 2. Redistributions in binary form must reproduce the above copyright
      14             :  *    notice, this list of conditions and the following disclaimer in the
      15             :  *    documentation and/or other materials provided with the distribution.
      16             :  *
      17             :  * 3. Neither the name of the Institute nor the names of its contributors
      18             :  *    may be used to endorse or promote products derived from this software
      19             :  *    without specific prior written permission.
      20             :  *
      21             :  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
      22             :  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
      23             :  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
      24             :  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
      25             :  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
      26             :  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
      27             :  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
      28             :  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
      29             :  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
      30             :  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
      31             :  * SUCH DAMAGE.
      32             :  */
      33             : 
      34             : #include "krb5_locl.h"
      35             : 
      36             : #ifdef __osf__
      37             : /* hate */
      38             : struct rtentry;
      39             : struct mbuf;
      40             : #endif
      41             : #ifdef HAVE_NET_IF_H
      42             : #include <net/if.h>
      43             : #endif
      44             : #include <ifaddrs.h>
      45             : 
      46             : static krb5_error_code
      47           0 : gethostname_fallback (krb5_context context, krb5_addresses *res)
      48             : {
      49             :     krb5_error_code ret;
      50             :     char hostname[MAXHOSTNAMELEN];
      51             :     struct hostent *hostent;
      52             : 
      53           0 :     if (gethostname (hostname, sizeof(hostname))) {
      54           0 :         ret = errno;
      55           0 :         krb5_set_error_message(context, ret, "gethostname: %s", strerror(ret));
      56           0 :         return ret;
      57             :     }
      58           0 :     hostent = roken_gethostbyname (hostname);
      59           0 :     if (hostent == NULL) {
      60           0 :         ret = errno;
      61           0 :         krb5_set_error_message (context, ret, "gethostbyname %s: %s",
      62             :                                 hostname, strerror(ret));
      63           0 :         return ret;
      64             :     }
      65           0 :     res->len = 1;
      66           0 :     res->val = malloc (sizeof(*res->val));
      67           0 :     if (res->val == NULL) {
      68           0 :         krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", ""));
      69           0 :         return ENOMEM;
      70             :     }
      71           0 :     res->val[0].addr_type = hostent->h_addrtype;
      72           0 :     res->val[0].address.data = NULL;
      73           0 :     res->val[0].address.length = 0;
      74           0 :     ret = krb5_data_copy (&res->val[0].address,
      75           0 :                           hostent->h_addr,
      76           0 :                           hostent->h_length);
      77           0 :     if (ret) {
      78           0 :         free (res->val);
      79           0 :         return ret;
      80             :     }
      81           0 :     return 0;
      82             : }
      83             : 
      84             : enum {
      85             :     LOOP            = 1,        /* do include loopback addrs */
      86             :     LOOP_IF_NONE    = 2,        /* include loopback addrs if no others */
      87             :     EXTRA_ADDRESSES = 4,        /* include extra addresses */
      88             :     SCAN_INTERFACES = 8         /* scan interfaces for addresses */
      89             : };
      90             : 
      91             : /*
      92             :  * Try to figure out the addresses of all configured interfaces with a
      93             :  * lot of magic ioctls.
      94             :  */
      95             : 
      96             : static krb5_error_code
      97           0 : find_all_addresses (krb5_context context, krb5_addresses *res, int flags)
      98             : {
      99             :     struct sockaddr sa_zero;
     100             :     struct ifaddrs *ifa0, *ifa;
     101           0 :     krb5_error_code ret = ENXIO;
     102             :     unsigned int num, idx;
     103             :     krb5_addresses ignore_addresses;
     104             : 
     105           0 :     if (getifaddrs(&ifa0) == -1) {
     106           0 :         ret = errno;
     107           0 :         krb5_set_error_message(context, ret, "getifaddrs: %s", strerror(ret));
     108           0 :         return (ret);
     109             :     }
     110             : 
     111           0 :     memset(&sa_zero, 0, sizeof(sa_zero));
     112             : 
     113             :     /* First, count all the ifaddrs. */
     114           0 :     for (ifa = ifa0, num = 0; ifa != NULL; ifa = ifa->ifa_next, num++)
     115             :         /* nothing */;
     116             : 
     117           0 :     if (num == 0) {
     118           0 :         freeifaddrs(ifa0);
     119           0 :         krb5_set_error_message(context, ENXIO, N_("no addresses found", ""));
     120           0 :         return (ENXIO);
     121             :     }
     122             : 
     123           0 :     if (flags & EXTRA_ADDRESSES) {
     124             :         /* we'll remove the addresses we don't care about */
     125           0 :         ret = krb5_get_ignore_addresses(context, &ignore_addresses);
     126           0 :         if(ret)
     127           0 :             return ret;
     128             :     }
     129             : 
     130             :     /* Allocate storage for them. */
     131           0 :     res->val = calloc(num, sizeof(*res->val));
     132           0 :     if (res->val == NULL) {
     133           0 :         if (flags & EXTRA_ADDRESSES)
     134           0 :             krb5_free_addresses(context, &ignore_addresses);
     135           0 :         freeifaddrs(ifa0);
     136           0 :         krb5_set_error_message(context, ENOMEM, N_("malloc: out of memory", ""));
     137           0 :         return ENOMEM;
     138             :     }
     139             : 
     140             :     /* Now traverse the list. */
     141           0 :     for (ifa = ifa0, idx = 0; ifa != NULL; ifa = ifa->ifa_next) {
     142           0 :         if ((ifa->ifa_flags & IFF_UP) == 0)
     143           0 :             continue;
     144           0 :         if (ifa->ifa_addr == NULL)
     145           0 :             continue;
     146           0 :         if (memcmp(ifa->ifa_addr, &sa_zero, sizeof(sa_zero)) == 0)
     147           0 :             continue;
     148           0 :         if (krb5_sockaddr_uninteresting(ifa->ifa_addr))
     149           0 :             continue;
     150           0 :         if (krb5_sockaddr_is_loopback(ifa->ifa_addr) && (flags & LOOP) == 0)
     151             :             /* We'll deal with the LOOP_IF_NONE case later. */
     152           0 :             continue;
     153             : 
     154           0 :         ret = krb5_sockaddr2address(context, ifa->ifa_addr, &res->val[idx]);
     155           0 :         if (ret) {
     156             :             /*
     157             :              * The most likely error here is going to be "Program
     158             :              * lacks support for address type".  This is no big
     159             :              * deal -- just continue, and we'll listen on the
     160             :              * addresses who's type we *do* support.
     161             :              */
     162           0 :             continue;
     163             :         }
     164             :         /* possibly skip this address? */
     165           0 :         if((flags & EXTRA_ADDRESSES) &&
     166           0 :            krb5_address_search(context, &res->val[idx], &ignore_addresses)) {
     167           0 :             krb5_free_address(context, &res->val[idx]);
     168           0 :             flags &= ~LOOP_IF_NONE; /* we actually found an address,
     169             :                                        so don't add any loop-back
     170             :                                        addresses */
     171           0 :             continue;
     172             :         }
     173             : 
     174           0 :         idx++;
     175             :     }
     176             : 
     177             :     /*
     178             :      * If no addresses were found, and LOOP_IF_NONE is set, then find
     179             :      * the loopback addresses and add them to our list.
     180             :      */
     181           0 :     if ((flags & LOOP_IF_NONE) != 0 && idx == 0) {
     182           0 :         for (ifa = ifa0; ifa != NULL; ifa = ifa->ifa_next) {
     183           0 :             if ((ifa->ifa_flags & IFF_UP) == 0)
     184           0 :                 continue;
     185           0 :             if (ifa->ifa_addr == NULL)
     186           0 :                 continue;
     187           0 :             if (memcmp(ifa->ifa_addr, &sa_zero, sizeof(sa_zero)) == 0)
     188           0 :                 continue;
     189           0 :             if (krb5_sockaddr_uninteresting(ifa->ifa_addr))
     190           0 :                 continue;
     191           0 :             if (!krb5_sockaddr_is_loopback(ifa->ifa_addr))
     192           0 :                 continue;
     193           0 :             if ((ifa->ifa_flags & IFF_LOOPBACK) == 0)
     194             :                 /* Presumably loopback addrs are only used on loopback ifs! */
     195           0 :                 continue;
     196           0 :             ret = krb5_sockaddr2address(context,
     197           0 :                                         ifa->ifa_addr, &res->val[idx]);
     198           0 :             if (ret)
     199           0 :                 continue; /* We don't consider this failure fatal */
     200           0 :             if((flags & EXTRA_ADDRESSES) &&
     201           0 :                krb5_address_search(context, &res->val[idx],
     202             :                                    &ignore_addresses)) {
     203           0 :                 krb5_free_address(context, &res->val[idx]);
     204           0 :                 continue;
     205             :             }
     206           0 :             idx++;
     207             :         }
     208             :     }
     209             : 
     210           0 :     if (flags & EXTRA_ADDRESSES)
     211           0 :         krb5_free_addresses(context, &ignore_addresses);
     212           0 :     freeifaddrs(ifa0);
     213           0 :     if (ret) {
     214           0 :         free(res->val);
     215           0 :         res->val = NULL;
     216             :     } else
     217           0 :         res->len = idx;        /* Now a count. */
     218           0 :     return (ret);
     219             : }
     220             : 
     221             : static krb5_error_code
     222           0 : get_addrs_int (krb5_context context, krb5_addresses *res, int flags)
     223             : {
     224           0 :     krb5_error_code ret = -1;
     225             : 
     226           0 :     res->len = 0;
     227           0 :     res->val = NULL;
     228             : 
     229           0 :     if (flags & SCAN_INTERFACES) {
     230           0 :         ret = find_all_addresses (context, res, flags);
     231           0 :         if(ret || res->len == 0)
     232           0 :             ret = gethostname_fallback (context, res);
     233             :     } else {
     234           0 :         ret = 0;
     235             :     }
     236             : 
     237           0 :     if(ret == 0 && (flags & EXTRA_ADDRESSES)) {
     238             :         krb5_addresses a;
     239             :         /* append user specified addresses */
     240           0 :         ret = krb5_get_extra_addresses(context, &a);
     241           0 :         if(ret) {
     242           0 :             krb5_free_addresses(context, res);
     243           0 :             return ret;
     244             :         }
     245           0 :         ret = krb5_append_addresses(context, res, &a);
     246           0 :         if(ret) {
     247           0 :             krb5_free_addresses(context, res);
     248           0 :             return ret;
     249             :         }
     250           0 :         krb5_free_addresses(context, &a);
     251             :     }
     252           0 :     if(res->len == 0) {
     253           0 :         free(res->val);
     254           0 :         res->val = NULL;
     255             :     }
     256           0 :     return ret;
     257             : }
     258             : 
     259             : /*
     260             :  * Try to get all addresses, but return the one corresponding to
     261             :  * `hostname' if we fail.
     262             :  *
     263             :  * Only include loopback address if there are no other.
     264             :  */
     265             : 
     266             : KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
     267           0 : krb5_get_all_client_addrs (krb5_context context, krb5_addresses *res)
     268             : {
     269           0 :     int flags = LOOP_IF_NONE | EXTRA_ADDRESSES;
     270             : 
     271           0 :     if (context->scan_interfaces)
     272           0 :         flags |= SCAN_INTERFACES;
     273             : 
     274           0 :     return get_addrs_int (context, res, flags);
     275             : }
     276             : 
     277             : /*
     278             :  * Try to get all local addresses that a server should listen to.
     279             :  * If that fails, we return the address corresponding to `hostname'.
     280             :  */
     281             : 
     282             : KRB5_LIB_FUNCTION krb5_error_code KRB5_LIB_CALL
     283           0 : krb5_get_all_server_addrs (krb5_context context, krb5_addresses *res)
     284             : {
     285           0 :     return get_addrs_int (context, res, LOOP | SCAN_INTERFACES);
     286             : }

Generated by: LCOV version 1.13