practicas/pipi/src/nameserver.cpp

   1 #include "nameserver.h"
   2 #include <sstream>
   3 #include <algorithm>
   4 #include <iterator>
   5 #include <sstream>
   6 #include <functional>
   7 #ifdef DEBUG
   8 #include <iostream>
   9 #endif
  10
  11 NameServer::Name::Name(const std::string& s)
  12 {
  13     std::istringstream iss(s);
  14     std::string tok;
  15     while (std::getline(iss, tok, '.'))
  16         push_back(tok);
  17 }
  18
  19 std::ostream& operator<< (std::ostream& os, const NameServer::Name& name)
  20 {
  21     if (name.empty())
  22         return os;
  23     std::copy(name.begin(), name.end() - 1,
  24             std::ostream_iterator< std::string >(os, "."));
  25     return os << name.back();
  26 }
  27
  28 NameServer::Name::operator std::string () const
  29 {
  30     std::stringstream ss;
  31     ss << *this;
  32     return ss.str();
  33 }
  34
  35 /// Parsea una zona
  36 static std::istream& parsezone(std::istream& is, NameServer::Zone& z)
  37     throw (std::runtime_error)
  38 {
  39     std::string line, sname, ip;
  40     // [dominio] [ttl] [parent ip]
  41     while (std::getline(is, line) && (line == "")); // Salteo líneas en blanco
  42     if (!is)
  43         return is;
  44     std::istringstream iss(line);
  45     if (!(iss >> sname >> z.ttl >> ip))
  46         throw std::runtime_error("Error al parsear");
  47     z.name = sname;
  48 #ifdef DEBUG_PARSER
  49     std::cout << "NameServer::parsezone: IP = " << ip << "\n\n";
  50 #endif
  51     z.parent = IPAddr(ip);
  52     // un record por linea, sin líneas vacías
  53     // [name] [type] [ip]
  54     while (std::getline(is, line) && (line != ""))
  55     {
  56         iss.clear();
  57         iss.str(line);
  58         std::string key, type;
  59         if (!(iss >> key >> type >> ip))
  60             throw std::runtime_error("Error al parsear");
  61         typedef NameServer::Record Rec;
  62 #ifdef DEBUG_PARSER
  63         std::cout << "NameServer::parsezone: IP = " << ip << "\n\n";
  64 #endif
  65         Rec r((type == "NS") ? Rec::NS : Rec::A, IPAddr(ip));
  66         z.records.insert(NameServer::Zone::records_t::value_type(key, r));
  67     }
  68 #ifdef DEBUG_PARSER
  69     std::cout << "NameServer::parsezone: " << z << "\n\n";
  70 #endif
  71     return is;
  72 }
  73
  74 /// Constructor
  75 NameServer::Zone::Zone(std::string sname, size_t ttl, const IPAddr& parent):
  76     name(sname), ttl(ttl), parent(parent)
  77 {
  78 }
  79
  80 /// Constructor
  81 NameServer::Zone::Zone(std::istream& is)
  82     throw (std::runtime_error)
  83 {
  84     // Parsea la zona
  85     if (!parsezone(is, *this))
  86         throw std::runtime_error("Error de parser, no hay zona");
  87 }
  88
  89 /// Limpia una zona
  90 void NameServer::Zone::clear()
  91 {
  92     name.clear();
  93     records.clear();
  94 }
  95
  96 /// Constructor
  97 NameServer::NameServer(std::istream& is, IPIn& ipin, IPOut& ipout,
  98         DevQue& req_que, DevQue& res_que, DevQue& snd_que)
  99     throw (std::runtime_error):
 100     ipin(ipin), ipout(ipout), req_que(req_que), res_que(res_que),
 101         snd_que(snd_que)
 102 {
 103     Zone z;
 104     while (parsezone(is, z))
 105     {
 106         zones.push_back(z);
 107         z.clear();
 108 #ifdef DEBUG_PARSER
 109         std::cout << "NameServer::NameServer: " << z << "\n\n";
 110 #endif
 111     }
 112
 113 #ifdef DEBUG_RESOLV
 114     std::cout << "NameServer::NameServer: req_que_id = " << req_que.que_id
 115         << ", res_que_id = " << res_que.que_id
 116         << ", snd_que_id = " << snd_que.que_id << "\n";
 117 #endif
 118 }
 119
 120 /// Devuelve la parte izquierda de n, si la parte derecha coincide exactamente
 121 /// con m, si no devuelve un vector vacío.
 122 /// Elemplo: name_split("mi.domi.nio", "domi.nio") == ["mi"]
 123 ///          name_split("dos.mi.domi.nio", "domi.nio") == ["dos", "mi"]
 124 ///          name_split("domi.nio", "domi.nio") == []
 125 ///          name_split("papeli.nio", "domi.nio") == []
 126 static NameServer::Name
 127 name_split(NameServer::Name n, NameServer::Name m)
 128 {
 129     NameServer::Name r;
 130     std::reverse(n.begin(), n.end());
 131     std::reverse(m.begin(), m.end());
 132     // Si m es más grande o igual que n, no hay nada que hacer
 133     if (n.size() <= m.size())
 134         return r;
 135     // Si no coincide la parte derecha, no hay nada que hacer
 136     NameServer::Name::size_type i;
 137     for (i = 0; i < m.size(); ++i)
 138         if (n[i] != m[i])
 139             return r;
 140     // Si era todo igual y sobran cosas, devolvemos lo que "sobra"
 141     while (i < n.size())
 142         r.push_back(n[i++]);
 143     std::reverse(r.begin(), r.end());
 144 #ifdef DEBUG_NAME
 145     std::cout << "NameServer::name_split(" << n << ", " << m << ") -> "
 146         << r << "\n";
 147 #endif
 148     return r;
 149 }
 150
 151 /// Devuelve -1 si es un nombre "hijo" (la parte derecha de n está contenida
 152 /// completamente en m, pero m y n no son iguales), 0 si m == n y 1 si es
 153 /// "padre" (m no coincide con la parte derecha de n).
 154 /// Elemplo: namecmp("mi.domi.nio", "domi.nio") == -1
 155 ///          namecmp("otra.cosa", "domi.nio") == 1
 156 ///          namecmp("papeli.nio", "domi.nio") == 1
 157 ///          namecmp("domi.nio", "domi.nio") == 0
 158 /*enum name_cmp_t
 159 {
 160     NC_DIRECT_CHILD,  ///> Hijo directo, es decir, está en la zona m
 161     NC_CHILD,         ///> Hijo indirecto, está en una zona que cuelga de m
 162     NC_EQUAL,         ///> Es el host de la zona m
 163     NC_DIRECT_PARENT, ///> Padre directo, es decir, coincide en parte con m
 164     NC_PARENT         ///> Padre indirecto, es completamente distinto a m
 165 };*/
 166 #if 0
 167 static int name_cmp(const NameServer::Name& n, const NameServer::Name& m)
 168 {
 169     // Si m es más grande que n, seguro es padre
 170     if (n.size() < m.size())
 171         return 1;
 172     // Si no coincide la parte derecha, seguro es padre
 173     NameServer::Name::size_type i;
 174     for (i = m.size(); i > 0; --i)
 175         if (n[i-1] != m[i-1])
 176             return 1;
 177     // Si era todo igual y sobran cosas, es hijo
 178     if (i)
 179         return -1;
 180     // Si no, son iguales.
 181     return 0;
 182 }
 183 #endif
 184
 185 struct search_zone: std::unary_function< NameServer::Zone, bool >
 186 {
 187     bool local;
 188     ResolvProtoResponse resp;
 189     const NameServer::Name& name;
 190     search_zone(const NameServer::Name& n): local(false), name(n) {}
 191     bool operator() (const NameServer::Zone& z)
 192     {
 193         bool found = false;
 194         NameServer::Name local_part = name_split(name, z.name);
 195         if (!local_part.empty()) // Está en esta zona
 196         {
 197             local = true;
 198             std::string n = local_part.back(); // Obtengo última parte
 199             // busco
 200             typedef NameServer::Zone::records_t::const_iterator itt;
 201             std::pair<itt, itt> p = z.records.equal_range(n);
 202             for (; p.first != p.second; ++p.first)
 203             {
 204                 const NameServer::Record& r = (*p.first).second;
 205                 // Tiene que buscar solo A porque era un nombre
 206                 if ((local_part.size() == 1) && (r.type != NameServer::Record::A))
 207                     continue;
 208                 // Tiene que seguir para abajo, solo busca NS
 209                 if ((local_part.size() > 1) && r.type != NameServer::Record::NS)
 210                     continue;
 211                 found = true;
 212                 resp.ret = (r.type == NameServer::Record::NS) ? RP_RES_NS
 213                     : RP_RES_A;
 214                 resp.ttl = z.ttl;
 215                 resp.ips.push_back(r.ip);
 216             }
 217         }
 218         return found;
 219     }
 220 };
 221
 222 /// Resuelve un nombre de forma directa (no recursiva)
 223 ResolvProtoResponse NameServer::resolv_direct(const Name& n)
 224 {
 225 #ifdef DEBUG_TRACE
 226     std::cout << "NameServer::resolv_direct()\n";
 227 #endif
 228 #ifdef DEBUG_RESOLV
 229     std::cout << "NameServer::resolv_direct -> tratando de resolver: "
 230         << n << "\n";
 231 #endif
 232     search_zone zs(n);
 233     bool found;
 234     for (zones_t::const_iterator i = zones.begin(); i!= zones.end(); ++i)
 235         if ((found = zs(*i)))
 236             break;
 237     if (found)
 238     {
 239 #ifdef DEBUG_RESOLV
 240         std::cout << "NameServer::resolv_direct -> found (local/hijo): "
 241             << zs.resp << "\n";
 242 #endif
 243         return zs.resp;
 244     }
 245     if (zs.local)
 246     {
 247 #ifdef DEBUG_RESOLV
 248         std::cout << "NameServer::resolv_direct -> NOT FOUND (es local pero "
 249             "no existe)\n";
 250 #endif
 251         return ResolvProtoResponse(RP_RES_NOTFOUND);
 252     }
 253     cache_t::iterator i = cache.find(n);
 254     if (i != cache.end())
 255     {
 256         const CacheRecord& cr = i->second;
 257 #ifdef DEBUG_RESOLV
 258         std::cout << "NameServer::resolv_direct -> found (en cache): "
 259             << cr << "\n";
 260 #endif
 261         if (unsigned(time(NULL)) > cr.expire) // Expiró
 262         {
 263             cache.erase(i);
 264 #ifdef DEBUG_RESOLV
 265             std::cout << "                          -> pero no sirve, expiró "
 266                 "hace unos " << (time(NULL) - cr.expire) << " segundos\n";
 267 #endif
 268         }
 269         else
 270         {
 271             return ResolvProtoResponse(RP_RES_A, cr.ttl, cr.ips);
 272         }
 273     }
 274     if (zones.size())
 275     {
 276         // Busco una zona con padre para ver si puedo "trepar"
 277         for (zones_t::const_iterator i = zones.begin(); i != zones.end(); ++i)
 278         {
 279 #ifdef DEBUG_RESOLV
 280             std::cout << "NameServer::resolv_direct -> evaluando padre "
 281                 << i->parent << "\n";
 282 #endif
 283             if (i->parent != IPAddr(0))
 284             {
 285 #ifdef DEBUG_RESOLV
 286                 std::cout << "NameServer::resolv_direct -> found (al padre): "
 287                     << i->parent << "\n";
 288 #endif
 289                 ResolvProtoResponse rpr(RP_RES_NS, i->ttl);
 290                 rpr.ips.push_back(i->parent);
 291                 return rpr;
 292             }
 293         }
 294     }
 295 #ifdef DEBUG_RESOLV
 296     std::cout << "NameServer::resolv_direct -> NOT FOUND (no hay padre)\n";
 297 #endif
 298     // No hay padre, no puedo hacer nada más
 299     return ResolvProtoResponse(RP_RES_NOTFOUND);
 300 }
 301
 302 /// Resuelve un nombre de forma recursiva
 303 ResolvProtoResponse NameServer::resolv_recursive(const Name& n)
 304 {
 305 #ifdef DEBUG_TRACE
 306     std::cout << "NameServer::resolv_recursive()\n";
 307 #endif
 308     ResolvProtoResponse rpr = resolv_direct(n);
 309     switch (rpr.ret)
 310     {
 311         case RP_RES_NS:
 312 #ifdef DEBUG_RESOLV
 313             std::cout << "NameServer::resolv_recursive -> redirect a "
 314                 << rpr << "\n";
 315 #endif
 316             return resolv_recursive_r(n, rpr); // Sigo "bajando"
 317         case RP_RES_A:
 318 #ifdef DEBUG_RESOLV
 319             std::cout << "NameServer::resolv_recursive -> gotcha! "
 320                 << rpr << "\n";
 321 #endif
 322             break;
 323     }
 324     return rpr; // Devuelvo el A o NOTFOUND
 325 }
 326
 327 /// Resuelve un nombre de forma recursiva entrando a otros ns
 328 ResolvProtoResponse NameServer::resolv_recursive_r(const Name& n,
 329         ResolvProtoResponse rpr)
 330 {
 331 #ifdef DEBUG_TRACE
 332     std::cout << "NameServer::resolv_recursive_r()\n";
 333 #endif
 334     ResolvProtoResponse r;
 335     for (ResolvProtoResponse::ipvec_t::const_iterator ip = rpr.ips.begin();
 336             ip != rpr.ips.end(); ++ip)
 337     {
 338         r = query(n, *ip);
 339         switch (r.ret)
 340         {
 341             case RP_RES_NS:
 342 #ifdef DEBUG_RESOLV
 343                 std::cout << "NameServer::resolv_recursive_r -> redirect a "
 344                     << r << "\n";
 345 #endif
 346                 return resolv_recursive_r(n, r); // Sigo "bajando"
 347             case RP_RES_NOTFOUND:
 348 #ifdef DEBUG_RESOLV
 349                 std::cout << "NameServer::resolv_recursive_r -> NOT FOUND en "
 350                     << *ip << ", sigo probando\n";
 351 #endif
 352                 break; // Sigo probando del mismo nivel
 353             case RP_RES_A:
 354 #ifdef DEBUG_RESOLV
 355                 std::cout << "NameServer::resolv_recursive_r -> gotcha! "
 356                     << r << "\n";
 357 #endif
 358                 return r; // Gotcha!
 359         }
 360     }
 361 #ifdef DEBUG_RESOLV
 362     std::cout << "NameServer::resolv_recursive_r -> NOT FOUND, no hay más "
 363         "por hacer\n";
 364 #endif
 365     return r; // NOTFOUND
 366 }
 367
 368 /// Consulta a otro name server sobre un nombre
 369 ResolvProtoResponse NameServer::query(const Name& n, const IPAddr& ip)
 370 {
 371 #ifdef DEBUG_TRACE
 372     std::cout << "NameServer::query()\n";
 373 #endif
 374     ResolvProtoRequest r(std::string(n), RP_REQ_DIRECT);
 375 #ifdef DEBUG_RESOLV
 376     std::cout << "NameServer::query -> pidiendo " << r << " a " << ip << "\n";
 377 #endif
 378     // Envía a través de la cola de envío
 379     snd_que.transmit(std::string(r), ip);
 380     Dev::mac_type mac = ip;
 381     std::string buf = res_que.receive(mac);
 382     ResolvProtoResponse resp(buf);
 383 #ifdef DEBUG_RESOLV
 384     std::cout << "NameServer::query -> recibido " << resp << " de "
 385         << ip << "\n";
 386 #endif
 387     // Agrego a cache
 388     if (resp.ret == RP_RES_A)
 389         cache[n] = CacheRecord(time(NULL) + resp.ttl, resp.ttl, resp.ips);
 390     return resp;
 391 }
 392
 393 void NameServer::recv_loop()
 394 {
 395 #ifdef DEBUG_TRACE
 396     std::cout << "NameServer::recv_loop()\n";
 397 #endif
 398     while (true)
 399     {
 400         IPAddr src, dst;
 401         uint8_t proto;
 402         std::string s = ipin.recv(proto, src, dst);
 403 #ifdef DEBUG_RESOLV
 404             std::cout << "NameServer::recv_loop() -> recibido len=" << s.size()
 405                 << " de " << src << " para " << dst << " (proto = "
 406                 << unsigned(proto) << ")\n";
 407 #endif
 408         if (proto == RESOLV_PROTO) // Si es para nosotros
 409         {
 410             rp_pkt_type_t type;
 411             memcpy(&type, s.data(), sizeof(uint8_t));
 412             switch (type)
 413             {
 414                 // Request
 415                 case RP_REQ_DIRECT:
 416                 case RP_REQ_RECURSIVE:
 417 #ifdef DEBUG_RESOLV
 418                     std::cout << "---> " << ResolvProtoRequest(s) << "\n";
 419 #endif
 420                     req_que.transmit(s, src); // Encolo
 421                     break;
 422                 // Response
 423                 default:
 424 #ifdef DEBUG_RESOLV
 425                     std::cout << "---> " << ResolvProtoResponse(s) << "\n";
 426 #endif
 427                     res_que.transmit(s, src); // Encolo
 428             }
 429         }
 430     }
 431 }
 432
 433 void NameServer::send_loop()
 434 {
 435 #ifdef DEBUG_TRACE
 436     std::cout << "NameServer::send_loop()\n";
 437 #endif
 438     while (true)
 439     {
 440         Dev::mac_type mac = 0;
 441         std::string buf = snd_que.receive(mac);
 442 #ifdef DEBUG_RESOLV
 443         uint8_t type;
 444         memcpy(&type, buf.data(), sizeof(uint8_t));
 445         std::cout << "NameServer::send_loop() -> envío ";
 446         if (type == RP_REQ_DIRECT || type == RP_REQ_RECURSIVE)
 447             std::cout << "request " << ResolvProtoRequest(buf) << "\n";
 448         else
 449             std::cout << "response " << ResolvProtoResponse(buf) << "\n";
 450 #endif
 451         ipout.send(buf, RESOLV_PROTO, IPAddr(mac));
 452     }
 453 }
 454
 455 void NameServer::req_loop()
 456 {
 457 #ifdef DEBUG_TRACE
 458     std::cout << "NameServer::req_loop()\n";
 459 #endif
 460     while (true)
 461     {
 462 #ifdef DEBUG_RESOLV
 463         std::cout << "----------------------------------------------------\n";
 464 #endif
 465         Dev::mac_type mac = 0;
 466         ResolvProtoRequest req(req_que.receive(mac));
 467 #ifdef DEBUG_RESOLV
 468         std::cout << "NameServer::req_loop() -> recibido " << req << "\n";
 469 #endif
 470         ResolvProtoResponse res
 471             = (req.query_type == RP_REQ_DIRECT)
 472             ? resolv_direct(req.name)
 473             : resolv_recursive(req.name);
 474 #ifdef DEBUG_RESOLV
 475         std::cout << "NameServer::req_loop() -> respondo " << res << "\n";
 476 #endif
 477         snd_que.transmit(std::string(res), IPAddr(mac));
 478     }
 479 }
 480
 481 std::ostream& operator<< (std::ostream& os, const NameServer::Record::type_t& t)
 482 {
 483     if (t == NameServer::Record::NS)
 484         return os << "NS";
 485     else
 486         return os << "A";
 487 }
 488
 489 std::ostream& operator<< (std::ostream& os, const NameServer::Record& r)
 490 {
 491     return os << r.type << " " << r.ip;
 492 }
 493
 494 std::ostream& operator<< (std::ostream& os,
 495         const NameServer::Zone::records_t::value_type& p)
 496 {
 497     return os << p.first << ": " << p.second;
 498 }
 499
 500 std::ostream& operator<< (std::ostream& os, const NameServer::Zone& z)
 501 {
 502     os << "Zone " << z.name << " " << z.ttl << " " << z.parent << "\n";
 503     std::copy(z.records.begin(), z.records.end(), std::ostream_iterator<
 504             NameServer::Zone::records_t::value_type >(os, "\n"));
 505     return os;
 506 }
 507
 508 std::ostream& operator<< (std::ostream& os, const NameServer::CacheRecord& cr)
 509 {
 510     os << "CacheRecord(expire=" << cr.expire << " [now=" << time(NULL)
 511         << "], ttl=" << cr.ttl << ", records=";
 512     std::copy(cr.ips.begin(), cr.ips.end(),
 513             std::ostream_iterator< IPAddr >(os, ","));
 514     return os << ")";
 515 }
 516
 517 std::ostream& operator<< (std::ostream& os, const NameServer& ns)
 518 {
 519     os << "NameServer: zones[" << ns.zones.size() << "] (\n\n";
 520     std::copy(ns.zones.begin(), ns.zones.end(),
 521             std::ostream_iterator< NameServer::Zone >(os, "\n"));
 522     return os << ")";
 523 }
 524
 525 // vim: set et sw=4 sts=4 :