From 5c412208f949aadb5cc8bd2d1baa9a8c1a77fbbb Mon Sep 17 00:00:00 2001 From: Matias Fontanini Date: Mon, 15 Aug 2011 12:39:46 -0300 Subject: [PATCH] Added recv mechanism on PacketSender. --- include/icmp.h | 10 +++++++ include/ip.h | 16 +++++++++-- include/packetsender.h | 24 ++++++++++++---- include/pdu.h | 24 ++++++++++++++-- src/icmp.cpp | 33 ++++++++++++++++++++++ src/ip.cpp | 57 ++++++++++++++++++++++++++++++++++++-- src/packetsender.cpp | 63 ++++++++++++++++++++++++++++++++---------- 7 files changed, 201 insertions(+), 26 deletions(-) diff --git a/include/icmp.h b/include/icmp.h index f0db12c..f64802d 100644 --- a/include/icmp.h +++ b/include/icmp.h @@ -135,6 +135,10 @@ namespace Tins { * payload and options size. \sa PDU::header_size */ uint32_t header_size() const; + + bool matches_response(uint8_t *ptr, uint32_t total_sz); + + PDU *clone_packet(uint8_t *ptr, uint32_t total_sz); private: static uint16_t global_id, global_seq; @@ -155,6 +159,12 @@ namespace Tins { } un; } __attribute__((packed)); + /** \brief Creates an instance of ICMP from a icmphdr pointer. + * + * \param ptr The icmphdr to clone. + */ + ICMP(icmphdr *ptr); + /** \brief Serialices this ICMP PDU. * \param buffer The buffer in which the PDU will be serialized. * \param total_sz The size available in the buffer. diff --git a/include/ip.h b/include/ip.h index 3bc2f3f..069bb3b 100644 --- a/include/ip.h +++ b/include/ip.h @@ -119,7 +119,15 @@ namespace Tins { /* Virtual methods */ uint32_t header_size() const; bool send(PacketSender* sender); + + bool matches_response(uint8_t *ptr, uint32_t total_sz); + + PDU *recv_response(PacketSender *sender); + + PDU *clone_packet(uint8_t *ptr, uint32_t total_sz); private: + static const uint8_t DEFAULT_TTL; + struct iphdr { #if __BYTE_ORDER == __LITTLE_ENDIAN unsigned int ihl:4; @@ -161,8 +169,12 @@ namespace Tins { } __attribute__((__packed__)); - static const uint8_t DEFAULT_TTL; - + /** \brief Creates an instance of IP from an iphdr pointer. + * + * \param ptr The ip header pointer. + */ + IP(const iphdr *ptr); + void init_ip_fields(); void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent); diff --git a/include/packetsender.h b/include/packetsender.h index 9e3e369..9b3e366 100644 --- a/include/packetsender.h +++ b/include/packetsender.h @@ -25,6 +25,7 @@ #include #include +#include #include "pdu.h" namespace Tins { @@ -38,6 +39,12 @@ namespace Tins { */ class PacketSender { public: + enum SocketType { + IP_SOCKET, + ICMP_SOCKET, + SOCKETS_END + }; + /** * \brief Constructor for PacketSender objects. */ @@ -46,23 +53,28 @@ namespace Tins { bool open_l2_socket(); - bool open_l3_socket(); + bool open_l3_socket(SocketType type); bool close_socket(uint32_t flag); bool send(PDU* pdu); + + PDU *send_recv(PDU *pdu); bool send_l2(PDU *pdu); + + PDU *recv_l3(PDU *pdu, struct sockaddr *link_addr, uint32_t len_link_addr, SocketType type); - bool send_l3(PDU *pdu, const struct sockaddr* link_addr, uint32_t len_link_addr); + bool send_l3(PDU *pdu, struct sockaddr *link_addr, uint32_t len_link_addr, SocketType type); private: - enum SocketType { - IP_SOCKET, - SOCKETS_END - }; static const int INVALID_RAW_SOCKET; + + typedef std::map SocketTypeMap; + + int find_type(SocketType type); std::vector _sockets; + SocketTypeMap _types; }; }; diff --git a/include/pdu.h b/include/pdu.h index 508a4be..b9dd16f 100644 --- a/include/pdu.h +++ b/include/pdu.h @@ -73,7 +73,7 @@ namespace Tins { /** \brief The child PDU. */ - inline const PDU *inner_pdu() const { return _inner_pdu; } + inline PDU *inner_pdu() const { return _inner_pdu; } /** \brief Sets the flag identifier. */ @@ -105,7 +105,27 @@ namespace Tins { * those methods. * \param sender The PacketSender which will send the packet. */ - virtual bool send(PacketSender* sender) { return false; } + virtual bool send(PacketSender *sender) { return false; } + + /** \brief Receives a matching response for this packet. + * + * This method should act as a proxy for PacketSender::recv_lX methods. + * \param sender The packet sender which will receive the packet. + */ + virtual PDU *recv_response(PacketSender *sender) { return false; } + + /** \brief Check wether ptr points to a valid response for this PDU. + * + * This method must check wether the buffer pointed by ptr is a valid + * response for this PDU. If it is valid, then it might want to propagate + * the call to the next PDU. Note that in some cases, such as ICMP + * Host Unreachable, there is no need to ask the next layer for matching. + * \param ptr The pointer to the buffer. + * \param total_sz The size of the buffer. + */ + virtual bool matches_response(uint8_t *ptr, uint32_t total_sz) { return false; } + + virtual PDU *clone_packet(uint8_t *ptr, uint32_t total_sz) { return 0; } protected: /* Serialize this PDU storing the result in buffer. */ void serialize(uint8_t *buffer, uint32_t total_sz, const PDU *parent); diff --git a/src/icmp.cpp b/src/icmp.cpp index f117292..88b78c0 100644 --- a/src/icmp.cpp +++ b/src/icmp.cpp @@ -4,6 +4,7 @@ #include #include #include "icmp.h" +#include "rawpdu.h" #include "utils.h" @@ -26,6 +27,10 @@ Tins::ICMP::ICMP(Flags flag) : PDU(IPPROTO_ICMP) { }; } +Tins::ICMP::ICMP(icmphdr *ptr) : PDU(IPPROTO_ICMP) { + std::memcpy(&_icmp, ptr, sizeof(icmphdr)); +} + void Tins::ICMP::code(uint8_t new_code) { _icmp.code = new_code; } @@ -121,4 +126,32 @@ void Tins::ICMP::write_serialization(uint8_t *buffer, uint32_t total_sz, const P _icmp.check = 0; } +bool Tins::ICMP::matches_response(uint8_t *ptr, uint32_t total_sz) { + if(total_sz < sizeof(icmphdr)) + return false; + icmphdr *icmp_ptr = (icmphdr*)ptr; + if(_icmp.type == ECHO_REQUEST) { + return icmp_ptr->type == ECHO_REPLY && icmp_ptr->un.echo.id == _icmp.un.echo.id && icmp_ptr->un.echo.sequence == _icmp.un.echo.sequence; + } + return false; +} +Tins::PDU *Tins::ICMP::clone_packet(uint8_t *ptr, uint32_t total_sz) { + if(total_sz < sizeof(icmphdr)) + return 0; + icmphdr *icmp_ptr = (icmphdr*)ptr; + PDU *child = 0, *cloned; + if(total_sz > sizeof(icmphdr)) { + if(inner_pdu()) { + child = inner_pdu()->clone_packet(ptr + sizeof(icmphdr), total_sz - sizeof(icmphdr)); + if(!child) + return 0; + } + else + child = new RawPDU(ptr + sizeof(icmphdr), total_sz - sizeof(icmphdr)); + + } + cloned = new ICMP(icmp_ptr); + cloned->inner_pdu(child); + return cloned; +} diff --git a/src/ip.cpp b/src/ip.cpp index a59c08c..b67c8e1 100644 --- a/src/ip.cpp +++ b/src/ip.cpp @@ -25,6 +25,7 @@ #include #endif #include "ip.h" +#include "rawpdu.h" #include "utils.h" #include @@ -42,6 +43,11 @@ Tins::IP::IP(const string &ip_dst, const string &ip_src, PDU *child) : PDU(IPPRO } +Tins::IP::IP(const iphdr *ptr) : PDU(IPPROTO_IP) { + std::memcpy(&_ip, ptr, sizeof(iphdr)); + /* Options... */ +} + Tins::IP::IP(uint32_t ip_dst, uint32_t ip_src, PDU *child) : PDU(IPPROTO_IP, child) { init_ip_fields(); _ip.daddr = ip_dst; @@ -153,16 +159,30 @@ uint8_t* Tins::IP::IpOption::write(uint8_t* buffer) { uint32_t Tins::IP::header_size() const { return sizeof(iphdr) + _padded_options_size; - } bool Tins::IP::send(PacketSender* sender) { struct sockaddr_in link_addr; + PacketSender::SocketType type = PacketSender::IP_SOCKET; link_addr.sin_family = AF_INET; link_addr.sin_port = 0; link_addr.sin_addr.s_addr = _ip.daddr; + if(inner_pdu() && inner_pdu()->flag() == IPPROTO_ICMP) + type = PacketSender::ICMP_SOCKET; - return sender->send_l3(this, (const struct sockaddr*)&link_addr, sizeof(link_addr)); + return sender->send_l3(this, (struct sockaddr*)&link_addr, sizeof(link_addr), type); +} + +Tins::PDU *Tins::IP::recv_response(PacketSender *sender) { + struct sockaddr_in link_addr; + PacketSender::SocketType type = PacketSender::IP_SOCKET; + link_addr.sin_family = AF_INET; + link_addr.sin_port = 0; + link_addr.sin_addr.s_addr = _ip.daddr; + if(inner_pdu() && inner_pdu()->flag() == IPPROTO_ICMP) + type = PacketSender::ICMP_SOCKET; + + return sender->recv_l3(this, (struct sockaddr*)&link_addr, sizeof(link_addr), type); } void Tins::IP::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *) { @@ -187,3 +207,36 @@ void Tins::IP::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU for (uint32_t i = 0; i < _ip_options.size(); ++i) buffer = _ip_options[i].write(buffer); } + +bool Tins::IP::matches_response(uint8_t *ptr, uint32_t total_sz) { + if(total_sz < sizeof(iphdr)) + return false; + iphdr *ip_ptr = (iphdr*)ptr; + if(_ip.daddr == ip_ptr->saddr && _ip.saddr == ip_ptr->daddr) { + uint32_t sz = _ip.ihl * sizeof(uint32_t); + return inner_pdu() ? inner_pdu()->matches_response(ptr + sz, total_sz - sz) : true; + } + return false; +} + +Tins::PDU *Tins::IP::clone_packet(uint8_t *ptr, uint32_t total_sz) { + if(total_sz < sizeof(iphdr)) + return 0; + iphdr *ip_ptr = (iphdr*)ptr; + uint32_t sz = ip_ptr->ihl * sizeof(uint32_t); + if(total_sz < sz) + return 0; + PDU *child = 0, *cloned; + if(total_sz > sz) { + if(inner_pdu()) { + child = inner_pdu()->clone_packet(ptr + sz, total_sz - sz); + if(!child) + return 0; + } + else + child = new RawPDU(ptr + sz, total_sz - sz); + } + cloned = new IP(ip_ptr); + cloned->inner_pdu(child); + return cloned; +} diff --git a/src/packetsender.cpp b/src/packetsender.cpp index 43dc7c5..eff7852 100644 --- a/src/packetsender.cpp +++ b/src/packetsender.cpp @@ -24,21 +24,23 @@ #include #include #include - #include - #include + #include + #include #include #endif #include -#include +#include //borrar #include #include #include "packetsender.h" +#include "utils.h" //borrar const int Tins::PacketSender::INVALID_RAW_SOCKET = -10; Tins::PacketSender::PacketSender() : _sockets(SOCKETS_END, INVALID_RAW_SOCKET) { - + _types[IP_SOCKET] = IPPROTO_RAW; + _types[ICMP_SOCKET] = IPPROTO_ICMP; } bool Tins::PacketSender::open_l2_socket() { @@ -48,18 +50,21 @@ bool Tins::PacketSender::open_l2_socket() { return false; } -bool Tins::PacketSender::open_l3_socket() { - if(_sockets[IP_SOCKET] != INVALID_RAW_SOCKET) +bool Tins::PacketSender::open_l3_socket(SocketType type) { + int socktype = find_type(type); + if(socktype == -1) + return false; + if(_sockets[type] != INVALID_RAW_SOCKET) return true; int sockfd; - sockfd = socket(AF_INET, SOCK_RAW, IPPROTO_RAW); + sockfd = socket(AF_INET, SOCK_RAW, socktype); if (sockfd < 0) return false; const int on = 1; - setsockopt(sockfd, IPPROTO_IP,IP_HDRINCL,(const void *)&on,sizeof(on)); + setsockopt(sockfd, IPPROTO_IP, IP_HDRINCL,(const void *)&on,sizeof(on)); - _sockets[IP_SOCKET] = sockfd; + _sockets[type] = sockfd; return true; } @@ -75,6 +80,12 @@ bool Tins::PacketSender::send(PDU *pdu) { return pdu->send(this); } +Tins::PDU *Tins::PacketSender::send_recv(PDU *pdu) { + if(!pdu->send(this)) + return 0; + return pdu->recv_response(this); +} + bool Tins::PacketSender::send_l2(PDU *pdu) { /* To be implemented */ @@ -82,18 +93,42 @@ bool Tins::PacketSender::send_l2(PDU *pdu) { return false; } -bool Tins::PacketSender::send_l3(PDU *pdu, const struct sockaddr* link_addr, uint32_t len_link_addr) { +Tins::PDU *Tins::PacketSender::recv_l3(PDU *pdu, struct sockaddr *link_addr, uint32_t len_link_addr, SocketType type) { + if(!open_l3_socket(type)) + return 0; + uint8_t buffer[2048]; + int sock = _sockets[type]; + bool done = false; + socklen_t addrlen = len_link_addr; + + while(!done) { + ssize_t size = recvfrom(sock, buffer, 2048, 0, link_addr, &addrlen); + if(size == -1) + return 0; + if(pdu->matches_response(buffer, size)) + return pdu->clone_packet(buffer, size); + } + return 0; +} + +bool Tins::PacketSender::send_l3(PDU *pdu, struct sockaddr* link_addr, uint32_t len_link_addr, SocketType type) { bool ret_val = true; - if(!open_l3_socket()) + if(!open_l3_socket(type)) ret_val = false; if (ret_val) { uint32_t sz; - int sock = _sockets[IP_SOCKET]; + int sock = _sockets[type]; uint8_t *buffer = pdu->serialize(sz); ret_val = (sendto(sock, buffer, sz, 0, link_addr, len_link_addr) != -1); delete[] buffer; } - return ret_val; - +} + +int Tins::PacketSender::find_type(SocketType type) { + SocketTypeMap::iterator it = _types.find(type); + if(it == _types.end()) + return -1; + else + return it->second; }