3rd-party/libtins
1
0
Fork 0
mirror of https://github.com/mfontanini/libtins synced 2026-01-26 12:01:34 +01:00
Code Issues Releases Wiki Activity

Code cleanup and use same syntax on the entire project

Browse Source 
Initial code cleanup

More code cleanup

Cleanup more code

Cleanup Dot11 code

Fix OSX build issue

Cleanup examples

Fix ref and pointer declaration syntax

Fix braces
This commit is contained in:
Matias Fontanini
2016-01-02 08:17:59 -08:00
parent f5a82b1a17
commit d84f10cf08
177 changed files with 13203 additions and 12272 deletions
Download Patch File Download Diff File Expand all files Collapse all files

95
src/ip_reassembler.cpp
View File

@@ -33,82 +33,86 @@
#include "internals.h"
#include "ip_reassembler.h"
using std::make_pair;
namespace Tins {
namespace Internals {
IPv4Stream::IPv4Stream()
: received_end(false), received_size(), total_size()
{
: received_end_(false), received_size_(), total_size_() {
}
void IPv4Stream::add_fragment(IP *ip) {
fragments_type::iterator it = fragments.begin();
void IPv4Stream::add_fragment(IP* ip) {
fragments_type::iterator it = fragments_.begin();
uint16_t offset = extract_offset(ip);
while(it != fragments.end() && offset > it->offset()) {
while (it != fragments_.end() && offset > it->offset()) {
++it;
}
// No duplicates plx
if(it != fragments.end() && it->offset() == offset)
if (it != fragments_.end() && it->offset() == offset) {
return;
fragments.insert(it, IPv4Fragment(ip->inner_pdu(), offset));
received_size += ip->inner_pdu()->size();
if(ip->flags() != IP::MORE_FRAGMENTS) {
total_size = offset + ip->inner_pdu()->size();
received_end = true;
}
if(offset == 0)
transport_proto = ip->protocol();
fragments_.insert(it, IPv4Fragment(ip->inner_pdu(), offset));
received_size_ += ip->inner_pdu()->size();
if (ip->flags() != IP::MORE_FRAGMENTS) {
total_size_ = offset + ip->inner_pdu()->size();
received_end_ = true;
}
if (offset == 0) {
transport_proto_ = ip->protocol();
}
}
bool IPv4Stream::is_complete() const {
return received_end && received_size == total_size;
return received_end_ && received_size_ == total_size_;
}
PDU *IPv4Stream::allocate_pdu() const {
PDU* IPv4Stream::allocate_pdu() const {
PDU::serialization_type buffer;
buffer.reserve(total_size);
buffer.reserve(total_size_);
// Check if we actually have all the data we need. Otherwise return nullptr;
uint16_t expected = 0;
for(fragments_type::const_iterator it = fragments.begin(); it != fragments.end(); ++it) {
if(expected != it->offset())
for (fragments_type::const_iterator it = fragments_.begin(); it != fragments_.end(); ++it) {
if (expected != it->offset()) {
return 0;
}
expected = static_cast<uint16_t>(it->offset() + it->payload().size());
buffer.insert(buffer.end(), it->payload().begin(), it->payload().end());
}
return Internals::pdu_from_flag(
static_cast<Constants::IP::e>(transport_proto),
buffer.empty() ? 0 : &buffer[0],
static_cast<Constants::IP::e>(transport_proto_),
buffer.empty() ? 0 :& buffer[0],
static_cast<uint32_t>(buffer.size())
);
}
uint16_t IPv4Stream::extract_offset(const IP *ip) {
uint16_t IPv4Stream::extract_offset(const IP* ip) {
return ip->fragment_offset() * 8;
}
} // namespace Internals
} // Internals
IPv4Reassembler::IPv4Reassembler(overlapping_technique technique)
: technique(technique)
{
: technique_(technique) {
}
IPv4Reassembler::packet_status IPv4Reassembler::process(PDU &pdu) {
IP *ip = pdu.find_pdu<IP>();
if(ip && ip->inner_pdu()) {
IPv4Reassembler::packet_status IPv4Reassembler::process(PDU& pdu) {
IP* ip = pdu.find_pdu<IP>();
if (ip && ip->inner_pdu()) {
// There's fragmentation
if(ip->is_fragmented()) {
if (ip->is_fragmented()) {
key_type key = make_key(ip);
// Create it or look it up, it's the same
Internals::IPv4Stream &stream = streams[key];
Internals::IPv4Stream& stream = streams_[key];
stream.add_fragment(ip);
if(stream.is_complete()) {
PDU *pdu = stream.allocate_pdu();
if (stream.is_complete()) {
PDU* pdu = stream.allocate_pdu();
// Erase this stream, since it's already assembled
streams.erase(key);
streams_.erase(key);
// The packet is corrupt
if(!pdu) {
if (!pdu) {
return FRAGMENTED;
}
ip->inner_pdu(pdu);
@@ -116,38 +120,41 @@ IPv4Reassembler::packet_status IPv4Reassembler::process(PDU &pdu) {
ip->flags(static_cast<IP::Flags>(0));
return REASSEMBLED;
}
else
else {
return FRAGMENTED;
}
}
}
return NOT_FRAGMENTED;
}
IPv4Reassembler::key_type IPv4Reassembler::make_key(const IP *ip) const {
return std::make_pair(
IPv4Reassembler::key_type IPv4Reassembler::make_key(const IP* ip) const {
return make_pair(
ip->id(),
make_address_pair(ip->src_addr(), ip->dst_addr())
);
}
IPv4Reassembler::address_pair IPv4Reassembler::make_address_pair(IPv4Address addr1, IPv4Address addr2) const {
if(addr1 < addr2)
return std::make_pair(addr1, addr2);
else
return std::make_pair(addr2, addr1);
if (addr1 < addr2) {
return make_pair(addr1, addr2);
}
else {
return make_pair(addr2, addr1);
}
}
void IPv4Reassembler::clear_streams() {
streams.clear();
streams_.clear();
}
void IPv4Reassembler::remove_stream(uint16_t id, IPv4Address addr1, IPv4Address addr2) {
streams.erase(
std::make_pair(
streams_.erase(
make_pair(
id,
make_address_pair(addr1, addr2)
)
);
}
} // namespace Tins
} // Tins