#include <iostream>
#endif
-#define DEBUG_RESOLV
-
NameServer::Name::Name(const std::string& s)
{
std::istringstream iss(s);
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
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
- std::cerr << "parsezone: " << z << "\n\n";
+ std::cout << "NameServer::parsezone: " << z << "\n\n";
#endif
return is;
}
zones.push_back(z);
z.clear();
#ifdef DEBUG_PARSER
- std::cerr << "NameServer: " << z << "\n\n";
+ std::cout << "NameServer::NameServer: " << z << "\n\n";
#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
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;
}
/// 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
- std::cerr << "resolv_direct -> tratando de resolver: " << n << "\n";
+ std::cout << "NameServer::resolv_direct -> tratando de resolver: "
+ << n << "\n";
#endif
search_zone zs(n);
bool found;
if (found)
{
#ifdef DEBUG_RESOLV
- std::cerr << "resolv_direct 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
- std::cerr << "resolv_direct NOT FOUND (es local pero no existe)\n";
+ std::cout << "NameServer::resolv_direct -> NOT FOUND (es local pero "
+ "no existe)\n";
#endif
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())
{
+ const CacheRecord& cr = i->second;
#ifdef DEBUG_RESOLV
- std::cerr << "resolv_direct found (en cache): " << i->second << "\n";
+ std::cout << "NameServer::resolv_direct -> found (en cache): "
+ << cr << "\n";
#endif
- const CacheRecord& cr = i->second;
- return ResolvProtoResponse(RP_RES_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())
{
for (zones_t::const_iterator i = zones.begin(); i != zones.end(); ++i)
{
#ifdef DEBUG_RESOLV
- std::cerr << "resolv_direct -> evaluando padre " << i->parent
- << "\n";
+ std::cout << "NameServer::resolv_direct -> evaluando padre "
+ << i->parent << "\n";
#endif
if (i->parent != IPAddr(0))
{
#ifdef DEBUG_RESOLV
- std::cerr << "resolv_direct found (al padre): "
+ std::cout << "NameServer::resolv_direct -> found (al padre): "
<< i->parent << "\n";
#endif
ResolvProtoResponse rpr(RP_RES_NS, i->ttl);
}
}
#ifdef DEBUG_RESOLV
- std::cerr << "resolv_direct NOT FOUND (no hay padre)\n";
+ 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::cerr << "resolv_recursive -> redirect a " << rpr << "\n";
+ 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
- std::cerr << "resolv_recursive -> gotcha! " << rpr << "\n";
+ std::cout << "NameServer::resolv_recursive -> gotcha! "
+ << rpr << "\n";
#endif
- // TODO agregar a cache
break;
}
return rpr; // Devuelvo el A o NOTFOUND
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)
{
case RP_RES_NS:
#ifdef DEBUG_RESOLV
- std::cerr << "resolv_recursive_r -> redirect a " << r << "\n";
+ 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
- std::cerr << "resolv_recursive_r -> NOT FOUND en " << *ip
- << ", sigo probando\n";
+ std::cout << "NameServer::resolv_recursive_r -> NOT FOUND en "
+ << *ip << ", sigo probando\n";
#endif
break; // Sigo probando del mismo nivel
case RP_RES_A:
#ifdef DEBUG_RESOLV
- std::cerr << "resolv_recursive_r -> gotcha! " << r << "\n";
+ std::cout << "NameServer::resolv_recursive_r -> gotcha! "
+ << r << "\n";
#endif
- // TODO agregar a cache
return r; // Gotcha!
}
}
#ifdef DEBUG_RESOLV
- std::cerr << "resolv_recursive_r -> NOT FOUND, no hay más por hacer\n";
+ 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::cerr << "query -> pidiendo " << r << " a " << ip << "\n";
+ 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);
std::string buf = res_que.receive(mac);
ResolvProtoResponse resp(buf);
#ifdef DEBUG_RESOLV
- std::cerr << "query -> recibido " << resp << " de " << ip << "\n";
+ 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;
if (proto == RESOLV_PROTO) // Si es para nosotros
{
rp_pkt_type_t type;
- memcpy(&type, s.c_str(), sizeof(uint8_t));
+ memcpy(&type, s.data(), sizeof(uint8_t));
switch (type)
{
// Request
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)
{
- if (!req_que.empty())
- {
- Dev::mac_type mac = 0;
- ResolvProtoRequest req(req_que.receive(mac));
#ifdef DEBUG_RESOLV
- std::cout << "NameServer::send_loop() -> recibido " << req << "\n";
+ std::cout << "----------------------------------------------------\n";
#endif
- ResolvProtoResponse res
- = (req.query_type == RP_REQ_DIRECT)
- ? resolv_direct(req.name)
- : resolv_recursive(req.name);
+ Dev::mac_type mac = 0;
+ ResolvProtoRequest req(req_que.receive(mac));
#ifdef DEBUG_RESOLV
- std::cout << "NameServer::send_loop() -> respondo " << res << "\n";
+ std::cout << "NameServer::req_loop() -> recibido " << req << "\n";
#endif
- ipout.send(res, RESOLV_PROTO, IPAddr(mac));
- }
- else if (!snd_que.empty()) // Hay un request para enviar
- {
- Dev::mac_type mac = 0;
- std::string buf = snd_que.receive(mac);
+ ResolvProtoResponse res
+ = (req.query_type == RP_REQ_DIRECT)
+ ? resolv_direct(req.name)
+ : resolv_recursive(req.name);
#ifdef DEBUG_RESOLV
- std::cout << "NameServer::send_loop() -> envío request "
- << ResolvProtoRequest(buf) << "\n";
+ std::cout << "NameServer::req_loop() -> respondo " << res << "\n";
#endif
- ipout.send(buf, RESOLV_PROTO, IPAddr(mac));
- }
- else // No hay nada, esperamos un rato
- {
- usleep(10000);
- }
+ snd_que.transmit(std::string(res), IPAddr(mac));
}
}
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 << ")";
projects / z.facultad / 75.74 / practicos.git / blobdiff