ceph/src/common/pick_address.cc

   1 // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
   2 // vim: ts=8 sw=2 smarttab
   3 /*
   4  * Ceph - scalable distributed file system
   5  *
   6  * Copyright (C) 2004-2012 Inktank
   7  *
   8  * This is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License version 2.1, as published by the Free Software
  11  * Foundation.  See file COPYING.
  12  *
  13  */
  14
  15 #include "common/pick_address.h"
  16 #include "include/ipaddr.h"
  17 #include "include/str_list.h"
  18 #include "common/debug.h"
  19 #include "common/errno.h"
  20
  21 #include <netdb.h>
  22
  23 #define dout_subsys ceph_subsys_
  24
  25 static const struct sockaddr *find_ip_in_subnet_list(CephContext *cct,
  26                                                      const struct ifaddrs *ifa,
  27                                                      const std::string &networks)
  28 {
  29   std::list<string> nets;
  30   get_str_list(networks, nets);
  31
  32   for(std::list<string>::iterator s = nets.begin(); s != nets.end(); ++s) {
  33       struct sockaddr_storage net;
  34       unsigned int prefix_len;
  35
  36       if (!parse_network(s->c_str(), &net, &prefix_len)) {
  37         lderr(cct) << "unable to parse network: " << *s << dendl;
  38         exit(1);
  39       }
  40
  41       const struct ifaddrs *found = find_ip_in_subnet(ifa,
  42                                       (struct sockaddr *) &net, prefix_len);
  43       if (found)
  44         return found->ifa_addr;
  45     }
  46
  47   return NULL;
  48 }
  49
  50 // observe this change
  51 struct Observer : public md_config_obs_t {
  52   const char *keys[2];
  53   explicit Observer(const char *c) {
  54     keys[0] = c;
  55     keys[1] = NULL;
  56   }
  57
  58   const char** get_tracked_conf_keys() const override {
  59     return (const char **)keys;
  60   }
  61   void handle_conf_change(const struct md_config_t *conf,
  62                           const std::set <std::string> &changed) override {
  63     // do nothing.
  64   }
  65 };
  66
  67 static void fill_in_one_address(CephContext *cct,
  68                                 const struct ifaddrs *ifa,
  69                                 const string networks,
  70                                 const char *conf_var)
  71 {
  72   const struct sockaddr *found = find_ip_in_subnet_list(cct, ifa, networks);
  73   if (!found) {
  74     lderr(cct) << "unable to find any IP address in networks: " << networks << dendl;
  75     exit(1);
  76   }
  77
  78   char buf[INET6_ADDRSTRLEN];
  79   int err;
  80
  81   err = getnameinfo(found,
  82                     (found->sa_family == AF_INET)
  83                     ? sizeof(struct sockaddr_in)
  84                     : sizeof(struct sockaddr_in6),
  85
  86                     buf, sizeof(buf),
  87                     NULL, 0,
  88                     NI_NUMERICHOST);
  89   if (err != 0) {
  90     lderr(cct) << "unable to convert chosen address to string: " << gai_strerror(err) << dendl;
  91     exit(1);
  92   }
  93
  94   Observer obs(conf_var);
  95
  96   cct->_conf->add_observer(&obs);
  97
  98   cct->_conf->set_val_or_die(conf_var, buf);
  99   cct->_conf->apply_changes(NULL);
 100
 101   cct->_conf->remove_observer(&obs);
 102 }
 103
 104 void pick_addresses(CephContext *cct, int needs)
 105 {
 106   struct ifaddrs *ifa;
 107   int r = getifaddrs(&ifa);
 108   if (r<0) {
 109     string err = cpp_strerror(errno);
 110     lderr(cct) << "unable to fetch interfaces and addresses: " << err << dendl;
 111     exit(1);
 112   }
 113
 114
 115   if ((needs & CEPH_PICK_ADDRESS_PUBLIC)
 116       && cct->_conf->public_addr.is_blank_ip()
 117       && !cct->_conf->public_network.empty()) {
 118     fill_in_one_address(cct, ifa, cct->_conf->public_network, "public_addr");
 119   }
 120
 121   if ((needs & CEPH_PICK_ADDRESS_CLUSTER)
 122       && cct->_conf->cluster_addr.is_blank_ip()) {
 123     if (!cct->_conf->cluster_network.empty()) {
 124       fill_in_one_address(cct, ifa, cct->_conf->cluster_network, "cluster_addr");
 125     } else {
 126       if (!cct->_conf->public_network.empty()) {
 127         lderr(cct) << "Public network was set, but cluster network was not set " << dendl;
 128         lderr(cct) << "    Using public network also for cluster network" << dendl;
 129         fill_in_one_address(cct, ifa, cct->_conf->public_network, "cluster_addr");
 130       }
 131     }
 132   }
 133
 134   freeifaddrs(ifa);
 135 }
 136
 137
 138 std::string pick_iface(CephContext *cct, const struct sockaddr_storage &network)
 139 {
 140   struct ifaddrs *ifa;
 141   int r = getifaddrs(&ifa);
 142   if (r < 0) {
 143     string err = cpp_strerror(errno);
 144     lderr(cct) << "unable to fetch interfaces and addresses: " << err << dendl;
 145     return {};
 146   }
 147
 148   unsigned int prefix_len = 0;
 149   const struct ifaddrs *found = find_ip_in_subnet(ifa,
 150                                   (const struct sockaddr *) &network, prefix_len);
 151
 152   std::string result;
 153   if (found) {
 154     result = found->ifa_name;
 155   }
 156
 157   freeifaddrs(ifa);
 158
 159   return result;
 160 }
 161
 162
 163 bool have_local_addr(CephContext *cct, const list<entity_addr_t>& ls, entity_addr_t *match)
 164 {
 165   struct ifaddrs *ifa;
 166   int r = getifaddrs(&ifa);
 167   if (r < 0) {
 168     lderr(cct) << "unable to fetch interfaces and addresses: " << cpp_strerror(errno) << dendl;
 169     exit(1);
 170   }
 171
 172   bool found = false;
 173   for (struct ifaddrs *addrs = ifa; addrs != NULL; addrs = addrs->ifa_next) {
 174     if (addrs->ifa_addr) {
 175       entity_addr_t a;
 176       a.set_sockaddr(addrs->ifa_addr);
 177       for (list<entity_addr_t>::const_iterator p = ls.begin(); p != ls.end(); ++p) {
 178         if (a.is_same_host(*p)) {
 179           *match = *p;
 180           found = true;
 181           goto out;
 182         }
 183       }
 184     }
 185   }
 186
 187  out:
 188   freeifaddrs(ifa);
 189   return found;
 190 }