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