Cosas de Distribuidos I.

[z.facultad/75.74/practicos.git] / practicas / pipi / src / nameserver.cpp

diff --git a/practicas/pipi/src/nameserver.cpp b/practicas/pipi/src/nameserver.cpp
index 1e6e19c323097a33e6ad1949bf621345f776145f..4fd894a51eaaedab6aaa2e1fec1f02e44f8268b9 100644 (file)
--- a/practicas/pipi/src/nameserver.cpp
+++ b/practicas/pipi/src/nameserver.cpp
@@ -8,8 +8,6 @@
 #include <iostream>
 #endif
 
 #include <iostream>
 #endif
 

-#define DEBUG_RESOLV
-

 NameServer::Name::Name(const std::string& s)
 {
     std::istringstream iss(s);
 NameServer::Name::Name(const std::string& s)
 {
     std::istringstream iss(s);


@@ -27,7 +25,7 @@ std::ostream& operator<< (std::ostream& os, const NameServer::Name& name)
     return os << name.back();
 }
 
     return os << name.back();
 }
 

-NameServer::Name::operator std::string ()
+NameServer::Name::operator std::string () const

 {
     std::stringstream ss;
     ss << *this;
 {
     std::stringstream ss;
     ss << *this;


@@ -48,7 +46,7 @@ static std::istream& parsezone(std::istream& is, NameServer::Zone& z)
         throw std::runtime_error("Error al parsear");
     z.name = sname;
 #ifdef DEBUG_PARSER
         throw std::runtime_error("Error al parsear");
     z.name = sname;
 #ifdef DEBUG_PARSER

-    std::cerr << "parsezone: IP = " << ip << "\n\n";
+    std::cout << "NameServer::parsezone: IP = " << ip << "\n\n";

 #endif
     z.parent = IPAddr(ip);
     // un record por linea, sin líneas vacías
 #endif
     z.parent = IPAddr(ip);
     // un record por linea, sin líneas vacías


@@ -62,13 +60,13 @@ static std::istream& parsezone(std::istream& is, NameServer::Zone& z)
             throw std::runtime_error("Error al parsear");
         typedef NameServer::Record Rec;
 #ifdef DEBUG_PARSER
             throw std::runtime_error("Error al parsear");
         typedef NameServer::Record Rec;
 #ifdef DEBUG_PARSER

-        std::cerr << "parsezone: IP = " << ip << "\n\n";
+        std::cout << "NameServer::parsezone: IP = " << ip << "\n\n";

 #endif
         Rec r((type == "NS") ? Rec::NS : Rec::A, IPAddr(ip));
         z.records.insert(NameServer::Zone::records_t::value_type(key, r));
     }
 #ifdef DEBUG_PARSER
 #endif
         Rec r((type == "NS") ? Rec::NS : Rec::A, IPAddr(ip));
         z.records.insert(NameServer::Zone::records_t::value_type(key, r));
     }
 #ifdef DEBUG_PARSER

-    std::cerr << "parsezone: " << z << "\n\n";
+    std::cout << "NameServer::parsezone: " << z << "\n\n";

 #endif
     return is;
 }
 #endif
     return is;
 }


@@ -96,8 +94,11 @@ void NameServer::Zone::clear()
 }
 
 /// Constructor
 }
 
 /// Constructor

-NameServer::NameServer(std::istream& is)
-    throw (std::runtime_error)
+NameServer::NameServer(std::istream& is, IPIn& ipin, IPOut& ipout,
+        DevQue& req_que, DevQue& res_que, DevQue& snd_que)
+    throw (std::runtime_error):
+    ipin(ipin), ipout(ipout), req_que(req_que), res_que(res_que),
+        snd_que(snd_que)

 {
     Zone z;
     while (parsezone(is, z))
 {
     Zone z;
     while (parsezone(is, z))


@@ -105,9 +106,15 @@ NameServer::NameServer(std::istream& is)
         zones.push_back(z);
         z.clear();
 #ifdef DEBUG_PARSER
         zones.push_back(z);
         z.clear();
 #ifdef DEBUG_PARSER

-        std::cerr << "NameServer: " << z << "\n\n";
+        std::cout << "NameServer::NameServer: " << z << "\n\n";

 #endif
     }
 #endif
     }

+
+#ifdef DEBUG_RESOLV
+    std::cout << "NameServer::NameServer: req_que_id = " << req_que.que_id
+        << ", res_que_id = " << res_que.que_id
+        << ", snd_que_id = " << snd_que.que_id << "\n";
+#endif

 }
 
 /// Devuelve la parte izquierda de n, si la parte derecha coincide exactamente
 }
 
 /// Devuelve la parte izquierda de n, si la parte derecha coincide exactamente


@@ -135,7 +142,8 @@ name_split(NameServer::Name n, NameServer::Name m)
         r.push_back(n[i++]);
     std::reverse(r.begin(), r.end());
 #ifdef DEBUG_NAME
         r.push_back(n[i++]);
     std::reverse(r.begin(), r.end());
 #ifdef DEBUG_NAME

-    std::cerr << "name_split(" << n << ", " << m << ") -> " << r << "\n";
+    std::cout << "NameServer::name_split(" << n << ", " << m << ") -> "
+        << r << "\n";

 #endif
     return r;
 }
 #endif
     return r;
 }


@@ -201,8 +209,8 @@ struct search_zone: std::unary_function< NameServer::Zone, bool >
                 if ((local_part.size() > 1) && r.type != NameServer::Record::NS)
                     continue;
                 found = true;
                 if ((local_part.size() > 1) && r.type != NameServer::Record::NS)
                     continue;
                 found = true;

-                resp.ret = (r.type == NameServer::Record::NS)
-                    ? ResolvProtoResponse::R_NS : ResolvProtoResponse::R_A;
+                resp.ret = (r.type == NameServer::Record::NS) ? RP_RES_NS
+                    : RP_RES_A;

                 resp.ttl = z.ttl;
                 resp.ips.push_back(r.ip);
             }
                 resp.ttl = z.ttl;
                 resp.ips.push_back(r.ip);
             }


@@ -211,10 +219,15 @@ struct search_zone: std::unary_function< NameServer::Zone, bool >
     }
 };
 
     }
 };
 

-ResolvProtoResponse NameServer::resolv_next(const Name& n)
+/// Resuelve un nombre de forma directa (no recursiva)
+ResolvProtoResponse NameServer::resolv_direct(const Name& n)

 {
 {

+#ifdef DEBUG_TRACE
+    std::cout << "NameServer::resolv_direct()\n";
+#endif

 #ifdef DEBUG_RESOLV
 #ifdef DEBUG_RESOLV

-    std::cerr << "resolv_next -> tratando de resolver: " << n << "\n";
+    std::cout << "NameServer::resolv_direct -> tratando de resolver: "
+        << n << "\n";

 #endif
     search_zone zs(n);
     bool found;
 #endif
     search_zone zs(n);
     bool found;


@@ -224,41 +237,245 @@ ResolvProtoResponse NameServer::resolv_next(const Name& n)
     if (found)
     {
 #ifdef DEBUG_RESOLV
     if (found)
     {
 #ifdef DEBUG_RESOLV

-        std::cerr << "resolv_next found (local/hijo): " << zs.resp << "\n";
+        std::cout << "NameServer::resolv_direct -> found (local/hijo): "
+            << zs.resp << "\n";

 #endif
         return zs.resp;
     }
     if (zs.local)
     {
 #ifdef DEBUG_RESOLV
 #endif
         return zs.resp;
     }
     if (zs.local)
     {
 #ifdef DEBUG_RESOLV

-        std::cerr << "resolv_next NOT FOUND (es local pero no existe)\n";
+        std::cout << "NameServer::resolv_direct -> NOT FOUND (es local pero "
+            "no existe)\n";

 #endif
 #endif

-        return ResolvProtoResponse(ResolvProtoResponse::R_NOTFOUND);
+        return ResolvProtoResponse(RP_RES_NOTFOUND);

     }
     }

-    cache_t::const_iterator i = cache.find(n);
-    // TODO TTL!?!
+    cache_t::iterator i = cache.find(n);

     if (i != cache.end())
     {
     if (i != cache.end())
     {

+        const CacheRecord& cr = i->second;

 #ifdef DEBUG_RESOLV
 #ifdef DEBUG_RESOLV

-        std::cerr << "resolv_next found (en cache): " << i->second << "\n";
+        std::cout << "NameServer::resolv_direct -> found (en cache): "
+            << cr << "\n";

 #endif
 #endif

-        const CacheRecord& cr = i->second;
-        return ResolvProtoResponse(ResolvProtoResponse::R_A, cr.ttl, cr.ips);
+        if (unsigned(time(NULL)) > cr.expire) // Expiró
+        {
+            cache.erase(i);
+#ifdef DEBUG_RESOLV
+            std::cout << "                          -> pero no sirve, expiró "
+                "hace unos " << (time(NULL) - cr.expire) << " segundos\n";
+#endif
+        }
+        else
+        {
+            return ResolvProtoResponse(RP_RES_A, cr.ttl, cr.ips);
+        }

     }
     if (zones.size())
     {
     }
     if (zones.size())
     {

+        // Busco una zona con padre para ver si puedo "trepar"
+        for (zones_t::const_iterator i = zones.begin(); i != zones.end(); ++i)
+        {
+#ifdef DEBUG_RESOLV
+            std::cout << "NameServer::resolv_direct -> evaluando padre "
+                << i->parent << "\n";
+#endif
+            if (i->parent != IPAddr(0))
+            {
+#ifdef DEBUG_RESOLV
+                std::cout << "NameServer::resolv_direct -> found (al padre): "
+                    << i->parent << "\n";
+#endif
+                ResolvProtoResponse rpr(RP_RES_NS, i->ttl);
+                rpr.ips.push_back(i->parent);
+                return rpr;
+            }
+        }
+    }
+#ifdef DEBUG_RESOLV
+    std::cout << "NameServer::resolv_direct -> NOT FOUND (no hay padre)\n";
+#endif
+    // No hay padre, no puedo hacer nada más
+    return ResolvProtoResponse(RP_RES_NOTFOUND);
+}
+
+/// Resuelve un nombre de forma recursiva
+ResolvProtoResponse NameServer::resolv_recursive(const Name& n)
+{
+#ifdef DEBUG_TRACE
+    std::cout << "NameServer::resolv_recursive()\n";
+#endif
+    ResolvProtoResponse rpr = resolv_direct(n);
+    switch (rpr.ret)
+    {
+        case RP_RES_NS:
+#ifdef DEBUG_RESOLV
+            std::cout << "NameServer::resolv_recursive -> redirect a "
+                << rpr << "\n";
+#endif
+            return resolv_recursive_r(n, rpr); // Sigo "bajando"
+        case RP_RES_A:

 #ifdef DEBUG_RESOLV
 #ifdef DEBUG_RESOLV

-        std::cerr << "resolv_next found (al padre): " << zones.front().parent
-                << "\n";
-        ResolvProtoResponse rpr(ResolvProtoResponse::R_NS, zones.front().ttl);
-        rpr.ips.push_back(zones.front().parent);
-        return rpr;
+            std::cout << "NameServer::resolv_recursive -> gotcha! "
+                << rpr << "\n";

 #endif
 #endif

+            break;

     }
     }

+    return rpr; // Devuelvo el A o NOTFOUND
+}
+
+/// Resuelve un nombre de forma recursiva entrando a otros ns
+ResolvProtoResponse NameServer::resolv_recursive_r(const Name& n,
+        ResolvProtoResponse rpr)
+{
+#ifdef DEBUG_TRACE
+    std::cout << "NameServer::resolv_recursive_r()\n";
+#endif
+    ResolvProtoResponse r;
+    for (ResolvProtoResponse::ipvec_t::const_iterator ip = rpr.ips.begin();
+            ip != rpr.ips.end(); ++ip)
+    {
+        r = query(n, *ip);
+        switch (r.ret)
+        {
+            case RP_RES_NS:
+#ifdef DEBUG_RESOLV
+                std::cout << "NameServer::resolv_recursive_r -> redirect a "
+                    << r << "\n";
+#endif
+                return resolv_recursive_r(n, r); // Sigo "bajando"
+            case RP_RES_NOTFOUND:

 #ifdef DEBUG_RESOLV
 #ifdef DEBUG_RESOLV

-    std::cerr << "resolv_next NOT FOUND (no hay padre)\n";
+                std::cout << "NameServer::resolv_recursive_r -> NOT FOUND en "
+                    << *ip << ", sigo probando\n";

 #endif
 #endif

-    return ResolvProtoResponse(ResolvProtoResponse::R_NOTFOUND);
+                break; // Sigo probando del mismo nivel
+            case RP_RES_A:
+#ifdef DEBUG_RESOLV
+                std::cout << "NameServer::resolv_recursive_r -> gotcha! "
+                    << r << "\n";
+#endif
+                return r; // Gotcha!
+        }
+    }
+#ifdef DEBUG_RESOLV
+    std::cout << "NameServer::resolv_recursive_r -> NOT FOUND, no hay más "
+        "por hacer\n";
+#endif
+    return r; // NOTFOUND
+}
+
+/// Consulta a otro name server sobre un nombre
+ResolvProtoResponse NameServer::query(const Name& n, const IPAddr& ip)
+{
+#ifdef DEBUG_TRACE
+    std::cout << "NameServer::query()\n";
+#endif
+    ResolvProtoRequest r(std::string(n), RP_REQ_DIRECT);
+#ifdef DEBUG_RESOLV
+    std::cout << "NameServer::query -> pidiendo " << r << " a " << ip << "\n";
+#endif
+    // Envía a través de la cola de envío
+    snd_que.transmit(std::string(r), ip);
+    Dev::mac_type mac = ip;
+    std::string buf = res_que.receive(mac);
+    ResolvProtoResponse resp(buf);
+#ifdef DEBUG_RESOLV
+    std::cout << "NameServer::query -> recibido " << resp << " de "
+        << ip << "\n";
+#endif
+    // Agrego a cache
+    if (resp.ret == RP_RES_A)
+        cache[n] = CacheRecord(time(NULL) + resp.ttl, resp.ttl, resp.ips);
+    return resp;
+}
+
+void NameServer::recv_loop()
+{
+#ifdef DEBUG_TRACE
+    std::cout << "NameServer::recv_loop()\n";
+#endif
+    while (true)
+    {
+        IPAddr src, dst;
+        uint8_t proto;
+        std::string s = ipin.recv(proto, src, dst);
+#ifdef DEBUG_RESOLV
+            std::cout << "NameServer::recv_loop() -> recibido len=" << s.size()
+                << " de " << src << " para " << dst << " (proto = "
+                << unsigned(proto) << ")\n";
+#endif
+        if (proto == RESOLV_PROTO) // Si es para nosotros
+        {
+            rp_pkt_type_t type;
+            memcpy(&type, s.data(), sizeof(uint8_t));
+            switch (type)
+            {
+                // Request
+                case RP_REQ_DIRECT:
+                case RP_REQ_RECURSIVE:
+#ifdef DEBUG_RESOLV
+                    std::cout << "---> " << ResolvProtoRequest(s) << "\n";
+#endif
+                    req_que.transmit(s, src); // Encolo
+                    break;
+                // Response
+                default:
+#ifdef DEBUG_RESOLV
+                    std::cout << "---> " << ResolvProtoResponse(s) << "\n";
+#endif
+                    res_que.transmit(s, src); // Encolo
+            }
+        }
+    }
+}
+
+void NameServer::send_loop()
+{
+#ifdef DEBUG_TRACE
+    std::cout << "NameServer::send_loop()\n";
+#endif
+    while (true)
+    {
+        Dev::mac_type mac = 0;
+        std::string buf = snd_que.receive(mac);
+#ifdef DEBUG_RESOLV
+        uint8_t type;
+        memcpy(&type, buf.data(), sizeof(uint8_t));
+        std::cout << "NameServer::send_loop() -> envío ";
+        if (type == RP_REQ_DIRECT || type == RP_REQ_RECURSIVE)
+            std::cout << "request " << ResolvProtoRequest(buf) << "\n";
+        else
+            std::cout << "response " << ResolvProtoResponse(buf) << "\n";
+#endif
+        ipout.send(buf, RESOLV_PROTO, IPAddr(mac));
+    }
+}
+
+void NameServer::req_loop()
+{
+#ifdef DEBUG_TRACE
+    std::cout << "NameServer::req_loop()\n";
+#endif
+    while (true)
+    {
+#ifdef DEBUG_RESOLV
+        std::cout << "----------------------------------------------------\n";
+#endif
+        Dev::mac_type mac = 0;
+        ResolvProtoRequest req(req_que.receive(mac));
+#ifdef DEBUG_RESOLV
+        std::cout << "NameServer::req_loop() -> recibido " << req << "\n";
+#endif
+        ResolvProtoResponse res
+            = (req.query_type == RP_REQ_DIRECT)
+            ? resolv_direct(req.name)
+            : resolv_recursive(req.name);
+#ifdef DEBUG_RESOLV
+        std::cout << "NameServer::req_loop() -> respondo " << res << "\n";
+#endif
+        snd_que.transmit(std::string(res), IPAddr(mac));
+    }

 }
 
 std::ostream& operator<< (std::ostream& os, const NameServer::Record::type_t& t)
 }
 
 std::ostream& operator<< (std::ostream& os, const NameServer::Record::type_t& t)


@@ -290,7 +507,8 @@ std::ostream& operator<< (std::ostream& os, const NameServer::Zone& z)
 
 std::ostream& operator<< (std::ostream& os, const NameServer::CacheRecord& cr)
 {
 
 std::ostream& operator<< (std::ostream& os, const NameServer::CacheRecord& cr)
 {

-    os << "CacheRecord(ttl=" << cr.ttl << ", records=";
+    os << "CacheRecord(expire=" << cr.expire << " [now=" << time(NULL)
+        << "], ttl=" << cr.ttl << ", records=";

     std::copy(cr.ips.begin(), cr.ips.end(),
             std::ostream_iterator< IPAddr >(os, ","));
     return os << ")";
     std::copy(cr.ips.begin(), cr.ips.end(),
             std::ostream_iterator< IPAddr >(os, ","));
     return os << ")";