ceph/src/common/dns_resolve.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) 2016 SUSE LINUX GmbH
   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 <arpa/inet.h>
  16
  17 #include "include/scope_guard.h"
  18 #include "dns_resolve.h"
  19 #include "common/debug.h"
  20
  21 #define dout_subsys ceph_subsys_
  22
  23 using namespace std;
  24
  25 namespace ceph {
  26
  27 #ifdef HAVE_RES_NQUERY
  28
  29 int ResolvHWrapper::res_nquery(res_state s, const char *hostname, int cls,
  30     int type, u_char *buf, int bufsz) {
  31   return ::res_nquery(s, hostname, cls, type, buf, bufsz);
  32 }
  33
  34 int ResolvHWrapper::res_nsearch(res_state s, const char *hostname, int cls,
  35     int type, u_char *buf, int bufsz) {
  36   return ::res_nsearch(s, hostname, cls, type, buf, bufsz);
  37 }
  38
  39 #else
  40
  41 int ResolvHWrapper::res_query(const char *hostname, int cls,
  42     int type, u_char *buf, int bufsz) {
  43   return ::res_query(hostname, cls, type, buf, bufsz);
  44 }
  45
  46 int ResolvHWrapper::res_search(const char *hostname, int cls,
  47     int type, u_char *buf, int bufsz) {
  48   return ::res_search(hostname, cls, type, buf, bufsz);
  49 }
  50
  51 #endif
  52
  53 DNSResolver::~DNSResolver()
  54 {
  55 #ifdef HAVE_RES_NQUERY
  56   list<res_state>::iterator iter;
  57   for (iter = states.begin(); iter != states.end(); ++iter) {
  58     struct __res_state *s = *iter;
  59     delete s;
  60   }
  61 #endif
  62   delete resolv_h;
  63 }
  64
  65 #ifdef HAVE_RES_NQUERY
  66 int DNSResolver::get_state(CephContext *cct, res_state *ps)
  67 {
  68   lock.Lock();
  69   if (!states.empty()) {
  70     res_state s = states.front();
  71     states.pop_front();
  72     lock.Unlock();
  73     *ps = s;
  74     return 0;
  75   }
  76   lock.Unlock();
  77   struct __res_state *s = new struct __res_state;
  78   s->options = 0;
  79   if (res_ninit(s) < 0) {
  80     delete s;
  81     lderr(cct) << "ERROR: failed to call res_ninit()" << dendl;
  82     return -EINVAL;
  83   }
  84   *ps = s;
  85   return 0;
  86 }
  87
  88 void DNSResolver::put_state(res_state s)
  89 {
  90   Mutex::Locker l(lock);
  91   states.push_back(s);
  92 }
  93 #endif
  94
  95 int DNSResolver::resolve_cname(CephContext *cct, const string& hostname,
  96     string *cname, bool *found)
  97 {
  98   *found = false;
  99
 100 #ifdef HAVE_RES_NQUERY
 101   res_state res;
 102   int r = get_state(cct, &res);
 103   if (r < 0) {
 104     return r;
 105   }
 106   auto put_state = make_scope_guard([res, this] {
 107       this->put_state(res);
 108     });
 109 #endif
 110
 111 #define LARGE_ENOUGH_DNS_BUFSIZE 1024
 112   unsigned char buf[LARGE_ENOUGH_DNS_BUFSIZE];
 113
 114 #define MAX_FQDN_SIZE 255
 115   char host[MAX_FQDN_SIZE + 1];
 116   const char *origname = hostname.c_str();
 117   unsigned char *pt, *answer;
 118   unsigned char *answend;
 119   int len;
 120
 121 #ifdef HAVE_RES_NQUERY
 122   len = resolv_h->res_nquery(res, origname, ns_c_in, ns_t_cname, buf, sizeof(buf));
 123 #else
 124   {
 125 # ifndef HAVE_THREAD_SAFE_RES_QUERY
 126     Mutex::Locker l(lock);
 127 # endif
 128     len = resolv_h->res_query(origname, ns_c_in, ns_t_cname, buf, sizeof(buf));
 129   }
 130 #endif
 131   if (len < 0) {
 132     lderr(cct) << "res_query() failed" << dendl;
 133     return 0;
 134   }
 135
 136   answer = buf;
 137   pt = answer + NS_HFIXEDSZ;
 138   answend = answer + len;
 139
 140   /* read query */
 141   if ((len = dn_expand(answer, answend, pt, host, sizeof(host))) < 0) {
 142     lderr(cct) << "ERROR: dn_expand() failed" << dendl;
 143     return -EINVAL;
 144   }
 145   pt += len;
 146
 147   if (pt + 4 > answend) {
 148     lderr(cct) << "ERROR: bad reply" << dendl;
 149     return -EIO;
 150   }
 151
 152   int type;
 153   NS_GET16(type, pt);
 154
 155   if (type != ns_t_cname) {
 156     lderr(cct) << "ERROR: failed response type: type=" << type <<
 157       " (was expecting " << ns_t_cname << ")" << dendl;
 158     return -EIO;
 159   }
 160
 161   pt += NS_INT16SZ; /* class */
 162
 163   /* read answer */
 164   if ((len = dn_expand(answer, answend, pt, host, sizeof(host))) < 0) {
 165     return 0;
 166   }
 167   pt += len;
 168   ldout(cct, 20) << "name=" << host << dendl;
 169
 170   if (pt + 10 > answend) {
 171     lderr(cct) << "ERROR: bad reply" << dendl;
 172     return -EIO;
 173   }
 174
 175   NS_GET16(type, pt);
 176   pt += NS_INT16SZ; /* class */
 177   pt += NS_INT32SZ; /* ttl */
 178   pt += NS_INT16SZ; /* size */
 179
 180   if ((len = dn_expand(answer, answend, pt, host, sizeof(host))) < 0) {
 181     return 0;
 182   }
 183   ldout(cct, 20) << "cname host=" << host << dendl;
 184   *cname = host;
 185
 186   *found = true;
 187   return 0;
 188 }
 189
 190
 191 int DNSResolver::resolve_ip_addr(CephContext *cct, const string& hostname,
 192     entity_addr_t *addr) {
 193
 194 #ifdef HAVE_RES_NQUERY
 195   res_state res;
 196   int r = get_state(cct, &res);
 197   if (r < 0) {
 198     return r;
 199   }
 200   auto put_state = make_scope_guard([res, this] {
 201       this->put_state(res);
 202     });
 203   return this->resolve_ip_addr(cct, &res, hostname, addr);
 204 #else
 205   return this->resolve_ip_addr(cct, NULL, hostname, addr);
 206 #endif
 207
 208 }
 209
 210 int DNSResolver::resolve_ip_addr(CephContext *cct, res_state *res, const string& hostname,
 211     entity_addr_t *addr) {
 212
 213   u_char nsbuf[NS_PACKETSZ];
 214   int len;
 215
 216
 217 #ifdef HAVE_RES_NQUERY
 218   len = resolv_h->res_nquery(*res, hostname.c_str(), ns_c_in, ns_t_a, nsbuf, sizeof(nsbuf));
 219 #else
 220   {
 221 # ifndef HAVE_THREAD_SAFE_RES_QUERY
 222     Mutex::Locker l(lock);
 223 # endif
 224     len = resolv_h->res_query(hostname.c_str(), ns_c_in, ns_t_a, nsbuf, sizeof(nsbuf));
 225   }
 226 #endif
 227   if (len < 0) {
 228     lderr(cct) << "res_query() failed" << dendl;
 229     return len;
 230   }
 231   else if (len == 0) {
 232     ldout(cct, 20) << "no address found for hostname " << hostname << dendl;
 233     return -1;
 234   }
 235
 236   ns_msg handle;
 237   ns_initparse(nsbuf, len, &handle);
 238
 239   if (ns_msg_count(handle, ns_s_an) == 0) {
 240     ldout(cct, 20) << "no address found for hostname " << hostname << dendl;
 241     return -1;
 242   }
 243
 244   ns_rr rr;
 245   int r;
 246   if ((r = ns_parserr(&handle, ns_s_an, 0, &rr)) < 0) {
 247       lderr(cct) << "error while parsing DNS record" << dendl;
 248       return r;
 249   }
 250
 251   char addr_buf[64];
 252   memset(addr_buf, 0, sizeof(addr_buf));
 253   inet_ntop(AF_INET, ns_rr_rdata(rr), addr_buf, sizeof(addr_buf));
 254   if (!addr->parse(addr_buf)) {
 255       lderr(cct) << "failed to parse address '" << (const char *)ns_rr_rdata(rr)
 256         << "'" << dendl;
 257       return -1;
 258   }
 259
 260   return 0;
 261 }
 262
 263 int DNSResolver::resolve_srv_hosts(CephContext *cct, const string& service_name,
 264     const SRV_Protocol trans_protocol,
 265     map<string, DNSResolver::Record> *srv_hosts) {
 266   return this->resolve_srv_hosts(cct, service_name, trans_protocol, "", srv_hosts);
 267 }
 268
 269 int DNSResolver::resolve_srv_hosts(CephContext *cct, const string& service_name,
 270     const SRV_Protocol trans_protocol, const string& domain,
 271     map<string, DNSResolver::Record> *srv_hosts) {
 272
 273 #ifdef HAVE_RES_NQUERY
 274   res_state res;
 275   int r = get_state(cct, &res);
 276   if (r < 0) {
 277     return r;
 278   }
 279   auto put_state = make_scope_guard([res, this] {
 280       this->put_state(res);
 281     });
 282 #endif
 283
 284   u_char nsbuf[NS_PACKETSZ];
 285   int num_hosts;
 286
 287   string proto_str = srv_protocol_to_str(trans_protocol);
 288   string query_str = "_"+service_name+"._"+proto_str+(domain.empty() ? ""
 289       : "."+domain);
 290   int len;
 291
 292 #ifdef HAVE_RES_NQUERY
 293   len = resolv_h->res_nsearch(res, query_str.c_str(), ns_c_in, ns_t_srv, nsbuf,
 294       sizeof(nsbuf));
 295 #else
 296   {
 297 # ifndef HAVE_THREAD_SAFE_RES_QUERY
 298     Mutex::Locker l(lock);
 299 # endif
 300     len = resolv_h->res_search(query_str.c_str(), ns_c_in, ns_t_srv, nsbuf,
 301         sizeof(nsbuf));
 302   }
 303 #endif
 304   if (len < 0) {
 305     lderr(cct) << "failed for service " << query_str << dendl;
 306     return len;
 307   }
 308   else if (len == 0) {
 309     ldout(cct, 20) << "No hosts found for service " << query_str << dendl;
 310     return 0;
 311   }
 312
 313   ns_msg handle;
 314
 315   ns_initparse(nsbuf, len, &handle);
 316
 317   num_hosts = ns_msg_count (handle, ns_s_an);
 318   if (num_hosts == 0) {
 319     ldout(cct, 20) << "No hosts found for service " << query_str << dendl;
 320     return 0;
 321   }
 322
 323   ns_rr rr;
 324   char full_target[NS_MAXDNAME];
 325
 326   for (int i = 0; i < num_hosts; i++) {
 327     int r;
 328     if ((r = ns_parserr(&handle, ns_s_an, i, &rr)) < 0) {
 329       lderr(cct) << "Error while parsing DNS record" << dendl;
 330       return r;
 331     }
 332
 333     string full_srv_name = ns_rr_name(rr);
 334     string protocol = "_" + proto_str;
 335     string srv_domain = full_srv_name.substr(full_srv_name.find(protocol)
 336         + protocol.length());
 337
 338     auto rdata = ns_rr_rdata(rr);
 339     uint16_t priority = ns_get16(rdata); rdata += NS_INT16SZ;
 340     rdata += NS_INT16SZ;        // weight
 341     uint16_t port = ns_get16(rdata); rdata += NS_INT16SZ;
 342     memset(full_target, 0, sizeof(full_target));
 343     ns_name_uncompress(ns_msg_base(handle), ns_msg_end(handle),
 344                        rdata, full_target, sizeof(full_target));
 345
 346     entity_addr_t addr;
 347 #ifdef HAVE_RES_NQUERY
 348     r = this->resolve_ip_addr(cct, &res, full_target, &addr);
 349 #else
 350     r = this->resolve_ip_addr(cct, NULL, full_target, &addr);
 351 #endif
 352
 353     if (r == 0) {
 354       addr.set_port(port);
 355       string target = full_target;
 356       auto end = target.find(srv_domain);
 357       if (end == target.npos) {
 358         lderr(cct) << "resolved target not in search domain: "
 359                    << target << " / " << srv_domain << dendl;
 360         return -EINVAL;
 361       }
 362       target = target.substr(0, end);
 363       (*srv_hosts)[target] = {priority, addr};
 364     }
 365   }
 366   return 0;
 367 }
 368
 369 }