3rd-party/libtins
1
0
Fork 0
mirror of https://github.com/mfontanini/libtins synced 2026-01-23 02:35:57 +01:00
Code Issues Releases Wiki Activity

Started utils test. cChanged IP format

Browse Source
This commit is contained in:
Santiago Alessandri
2011-09-22 22:53:09 -03:00
parent 88172a9f07
commit 9e98e2e454
10 changed files with 306 additions and 127 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
include/arp.h
View File

@@ -59,7 +59,7 @@ namespace Tins {
* \param total_sz The total size of the buffer.
*/
ARP(const uint8_t *buffer, uint32_t total_sz);
/* Getters */
/**
* \brief Getter for the sender's hardware address.
@@ -73,7 +73,7 @@ namespace Tins {
*
* \return Returns the sender's IP address in an uint32_t.
*/
inline const uint32_t sender_ip_addr() { return this->_arp.ar_sip; }
inline const uint32_t sender_ip_addr() { return Utils::net_to_host_l(this->_arp.ar_sip); }
/**
* \brief Getter for the target's hardware address.
@@ -87,7 +87,7 @@ namespace Tins {
*
* \return Returns the target's IP address in an uint32_t.
*/
inline const uint32_t target_ip_addr() { return this->_arp.ar_tip; }
inline const uint32_t target_ip_addr() { return Utils::net_to_host_l(this->_arp.ar_tip); }
/**
* \brief Getter for the hardware address format.
@@ -317,7 +317,7 @@ namespace Tins {
/**
* \brief Clones this PDU.
*
*
* \sa PDU::clone_pdu
*/
PDU *clone_pdu() const;
@@ -334,7 +334,7 @@ namespace Tins {
uint8_t ar_tha[6]; /* target hardware address */
uint32_t ar_tip; /* target IP address */
} __attribute__((__packed__));
void copy_fields(const ARP *other);
void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);

104
include/bootp.h
View File

@@ -41,217 +41,217 @@ namespace Tins {
*/
enum OpCodes {
BOOTREQUEST = 1,
BOOTREPLY = 2
BOOTREPLY = 2
};
/**
/**
* \brief Creates an instance of BootP.
*
*
* This sets the size of the vend field to 64, as the BootP RFC
* states.
*/
BootP();
/**
* \brief Constructor which creates a BootP object from a buffer and adds all identifiable
* PDUs found in the buffer as children of this one.
* \param buffer The buffer from which this PDU will be constructed.
* \param total_sz The total size of the buffer.
* \param vend_field_size The vend field size to allocate.
* \param vend_field_size The vend field size to allocate.
* Subclasses might use 0 to provide their own interpretation of this field.
*/
BootP(const uint8_t *buffer, uint32_t total_sz, uint32_t vend_field_size = 64);
/**
* \brief Copy constructor.
*/
BootP(const BootP &other);
/**
* \brief Copy assignment operator.
*/
BootP &operator= (const BootP &other);
/** \brief BootP destructor.
*
*
* This frees the memory allocated to hold the vend field.
*/
~BootP();
/* Getters */
/** \brief Getter for the opcode field.
* \return The opcode field for this BootP PDU.
*/
uint8_t opcode() const { return _bootp.opcode; }
/** \brief Getter for the htype field.
* \return The htype field for this BootP PDU.
*/
uint8_t htype() const { return _bootp.htype; }
/** \brief Getter for the hlen field.
* \return The hlen field for this BootP PDU.
*/
uint8_t hlen() const { return _bootp.hlen; }
/** \brief Getter for the hops field.
* \return The hops field for this BootP PDU.
*/
uint8_t hops() const { return _bootp.hops; }
/** \brief Getter for the xid field.
* \return The xid field for this BootP PDU.
*/
uint32_t xid() const { return Utils::net_to_host_l(_bootp.xid); }
/** \brief Getter for the secs field.
* \return The secs field for this BootP PDU.
*/
uint16_t secs() const { return Utils::net_to_host_s(_bootp.secs); }
/** \brief Getter for the padding field.
* \return The padding field for this BootP PDU.
*/
uint16_t padding() const { return Utils::net_to_host_s(_bootp.padding); }
/** \brief Getter for the ciaddr field.
* \return The ciaddr field for this BootP PDU.
*/
uint32_t ciaddr() const { return _bootp.ciaddr; }
uint32_t ciaddr() const { return Utils::net_to_host_l(_bootp.ciaddr); }
/** \brief Getter for the yiaddr field.
* \return The yiaddr field for this BootP PDU.
*/
uint32_t yiaddr() const { return _bootp.yiaddr; }
uint32_t yiaddr() const { return Utils::net_to_host_l(_bootp.yiaddr); }
/** \brief Getter for the siaddr field.
* \return The siaddr field for this BootP PDU.
*/
uint32_t siaddr() const { return _bootp.siaddr; }
uint32_t siaddr() const { return Utils::net_to_host_l(_bootp.siaddr); }
/** \brief Getter for the giaddr field.
* \return The giaddr field for this BootP PDU.
*/
uint32_t giaddr() const { return _bootp.giaddr; }
uint32_t giaddr() const { return Utils::net_to_host_l(_bootp.giaddr); }
/** \brief Getter for the chaddr field.
* \return The chddr field for this BootP PDU.
*/
const uint8_t *chaddr() const { return _bootp.chaddr; }
/** \brief Getter for the sname field.
* \return The sname field for this BootP PDU.
*/
const uint8_t *sname() const { return _bootp.sname; }
/** \brief Getter for the file field.
* \return The file field for this BootP PDU.
*/
const uint8_t *file() const { return _bootp.file; }
/** \brief Getter for the vend field.
* \return The vend field for this BootP PDU.
*/
uint8_t *vend() { return _vend; }
/** \brief Getter for the vend field.
*/
uint32_t vend_size() const { return _vend_size; }
/** \brief Getter for the header size.
* \return Returns the BOOTP header size.
* \sa PDU::header_size
*/
*/
uint32_t header_size() const;
/* Setters */
/** \brief Setter for the opcode field.
* \param new_opcode The opcode to be set.
*/
void opcode(uint8_t new_opcode);
/** \brief Setter for the htype field.
* \param new_htype The htype to be set.
*/
void htype(uint8_t new_htype);
/** \brief Setter for the hlen field.
* \param new_hlen The hlen to be set.
*/
void hlen(uint8_t new_hlen);
/** \brief Setter for the hops field.
* \param new_hops The hops to be set.
*/
void hops(uint8_t new_hops);
/** \brief Setter for the xid field.
* \param new_xid The xid to be set.
*/
void xid(uint32_t new_xid);
/** \brief Setter for the secs field.
* \param new_secs The secs to be set.
*/
void secs(uint16_t new_secs);
/** \brief Setter for the padding field.
* \param new_padding The padding to be set.
*/
void padding(uint16_t new_padding);
/** \brief Setter for the ciaddr field.
* \param new_ciaddr The ciaddr to be set.
*/
void ciaddr(uint32_t new_ciaddr);
/** \brief Setter for the yiaddr field.
* \param new_yiaddr The yiaddr to be set.
*/
void yiaddr(uint32_t new_yiaddr);
/** \brief Setter for the siaddr field.
* \param new_siaddr The siaddr to be set.
*/
void siaddr(uint32_t new_siaddr);
/** \brief Setter for the giaddr field.
* \param new_giaddr The giaddr to be set.
*/
void giaddr(uint32_t new_giaddr);
/** \brief Setter for the chaddr field.
* The new_chaddr pointer must be at least BOOTP::hlen() bytes long.
* \param new_chaddr The chaddr to be set.
*/
void chaddr(const uint8_t *new_chaddr);
/** \brief Setter for the sname field.
* \param new_sname The sname to be set.
*/
void sname(const uint8_t *new_sname);
/** \brief Setter for the file field.
* \param new_file The file to be set.
*/
void file(const uint8_t *new_file);
/** \brief Setter for the vend field.
* \param new_vend The vend to be set.
* \param size The size of the new vend field.
*/
void vend(uint8_t *new_vend, uint32_t size);
/**
* \brief Getter for the PDU's type.
* \sa PDU::pdu_type
*/
PDUType pdu_type() const { return PDU::BOOTP; }
/**
* \brief Clones this PDU.
*
*
* \sa PDU::clone_pdu
*/
PDU *clone_pdu() const;
@@ -278,7 +278,7 @@ namespace Tins {
uint8_t sname[64];
uint8_t file[128];
} __attribute__((__packed__));
bootphdr _bootp;
uint8_t *_vend;
uint32_t _vend_size;

16
include/ip.h
View File

@@ -38,11 +38,11 @@ namespace Tins {
*/
class IP : public PDU {
public:
/**
/**
* \brief IP address size.
*/
static const uint32_t ADDR_SIZE = 4;
/**
* \brief Enum indicating the option's class.
*
@@ -85,7 +85,7 @@ namespace Tins {
* \brief Default constructor.
*/
IP();
/**
* \brief Constructor for building the IP PDU taking strings as ip addresses.
*
@@ -199,12 +199,12 @@ namespace Tins {
*
* \return The source address for this IP PDU.
*/
inline uint32_t src_addr() const { return _ip.saddr; }
inline uint32_t src_addr() const { return Utils::net_to_host_l(_ip.saddr); }
/** \brief Getter for the destination address field.
* \return The destination address for this IP PDU.
*/
inline uint32_t dst_addr() const { return _ip.daddr; }
inline uint32_t dst_addr() const { return Utils::net_to_host_l(_ip.daddr); }
/* Setters */
@@ -369,10 +369,10 @@ namespace Tins {
* \sa PDU::clone_packet
*/
PDU *clone_packet(const uint8_t *ptr, uint32_t total_sz);
/**
* \brief Clones this PDU.
*
*
* \sa PDU::clone_pdu
*/
PDU *clone_pdu() const;
@@ -419,7 +419,7 @@ namespace Tins {
uint8_t* write(uint8_t* buffer);
} __attribute__((__packed__));
void copy_fields(const IP *other);
void init_ip_fields();
void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);

17
include/utils.h
View File

@@ -22,6 +22,7 @@
#ifndef __UTILS_H
#define __UTILS_H
#include <stdexcept>
#ifndef WIN32
#include <ifaddrs.h>
@@ -43,7 +44,7 @@ namespace Tins {
*
* \param ip A dotted ip notation string
*/
uint32_t ip_to_int(const std::string &ip);
uint32_t ip_to_int(const std::string &ip) throw (std::runtime_error);
/** \brief Convert an integer ip to a dotted-ip-notation string.
*
@@ -76,7 +77,7 @@ namespace Tins {
*
* \param to_resolve The domain name/ip address to resolve.
*/
uint32_t resolve_ip(const std::string &to_resolve);
uint32_t resolve_ip(const std::string &to_resolve) throw (std::runtime_error);
/** \brief Resolves the hardware address for a given ip.
*
@@ -168,15 +169,15 @@ namespace Tins {
* \param data The input buffer.
* \param data_size The size of the input buffer.
*/
uint32_t crc32(uint8_t* data, uint32_t data_size);
uint32_t crc32(const uint8_t* data, uint32_t data_size);
/**
* \brief Converts a channel number to its mhz representation.
* \param channel The channel number.
* \return The channel's mhz representation.
*/
uint16_t channel_to_mhz(uint16_t channel);
/** \brief Does the 16 bits sum of all 2 bytes elements between start and end.
*
* This is the checksum used by IP, UDP and TCP. If there's and odd number of
@@ -186,8 +187,8 @@ namespace Tins {
* \param end The pointer to the end of the buffer(excluding the last element).
* \return Returns the checksum between start and end(non inclusive).
*/
uint32_t do_checksum(uint8_t *start, uint8_t *end);
uint32_t do_checksum(const uint8_t *start, const uint8_t *end);
/** \brief Performs the pseudo header checksum used in TCP and UDP PDUs.
*
* \param source_ip The source ip address.
@@ -197,7 +198,7 @@ namespace Tins {
* \return The pseudo header checksum.
*/
uint32_t pseudoheader_checksum(uint32_t source_ip, uint32_t dest_ip, uint32_t len, uint32_t flag);
/** \brief Generic function to iterate through interface and collect
* data.
*

8
src/arp.cpp
View File

@@ -62,11 +62,11 @@ void Tins::ARP::sender_hw_addr(const uint8_t* new_snd_hw_addr) {
}
void Tins::ARP::sender_ip_addr(uint32_t new_snd_ip_addr) {
this->_arp.ar_sip = new_snd_ip_addr;
this->_arp.ar_sip = Utils::net_to_host_l(new_snd_ip_addr);
}
void Tins::ARP::sender_ip_addr(const string& new_snd_ip_addr) {
this->_arp.ar_sip = Utils::ip_to_int(new_snd_ip_addr);
this->_arp.ar_sip = Utils::net_to_host_l(Utils::resolve_ip(new_snd_ip_addr));
}
void Tins::ARP::target_hw_addr(const uint8_t* new_tgt_hw_addr) {
@@ -74,11 +74,11 @@ void Tins::ARP::target_hw_addr(const uint8_t* new_tgt_hw_addr) {
}
void Tins::ARP::target_ip_addr(uint32_t new_tgt_ip_addr) {
this->_arp.ar_tip = new_tgt_ip_addr;
this->_arp.ar_tip = Utils::net_to_host_l(new_tgt_ip_addr);
}
void Tins::ARP::target_ip_addr(const std::string& new_tgt_ip_addr) {
this->_arp.ar_tip = Utils::ip_to_int(new_tgt_ip_addr);
this->_arp.ar_tip = Utils::net_to_host_l(Utils::resolve_ip(new_tgt_ip_addr));
}
void Tins::ARP::hw_addr_format(uint16_t new_hw_addr_fmt) {

8
src/bootp.cpp
View File

@@ -70,19 +70,19 @@ void Tins::BootP::padding(uint16_t new_padding) {
}
void Tins::BootP::ciaddr(uint32_t new_ciaddr) {
_bootp.ciaddr = new_ciaddr;
_bootp.ciaddr = Utils::net_to_host_l(new_ciaddr);
}
void Tins::BootP::yiaddr(uint32_t new_yiaddr) {
_bootp.yiaddr = new_yiaddr;
_bootp.yiaddr = Utils::net_to_host_l(new_yiaddr);
}
void Tins::BootP::siaddr(uint32_t new_siaddr) {
_bootp.siaddr = new_siaddr;
_bootp.siaddr = Utils::net_to_host_l(new_siaddr);
}
void Tins::BootP::giaddr(uint32_t new_giaddr) {
_bootp.giaddr = new_giaddr;
_bootp.giaddr = Utils::net_to_host_l(new_giaddr);
}
void Tins::BootP::chaddr(const uint8_t *new_chaddr) {

16
src/ip.cpp
View File

@@ -43,9 +43,9 @@ const uint8_t Tins::IP::DEFAULT_TTL = 128;
Tins::IP::IP(const string &ip_dst, const string &ip_src, PDU *child) : PDU(Constants::IP::PROTO_IP, child) {
init_ip_fields();
if(ip_dst.size())
_ip.daddr = Utils::resolve_ip(ip_dst);
this->dst_addr(ip_dst);
if(ip_src.size())
_ip.saddr = Utils::resolve_ip(ip_src);
this->src_addr(ip_src);
}
@@ -146,8 +146,8 @@ Tins::IP::IP(const uint8_t *buffer, uint32_t total_sz) : PDU(Constants::IP::PROT
Tins::IP::IP(uint32_t ip_dst, uint32_t ip_src, PDU *child) : PDU(Constants::IP::PROTO_IP, child) {
init_ip_fields();
_ip.daddr = ip_dst;
_ip.saddr = ip_src;
this->dst_addr(ip_dst);
this->src_addr(ip_src);
}
Tins::IP::~IP() {
@@ -200,19 +200,19 @@ void Tins::IP::check(uint16_t new_check) {
}
void Tins::IP::src_addr(const string &ip) {
_ip.saddr = Utils::resolve_ip(ip);
_ip.saddr = Utils::net_to_host_l(Utils::resolve_ip(ip));
}
void Tins::IP::src_addr(uint32_t ip) {
_ip.saddr = ip;
_ip.saddr = Utils::net_to_host_l(ip);
}
void Tins::IP::dst_addr(const string &ip) {
_ip.daddr = Utils::resolve_ip(ip);
_ip.daddr = Utils::net_to_host_l(Utils::resolve_ip(ip));
}
void Tins::IP::dst_addr(uint32_t ip) {
_ip.daddr = ip;
_ip.daddr = Utils::net_to_host_l(ip);
}
void Tins::IP::head_len(uint8_t new_head_len) {

25
src/utils.cpp
View File

@@ -103,10 +103,10 @@ void skip_line(istream &input) {
/** \endcond */
uint32_t Tins::Utils::ip_to_int(const string &ip) {
uint32_t Tins::Utils::ip_to_int(const string &ip) throw (std::runtime_error) {
uint32_t result(0), i(0), end, bytes_found(0);
while(i < ip.size() && bytes_found < 4) {
uint8_t this_byte(0);
uint16_t this_byte(0);
end = i + 3;
while(i < ip.size() && i < end && ip[i] != '.') {
if(ip[i] < '0' || ip[i] > '9')
@@ -114,20 +114,22 @@ uint32_t Tins::Utils::ip_to_int(const string &ip) {
this_byte = (this_byte * 10) + (ip[i] - '0');
i++;
}
result = (result << 8) | this_byte;
if (this_byte > 0xFF) {
throw std::runtime_error("Byte greater than 255");
}
result = (result << 8) | (this_byte & 0xFF);
bytes_found++;
if(bytes_found < 4 && i < ip.size() && ip[i] == '.')
i++;
}
if(bytes_found < 4 || (i < ip.size() && bytes_found == 4))
throw std::runtime_error("Invalid ip address");
return net_to_host_l(result);
return result;
}
string Tins::Utils::ip_to_string(uint32_t ip) {
ostringstream oss;
int mask(24);
ip = net_to_host_l(ip);
while(mask >=0) {
oss << ((ip >> mask) & 0xff);
if(mask)
@@ -178,11 +180,11 @@ string Tins::Utils::hwaddr_to_string(const uint8_t *array) {
return oss.str();
}
uint32_t Tins::Utils::resolve_ip(const string &to_resolve) {
uint32_t Tins::Utils::resolve_ip(const string &to_resolve) throw (std::runtime_error) {
struct hostent *data = gethostbyname(to_resolve.c_str());
if(!data)
return 0;
return ((struct in_addr**)data->h_addr_list)[0]->s_addr;
throw std::runtime_error("Could not resolve IP");
return Utils::net_to_host_l(((struct in_addr**)data->h_addr_list)[0]->s_addr);
}
bool Tins::Utils::resolve_hwaddr(const string &iface, uint32_t ip, uint8_t *buffer, PacketSender *sender) {
@@ -210,6 +212,7 @@ string Tins::Utils::interface_from_ip(uint32_t ip) {
string iface;
string destination, mask;
uint32_t destination_int, mask_int;
ip = Utils::net_to_host_l(ip);
skip_line(input);
while(!match) {
input >> iface >> destination;
@@ -233,7 +236,7 @@ set<string> Tins::Utils::network_interfaces() {
bool Tins::Utils::interface_ip(const string &iface, uint32_t &ip) {
IPv4Collector collector(iface.c_str());
generic_iface_loop(collector);
ip = collector.ip;
ip = Utils::net_to_host_l(collector.ip);
return collector.found;
}
@@ -252,7 +255,7 @@ uint16_t Tins::Utils::channel_to_mhz(uint16_t channel) {
return 2407 + (channel * 5);
}
uint32_t Tins::Utils::do_checksum(uint8_t *start, uint8_t *end) {
uint32_t Tins::Utils::do_checksum(const uint8_t *start, const uint8_t *end) {
uint32_t checksum(0);
uint16_t *ptr = (uint16_t*)start, *last = (uint16_t*)end, padding(0);
if(((end - start) & 1) == 1) {
@@ -277,7 +280,7 @@ uint32_t Tins::Utils::pseudoheader_checksum(uint32_t source_ip, uint32_t dest_ip
return checksum;
}
uint32_t Tins::Utils::crc32(uint8_t* data, uint32_t data_size) {
uint32_t Tins::Utils::crc32(const uint8_t* data, uint32_t data_size) {
uint32_t i, crc = 0;
static uint32_t crc_table[] = {
0x4DBDF21C, 0x500AE278, 0x76D3D2D4, 0x6B64C2B0,

54
tests/src/dhcp.cpp
View File

@@ -3,7 +3,7 @@
#include <string>
#include <stdint.h>
#include <list>
#include <string>
#include <string>
#include "dhcp.h"
#include "utils.h"
#include "ethernetII.h"
@@ -15,7 +15,7 @@ class DHCPTest : public testing::Test {
public:
static const uint8_t expected_packet[];
static const uint8_t chaddr[], sname[], file[];
void test_equals(const DHCP &dhcp1, const DHCP &dhcp2);
void test_option(const DHCP &dhcp, DHCP::Options opt, uint32_t len = 0, uint8_t *value = 0);
};
@@ -34,25 +34,25 @@ const uint8_t DHCPTest::file[] = "\x16\xab\x54\x12\xfa\xca\x56\x7f\x1b\x65\x11\x
"\x16\xab\x54\x12\xfa\xca\x56\x7f\x1b\x65\x11\xfa\xda\xeb\x19\x18"
"\x16\xab\x54\x12\xfa\xca\x56\x7f\x1b\x65\x11\xfa\xda\xfb\x19\x18";
const uint8_t DHCPTest::expected_packet[] = {'\x01', '\x01', '\x06', '\x1f', '?', '\xab', '#', '\xde',
'\x9f', '\x1a', '\x00', '\x00', '\xc0', '\xa8', '\x00', 'f', '\xf3', '\x16', '"', 'b', '\xa7', ' ',
'\x0b', '\x9a', '{', '+', '7', '\xfe', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', 'c', '\x82', 'S', 'c', '6', '\x04', '\xc0', '\xa8', '\x04', '\x02',
const uint8_t DHCPTest::expected_packet[] = {'\x01', '\x01', '\x06', '\x1f', '?', '\xab', '#', '\xde',
'\x9f', '\x1a', '\x00', '\x00', '\xc0', '\xa8', '\x00', 'f', '\xf3', '\x16', '"', 'b', '\xa7', ' ',
'\x0b', '\x9a', '{', '+', '7', '\xfe', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00',
'\x00', '\x00', '\x00', '\x00', '\x00', 'c', '\x82', 'S', 'c', '6', '\x04', '\xc0', '\xa8', '\x04', '\x02',
'\x01', '\x04', '\xff', '\xff', ' ', '\x0b', '5', '\x01', '\x04'};
TEST_F(DHCPTest, DefaultConstructor) {
@@ -192,7 +192,7 @@ TEST_F(DHCPTest, RoutersOption) {
routers.push_back(Utils::ip_to_int("192.168.0.253"));
routers.push_back(Utils::ip_to_int("10.123.45.67"));
dhcp.add_routers_option(routers);
list<uint32_t> routers2;
ASSERT_TRUE(dhcp.search_routers_option(&routers2));
ASSERT_EQ(routers.size(), routers2.size());
@@ -209,7 +209,7 @@ TEST_F(DHCPTest, DNSOption) {
dns.push_back(Utils::ip_to_int("192.168.0.253"));
dns.push_back(Utils::ip_to_int("10.123.45.67"));
dhcp.add_dns_option(dns);
list<uint32_t> dns2;
ASSERT_TRUE(dhcp.search_dns_option(&dns2));
ASSERT_EQ(dns.size(), dns2.size());
@@ -267,7 +267,7 @@ void DHCPTest::test_equals(const DHCP &dhcp1, const DHCP &dhcp2) {
TEST_F(DHCPTest, ConstructorFromBuffer) {
DHCP dhcp1(expected_packet, sizeof(expected_packet));
uint32_t ip;
EXPECT_EQ(dhcp1.opcode(), DHCP::DISCOVER);
EXPECT_EQ(dhcp1.htype(), 1);
ASSERT_EQ(dhcp1.hlen(), EthernetII::ADDR_SIZE);
@@ -280,11 +280,11 @@ TEST_F(DHCPTest, ConstructorFromBuffer) {
EXPECT_EQ(dhcp1.giaddr(), Utils::ip_to_int("123.43.55.254"));
EXPECT_EQ(dhcp1.siaddr(), Utils::ip_to_int("167.32.11.154"));
ASSERT_TRUE(dhcp1.search_server_identifier(&ip));
EXPECT_EQ(ip, Utils::ip_to_int("192.168.4.2"));
EXPECT_EQ(ip, Utils::net_to_host_l(Utils::ip_to_int("192.168.4.2")));
uint32_t size;
uint8_t *buffer = dhcp1.serialize(size);
DHCP dhcp2(buffer, size);
test_equals(dhcp1, dhcp2);
delete[] buffer;

175
tests/src/utils_test.cpp Normal file
View File

@@ -0,0 +1,175 @@
#include <iostream>
#include <stdexcept>
#include "utils.h"
#include <gtest/gtest.h>
using namespace Tins;
class UtilsTest : public testing::Test {
public:
static const uint32_t zero_int_ip; // "0.0.0.0"
static const uint32_t full_int_ip; // "255.255.255.255"
static const uint32_t mix_int_ip; // "1.2.255.3"
static const uint8_t zero_hw_addr[];
static const uint8_t full_hw_addr[];
static const uint8_t mix_hw_addr[];
static const uint8_t data[];
static const uint32_t data_len;
};
const uint32_t UtilsTest::zero_int_ip = 0; // "0.0.0.0"
const uint32_t UtilsTest::full_int_ip = 0xFFFFFFFF; // "255.255.255.255"
const uint32_t UtilsTest::mix_int_ip = 0x0102FF03; // "1.2.255.3"
const uint8_t UtilsTest::zero_hw_addr[] = {'\x00', '\x00', '\x00', '\x00', '\x00', '\x00'};
const uint8_t UtilsTest::full_hw_addr[] = {'\xFF', '\xFF', '\xFF', '\xFF', '\xFF', '\xFF'};
const uint8_t UtilsTest::mix_hw_addr[] = {'\x01', '\x02', '\x03', '\x04', '\x05', '\x06'};
const uint8_t UtilsTest::data[] = {
215, 3, 132, 147, 170, 153, 240, 223, 227, 47, 144, 146, 52, 154, 192, 106,
195, 167, 160, 119, 154, 134, 59, 150, 6, 236, 67, 216, 7, 19, 110, 226, 228,
99, 103, 18, 39, 23, 157, 192, 38, 37, 23, 211, 77, 86, 176, 103, 62, 226, 235,
236, 114, 39, 216, 202, 236, 251, 158, 249, 89, 248, 80, 95, 245, 35, 61, 97,
242, 90, 122, 196, 187, 202, 15, 197, 204, 180, 183, 68, 65, 99, 209, 172, 80,
189, 188, 18, 216, 82, 103, 53, 3, 246, 183, 4, 56, 201, 5, 42, 94, 108, 30, 90,
183, 203, 193, 19, 128, 79, 156, 189, 18, 163, 67, 152, 153, 114, 151, 125, 114,
87, 105, 31, 212, 238, 154, 238, 82, 216, 244, 2, 33, 137, 126, 67, 176, 224, 95,
175, 205, 175, 91, 41, 101, 34, 178, 199, 88, 211, 91, 235, 42, 21, 182, 138,
185, 61, 205, 61, 245, 85, 18, 119, 253, 214, 127, 164, 31, 225, 140, 58, 103,
235, 231, 226, 119, 97, 86, 11, 56, 95, 218, 207, 137, 216, 141, 46, 82, 39, 158,
243, 131, 217, 197, 177, 239, 30, 145, 249, 162, 141, 252, 213, 132, 87, 42, 130,
213, 92, 47, 163, 113, 230, 59, 205, 19, 90, 65, 134, 181, 44, 150, 254, 73, 186,
194, 122, 96, 65, 114, 233, 245, 25, 194, 80, 174, 223, 158, 45, 131, 188, 222,
52, 212, 250, 96, 172, 181, 115, 252, 40, 249, 99, 65, 23, 118, 71, 124, 112, 228,
204, 106, 169, 40, 148, 72, 183, 252, 234, 83, 116, 109, 54, 233, 58, 231, 5, 88,
36, 77, 253, 75, 90, 250, 177, 159, 199, 180, 134, 211, 161, 175, 75, 161, 72, 80,
73, 163, 76, 160, 119, 226, 248, 231, 62, 91, 74, 32, 156, 9, 64, 170, 79, 38, 45,
204, 58, 144, 76, 226, 130, 21, 151, 239, 40, 116, 52, 77, 18, 6, 199, 42, 200, 213,
232, 12, 61, 156, 51, 23, 165, 11, 7, 149, 30, 27, 119, 216, 246, 93, 24, 111, 105,
218, 100, 45, 57, 69, 229, 168, 105, 99, 35, 41, 71, 255, 80, 255, 22, 7, 61, 211,
134, 113, 48, 255, 220, 26, 32, 6, 184, 204, 40, 194, 47, 201, 249, 133, 194, 203,
172, 123, 186, 77, 39, 92, 64, 52, 91, 187, 83, 58, 73, 65, 192, 150, 103, 230, 187,
165, 149, 84, 71, 142, 55, 69, 87, 102, 97, 20, 134, 184, 107, 133, 57, 57, 220, 121,
211, 241, 97, 172, 67, 208, 9, 151, 14, 200, 73, 31, 140, 34, 176, 215, 111, 4, 143,
13, 173, 193, 145, 255, 112, 249, 191, 88, 181, 113, 221, 50, 45, 34, 176, 203, 154,
65, 193, 6, 120, 182, 235, 250, 21, 136, 44, 21, 29, 6, 150, 194, 117, 118, 237, 0,
223, 207, 161, 58, 229, 174, 101, 101, 195, 17, 249, 12, 137, 177, 161
};
const uint32_t UtilsTest::data_len = 500;
TEST_F(UtilsTest, IpToInt) {
EXPECT_EQ(Utils::ip_to_int("0.0.0.0"), zero_int_ip);
EXPECT_EQ(Utils::ip_to_int("255.255.255.255"), full_int_ip);
EXPECT_EQ(Utils::ip_to_int("1.2.255.3"), mix_int_ip);
/* Invalid number */
EXPECT_THROW(Utils::ip_to_int("123.a.5.6"), std::runtime_error);
EXPECT_THROW(Utils::ip_to_int("0.0.256.0"), std::runtime_error);
EXPECT_THROW(Utils::ip_to_int("0.0.255.0a"), std::runtime_error);
EXPECT_THROW(Utils::ip_to_int("0.0.255.127a"), std::runtime_error);
EXPECT_THROW(Utils::ip_to_int("0.0.255.1.5"), std::runtime_error);
}
TEST_F(UtilsTest, IpToString) {
EXPECT_EQ(Utils::ip_to_string(zero_int_ip), "0.0.0.0");
EXPECT_EQ(Utils::ip_to_string(full_int_ip), "255.255.255.255");
EXPECT_EQ(Utils::ip_to_string(mix_int_ip), "1.2.255.3");
}
TEST_F(UtilsTest, HwaddrToByte) {
uint8_t result_buf[6];
Utils::hwaddr_to_byte("00:00:00:00:00:00", result_buf);
EXPECT_TRUE(memcmp(result_buf, zero_hw_addr, 6) == 0);
Utils::hwaddr_to_byte("ff:ff:ff:ff:ff:ff", result_buf);
EXPECT_TRUE(memcmp(result_buf, full_hw_addr, 6) == 0);
Utils::hwaddr_to_byte("01:02:03:04:05:06", result_buf);
EXPECT_TRUE(memcmp(result_buf, mix_hw_addr, 6) == 0);
}
TEST_F(UtilsTest, HwaddrToString) {
EXPECT_EQ(Utils::hwaddr_to_string(zero_hw_addr), "00:00:00:00:00:00");
EXPECT_EQ(Utils::hwaddr_to_string(full_hw_addr), "ff:ff:ff:ff:ff:ff");
EXPECT_EQ(Utils::hwaddr_to_string(mix_hw_addr), "01:02:03:04:05:06");
}
TEST_F(UtilsTest, ResolveIp) {
uint32_t localhost_ip = Utils::ip_to_int("127.0.0.1");
EXPECT_EQ(Utils::resolve_ip("localhost"), localhost_ip);
EXPECT_THROW(Utils::resolve_ip("www.qwertyuiopasdfg.com.ar.edu.gov"), std::runtime_error);
}
TEST_F(UtilsTest, InterfaceIp) {
uint32_t ip;
uint32_t localhost_ip = Utils::ip_to_int("127.0.0.1");
#ifndef WIN32
ASSERT_TRUE(Utils::interface_ip("lo", ip));
EXPECT_EQ(ip, localhost_ip);
#endif
EXPECT_FALSE(Utils::interface_ip("asdfghgfdsa", ip));
}
TEST_F(UtilsTest, NetToHostS) {
uint16_t a = 0x01FE;
uint16_t b = Utils::net_to_host_s(a);
EXPECT_EQ(b, 0xFE01);
EXPECT_EQ(a, Utils::net_to_host_s(b));
}
TEST_F(UtilsTest, NetToHostL) {
uint32_t a = 0x0102CDFE;
uint32_t b = Utils::net_to_host_l(a);
EXPECT_EQ(b, 0xFECD0201);
EXPECT_EQ(a, Utils::net_to_host_l(b));
}
TEST_F(UtilsTest, NetToHostLL) {
uint64_t a = 0x0102030489ABCDFE;
uint64_t b = Utils::net_to_host_ll(a);
EXPECT_EQ(b, 0xFECDAB8904030201);
EXPECT_EQ(a, Utils::net_to_host_ll(b));
}
TEST_F(UtilsTest, Crc32) {
uint32_t crc = Utils::crc32(data, data_len);
EXPECT_EQ(crc, 0x78840f54);
}
TEST_F(UtilsTest, Checksum) {
uint16_t checksum = Utils::do_checksum(data, data + data_len);
//EXPECT_EQ(checksum, 0x231a);
uint8_t my_data[] = {0, 0, 0, 0};
checksum = Utils::do_checksum(my_data, my_data + 4);
EXPECT_EQ(checksum, 0xFFFF);
}