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

Rename IP header member to header_

Browse Source
This commit is contained in:
Matias Fontanini
2016-02-04 20:37:24 -08:00
parent 602ead5de5
commit 5d41316b9a
2 changed files with 48 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
include/tins/ip.h
View File

@@ -280,7 +280,7 @@ public:
* \return The number of dwords the header occupies in an uin8_t.
*/
small_uint<4> head_len() const {
return this->ip_.ihl;
return this->header_.ihl;
}
/**
@@ -289,7 +289,7 @@ public:
* \return The this IP PDU's type of service.
*/
uint8_t tos() const {
return ip_.tos;
return header_.tos;
}
/**
@@ -298,7 +298,7 @@ public:
* \return The total length of this IP PDU.
*/
uint16_t tot_len() const {
return Endian::be_to_host(ip_.tot_len);
return Endian::be_to_host(header_.tot_len);
}
/**
@@ -307,7 +307,7 @@ public:
* \return The id for this IP PDU.
*/
uint16_t id() const {
return Endian::be_to_host(ip_.id);
return Endian::be_to_host(header_.id);
}
/**
@@ -321,7 +321,7 @@ public:
* \sa IP::flags
*/
TINS_DEPRECATED(uint16_t frag_off() const) {
return Endian::be_to_host(ip_.frag_off);
return Endian::be_to_host(header_.frag_off);
}
/**
@@ -333,7 +333,7 @@ public:
* \return The fragment offset, measured in units of 8 byte blocks
*/
small_uint<13> fragment_offset() const {
return Endian::be_to_host(ip_.frag_off) & 0x1fff;
return Endian::be_to_host(header_.frag_off) & 0x1fff;
}
/**
@@ -342,7 +342,7 @@ public:
* \return The IP flags field
*/
Flags flags() const {
return static_cast<Flags>(Endian::be_to_host(ip_.frag_off) >> 13);
return static_cast<Flags>(Endian::be_to_host(header_.frag_off) >> 13);
}
/**
@@ -351,7 +351,7 @@ public:
* \return The time to live for this IP PDU.
*/
uint8_t ttl() const {
return ip_.ttl;
return header_.ttl;
}
/**
@@ -360,7 +360,7 @@ public:
* \return The protocol for this IP PDU.
*/
uint8_t protocol() const {
return ip_.protocol;
return header_.protocol;
}
/**
@@ -369,7 +369,7 @@ public:
* \return The checksum for this IP PDU.
*/
uint16_t checksum() const {
return Endian::be_to_host(ip_.check);
return Endian::be_to_host(header_.check);
}
/**
@@ -378,7 +378,7 @@ public:
* \return The source address for this IP PDU.
*/
address_type src_addr() const {
return address_type(ip_.saddr);
return address_type(header_.saddr);
}
/**
@@ -386,7 +386,7 @@ public:
* \return The destination address for this IP PDU.
*/
address_type dst_addr() const {
return address_type(ip_.daddr);
return address_type(header_.daddr);
}
/**
@@ -394,7 +394,7 @@ public:
* \return The version for this IP PDU.
*/
small_uint<4> version() const {
return ip_.version;
return header_.version;
}
/**
@@ -760,7 +760,7 @@ private:
options_type::iterator search_option_iterator(option_identifier id);
void update_padded_options_size();
ip_header ip_;
ip_header header_;
uint16_t options_size_, padded_options_size_;
options_type ip_options_;
};

68
src/ip.cpp
View File

@@ -68,11 +68,11 @@ IP::IP(address_type ip_dst, address_type ip_src) {
IP::IP(const uint8_t* buffer, uint32_t total_sz)
: options_size_(0) {
InputMemoryStream stream(buffer, total_sz);
stream.read(ip_);
stream.read(header_);
// Make sure we have enough size for options and not less than we should
if (head_len() * sizeof(uint32_t) > total_sz ||
head_len() * sizeof(uint32_t) < sizeof(ip_)) {
head_len() * sizeof(uint32_t) < sizeof(header_)) {
throw malformed_packet();
}
const uint8_t* options_end = buffer + head_len() * sizeof(uint32_t);
@@ -131,7 +131,7 @@ IP::IP(const uint8_t* buffer, uint32_t total_sz)
if (!is_fragmented()) {
inner_pdu(
Internals::pdu_from_flag(
static_cast<Constants::IP::e>(ip_.protocol),
static_cast<Constants::IP::e>(header_.protocol),
stream.pointer(),
total_sz,
false
@@ -140,7 +140,7 @@ IP::IP(const uint8_t* buffer, uint32_t total_sz)
if (!inner_pdu()) {
inner_pdu(
Internals::allocate<IP>(
ip_.protocol,
header_.protocol,
stream.pointer(),
total_sz
)
@@ -158,8 +158,8 @@ IP::IP(const uint8_t* buffer, uint32_t total_sz)
}
void IP::init_ip_fields() {
memset(&ip_, 0, sizeof(ip_));
ip_.version = 4;
memset(&header_, 0, sizeof(header_));
header_.version = 4;
ttl(DEFAULT_TTL);
id(1);
options_size_ = 0;
@@ -173,57 +173,57 @@ bool IP::is_fragmented() const {
// Setters
void IP::tos(uint8_t new_tos) {
ip_.tos = new_tos;
header_.tos = new_tos;
}
void IP::tot_len(uint16_t new_tot_len) {
ip_.tot_len = Endian::host_to_be(new_tot_len);
header_.tot_len = Endian::host_to_be(new_tot_len);
}
void IP::id(uint16_t new_id) {
ip_.id = Endian::host_to_be(new_id);
header_.id = Endian::host_to_be(new_id);
}
void IP::frag_off(uint16_t new_frag_off) {
ip_.frag_off = Endian::host_to_be(new_frag_off);
header_.frag_off = Endian::host_to_be(new_frag_off);
}
void IP::fragment_offset(small_uint<13> new_frag_off) {
uint16_t value = (Endian::be_to_host(ip_.frag_off) & 0xe000) | new_frag_off;
ip_.frag_off = Endian::host_to_be(value);
uint16_t value = (Endian::be_to_host(header_.frag_off) & 0xe000) | new_frag_off;
header_.frag_off = Endian::host_to_be(value);
}
void IP::flags(Flags new_flags) {
uint16_t value = (Endian::be_to_host(ip_.frag_off) & 0x1fff) | (new_flags << 13);
ip_.frag_off = Endian::host_to_be(value);
uint16_t value = (Endian::be_to_host(header_.frag_off) & 0x1fff) | (new_flags << 13);
header_.frag_off = Endian::host_to_be(value);
}
void IP::ttl(uint8_t new_ttl) {
ip_.ttl = new_ttl;
header_.ttl = new_ttl;
}
void IP::protocol(uint8_t new_protocol) {
ip_.protocol = new_protocol;
header_.protocol = new_protocol;
}
void IP::checksum(uint16_t new_check) {
ip_.check = Endian::host_to_be(new_check);
header_.check = Endian::host_to_be(new_check);
}
void IP::src_addr(address_type ip) {
ip_.saddr = ip;
header_.saddr = ip;
}
void IP::dst_addr(address_type ip) {
ip_.daddr = ip;
header_.daddr = ip;
}
void IP::head_len(small_uint<4> new_head_len) {
ip_.ihl = new_head_len;
header_.ihl = new_head_len;
}
void IP::version(small_uint<4> ver) {
ip_.version = ver;
header_.version = ver;
}
void IP::eol() {
@@ -368,7 +368,7 @@ void IP::write_option(const option& opt, OutputMemoryStream& stream) {
// Virtual method overriding
uint32_t IP::header_size() const {
return sizeof(ip_) + padded_options_size_;
return sizeof(header_) + padded_options_size_;
}
PacketSender::SocketType pdu_type_to_sender_type(PDU::PDUType type) {
@@ -389,7 +389,7 @@ void IP::send(PacketSender& sender, const NetworkInterface &) {
PacketSender::SocketType type = PacketSender::IP_RAW_SOCKET;
link_addr.sin_family = AF_INET;
link_addr.sin_port = 0;
link_addr.sin_addr.s_addr = ip_.daddr;
link_addr.sin_addr.s_addr = header_.daddr;
if (inner_pdu()) {
type = pdu_type_to_sender_type(inner_pdu()->pdu_type());
}
@@ -409,7 +409,7 @@ PDU* IP::recv_response(PacketSender& sender, const NetworkInterface &) {
}
void IP::prepare_for_serialize(const PDU* parent) {
if (!parent && ip_.saddr == 0) {
if (!parent && header_.saddr == 0) {
NetworkInterface iface(dst_addr());
src_addr(iface.addresses().ip_addr);
}
@@ -430,21 +430,21 @@ void IP::write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* pare
}
}
uint16_t original_frag_off = ip_.frag_off;
uint16_t original_frag_off = header_.frag_off;
#if __FreeBSD__ || defined(__FreeBSD_kernel__) || __APPLE__
if (!parent) {
total_sz = Endian::host_to_be<uint16_t>(total_sz);
ip_.frag_off = Endian::be_to_host(ip_.frag_off);
header_.frag_off = Endian::be_to_host(header_.frag_off);
}
#endif
tot_len(total_sz);
head_len(static_cast<uint8_t>(header_size() / sizeof(uint32_t)));
stream.write(ip_);
stream.write(header_);
// Restore the fragment offset field in case we flipped it
ip_.frag_off = original_frag_off;
header_.frag_off = original_frag_off;
for (options_type::const_iterator it = ip_options_.begin(); it != ip_options_.end(); ++it) {
write_option(*it, stream);
@@ -457,11 +457,11 @@ void IP::write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* pare
check = (check & 0xffff) + (check >> 16);
}
checksum(~check);
((ip_header*)buffer)->check = ip_.check;
((ip_header*)buffer)->check = header_.check;
}
bool IP::matches_response(const uint8_t* ptr, uint32_t total_sz) const {
if (total_sz < sizeof(ip_)) {
if (total_sz < sizeof(header_)) {
return false;
}
const ip_header* ip_ptr = (const ip_header*)ptr;
@@ -475,15 +475,15 @@ bool IP::matches_response(const uint8_t* ptr, uint32_t total_sz) const {
pkt_sz -= 4;
// If our IP header is in the ICMP payload, then it's the same packet.
// This keeps in mind checksum and IP identifier, so I guess it's enough.
if (pkt_sz >= sizeof(ip_) && memcmp(&ip_, pkt_ptr, sizeof(ip_header))) {
if (pkt_sz >= sizeof(header_) && memcmp(&header_, pkt_ptr, sizeof(ip_header))) {
return true;
}
}
}
// checks for broadcast addr
if ((ip_.saddr == ip_ptr->daddr &&
(ip_.daddr == ip_ptr->saddr || dst_addr().is_broadcast())) ||
(dst_addr().is_broadcast() && ip_.saddr == 0)) {
if ((header_.saddr == ip_ptr->daddr &&
(header_.daddr == ip_ptr->saddr || dst_addr().is_broadcast())) ||
(dst_addr().is_broadcast() && header_.saddr == 0)) {
uint32_t sz = min<uint32_t>(header_size(), total_sz);
return inner_pdu() ? inner_pdu()->matches_response(ptr + sz, total_sz - sz) : true;
}