Se hace más genérico el protocolo del resolver (para que pueda ser usado para

comunicar el resolver con un nameserver y nameservers entre sí) y se agrega una
doc gráfica del paquete.

diff --git a/practicas/pipi/src/resolvproto.cpp b/practicas/pipi/src/resolvproto.cpp
index fe2f94a35688c13213a144faa88becb7303615e8..e71100488934ce83f856057c98cd8565371d255b 100644 (file)
--- a/practicas/pipi/src/resolvproto.cpp
+++ b/practicas/pipi/src/resolvproto.cpp
@@ -11,16 +11,16 @@ ResolvProtoRequest::ResolvProtoRequest(int fd)
 }
 
 /// Constructor
-ResolvProtoRequest::ResolvProtoRequest(std::string name, uint8_t type):
-    type(type), name(name)
+ResolvProtoRequest::ResolvProtoRequest(std::string name, uint8_t query_type):
+    query_type(query_type), name(name)
 {}
 
 /// Envía por socket
 void ResolvProtoRequest::send(int sockfd) const
     throw (std::runtime_error)
 {
-    if (libtcp_send(sockfd, &type, sizeof(uint8_t)) != sizeof(uint8_t))
-        throw std::runtime_error("Error al enviar type por socket");
+    if (libtcp_send(sockfd, &query_type, sizeof(uint8_t)) != sizeof(uint8_t))
+        throw std::runtime_error("Error al enviar query_type por socket");
     uint16_t size = name.size();
     if (libtcp_send(sockfd, &size, sizeof(uint16_t)) != sizeof(uint16_t))
         throw std::runtime_error("Error al enviar size por socket");
@@ -32,8 +32,8 @@ void ResolvProtoRequest::send(int sockfd) const
 void ResolvProtoRequest::recv(int sockfd)
     throw (std::runtime_error)
 {
-    if (libtcp_receive_bin(sockfd, &type, sizeof(uint8_t)) != sizeof(uint8_t))
-        throw std::runtime_error("Error al recibir type por socket");
+    if (libtcp_receive_bin(sockfd, &query_type, sizeof(uint8_t)) != sizeof(uint8_t))
+        throw std::runtime_error("Error al recibir query_type por socket");
     uint16_t size;
     if (libtcp_receive_bin(sockfd, &size, sizeof(uint16_t)) != sizeof(uint16_t))
         throw std::runtime_error("Error al recibir size por socket");
@@ -50,8 +50,8 @@ void ResolvProtoRequest::recv(int sockfd)
 /// Impresión de request
 std::ostream& operator<< (std::ostream& os, const ResolvProtoRequest& rpr)
 {
-    return os << "ResolvProtoRequest(type=" << unsigned(rpr.type) << ", name="
-        << rpr.name << ")";
+    return os << "ResolvProtoRequest(query_type=" << unsigned(rpr.query_type)
+        << ", name=" << rpr.name << ")";
 }
 
 /// Constructor
@@ -61,8 +61,8 @@ ResolvProtoResponse::ResolvProtoResponse(int fd)
 }
 
 /// Constructor
-ResolvProtoResponse::ResolvProtoResponse(ret_t ret):
-    ret(ret)
+ResolvProtoResponse::ResolvProtoResponse(ret_t ret, uint32_t ttl):
+    ret(ret), ttl(ttl)
 {}
 
 /// Envía por socket
@@ -71,6 +71,8 @@ void ResolvProtoResponse::send(int sockfd) const
 {
     if (libtcp_send(sockfd, &ret, sizeof(uint8_t)) != sizeof(uint8_t))
         throw std::runtime_error("Error al enviar ret por socket");
+    if (libtcp_send(sockfd, &ttl, sizeof(uint32_t)) != sizeof(uint32_t))
+        throw std::runtime_error("Error al enviar ttl por socket");
     uint8_t count = ips.size();
     if (libtcp_send(sockfd, &count, sizeof(uint8_t)) != sizeof(uint8_t))
         throw std::runtime_error("Error al enviar count por socket");
@@ -88,6 +90,8 @@ void ResolvProtoResponse::recv(int sockfd)
 {
     if (libtcp_receive_bin(sockfd, &ret, sizeof(uint8_t)) != sizeof(uint8_t))
         throw std::runtime_error("Error al recibir ret por socket");
+    if (libtcp_receive_bin(sockfd, &ttl, sizeof(uint32_t)) != sizeof(uint32_t))
+        throw std::runtime_error("Error al recibir ttl por socket");
     uint8_t count;
     if (libtcp_receive_bin(sockfd, &count, sizeof(uint8_t)) != sizeof(uint8_t))
         throw std::runtime_error("Error al recibir count por socket");
@@ -107,7 +111,8 @@ std::ostream& operator<< (std::ostream& os, const ResolvProtoResponse& rpr)
 {
     if (rpr.ips.empty())
         return os;
-    os << "ResolvProtoResponse(ret=" << unsigned(rpr.ret) << ", ";
+    os << "ResolvProtoResponse(ret=" << unsigned(rpr.ret)
+        << ", ttl=" << rpr.ttl << ", ";
     std::copy(rpr.ips.begin(), rpr.ips.end() - 1,
             std::ostream_iterator< IPAddr >(os, ", "));
     return os << rpr.ips.back() << ")";

diff --git a/practicas/pipi/src/resolvproto.h b/practicas/pipi/src/resolvproto.h
index 826fa386a0b0353e25ddac455e517cfe16618dac..7caf4f825e99903da5b04bc204a68fa57037956b 100644 (file)
--- a/practicas/pipi/src/resolvproto.h
+++ b/practicas/pipi/src/resolvproto.h
@@ -7,15 +7,21 @@
 #include <stdexcept>
 #include <stdint.h>
 
-/// Petición del resolver a un nameserver
+/// Petición de un nameserver
+/// +------------+------------+------------+
+/// | QUERY_TYPE |    SIZE    |    NAME    |
+/// +------------+------------+------------+
+/// /-- 1 byte --/- 2 bytes --/- variable -/
 struct ResolvProtoRequest
 {
 
-    /// Tipo de petición, por ahora sólo QUERY
-    enum { TYPE_QUERY };
-
-    /// Tipo de petición, por ahora sólo QUERY
-    uint8_t type;
+    /// Tipo de petición
+    enum query_type_t
+    {
+        QT_DIRECT,      ///> Búsqueda directa (inter nameservers)
+        QT_RECURSIVE    ///> Búsqueda recursiva (para resolvers)
+    };
+    uint8_t query_type;
 
     /// Nombre a buscar
     std::string name;
@@ -24,7 +30,7 @@ struct ResolvProtoRequest
     ResolvProtoRequest(int fd);
 
     /// Constructor
-    ResolvProtoRequest(std::string name, uint8_t type = TYPE_QUERY);
+    ResolvProtoRequest(std::string name, uint8_t query_type = QT_RECURSIVE);
 
     /// Envía por socket
     void send(int sockfd) const throw (std::runtime_error);
@@ -38,16 +44,27 @@ struct ResolvProtoRequest
 std::ostream& operator<< (std::ostream& os, const ResolvProtoRequest& rpr);
 
 
-/// Respuesta del resolver a un nameserver
+/// Respuesta de un nameserver
+/// +-----------+-----------+-----------+-----------+-----------+-----------+
+/// |    RET    |    TTL    |   COUNT   |    IP 1   |    ...    |    IP N   |
+/// +-----------+-----------+-----------+-----------+-----------+-----------+
+/// /-- 1 byte -/- 4 bytes -/-- 1 byte -/- 4 bytes -/- 4 bytes -/- 4 bytes -/
 struct ResolvProtoResponse
 {
 
     /// Resultado de la respuesta
-    enum ret_t { RET_OK, RET_NOTFOUND, RET_TIMEOUT };
-
-    /// Resultado de la respuesta
+    enum ret_t
+    {
+        R_A,            ///> OK, se devolvió un registro A
+        R_NS,           ///> OK, se devolvió un registro NS (sólo en directo)
+        R_NOTFOUND,     ///> No se encontró
+        R_TIMEOUT       ///> Tardó demasiado la consulta
+    };
     uint8_t ret;
 
+    /// TTL (sólo útil para búsquedas (inter nameserver)
+    uint32_t ttl;
+
     /// IPs devueltas
     typedef std::vector< IPAddr > ipvec_t;
     ipvec_t ips;
@@ -56,7 +73,7 @@ struct ResolvProtoResponse
     ResolvProtoResponse(int fd);
 
     /// Constructor
-    ResolvProtoResponse(ret_t ret);
+    ResolvProtoResponse(ret_t ret, uint32_t ttl);
 
     /// Envía por socket
     void send(int sockfd) const throw (std::runtime_error);

diff --git a/practicas/pipi/src/test_resolvprotos.cpp b/practicas/pipi/src/test_resolvprotos.cpp
index 7286ab386515591d0be9e426ebd975b01c2ee882..54c8c1052c7b99f7198ffd21b21fd23c6962e8e0 100644 (file)
--- a/practicas/pipi/src/test_resolvprotos.cpp
+++ b/practicas/pipi/src/test_resolvprotos.cpp
@@ -11,7 +11,7 @@ int main()
     close(sfd);
     ResolvProtoRequest rpr(cfd);
     std::cout << "Recibimos: " << rpr << "\n";
-    ResolvProtoResponse rps(ResolvProtoResponse::RET_OK);
+    ResolvProtoResponse rps(ResolvProtoResponse::R_A, 600);
     rps.ips.push_back(IPAddr("10.10.10.2"));
     rps.ips.push_back(IPAddr("100.20.45.21"));
     rps.ips.push_back(IPAddr("230.23.62.189"));