diff --git a/examples/arpmonitor.cpp b/examples/arpmonitor.cpp
index 16655ff..6caa2df 100644
--- a/examples/arpmonitor.cpp
+++ b/examples/arpmonitor.cpp
@@ -32,21 +32,25 @@
 #include <iostream>
 #include <functional>
 
+using std::cout;
+using std::endl;
+using std::map;
+using std::bind;
+
 using namespace Tins;
 
 class arp_monitor {
 public:
-    void run(Sniffer &sniffer);
+    void run(Sniffer& sniffer);
 private:
-    bool callback(const PDU &pdu);
+    bool callback(const PDU& pdu);
 
-    std::map<IPv4Address, HWAddress<6>> addresses;
+    map<IPv4Address, HWAddress<6>> addresses;
 };
 
-void arp_monitor::run(Sniffer &sniffer)
-{
+void arp_monitor::run(Sniffer& sniffer) {
     sniffer.sniff_loop(
-        std::bind(
+        bind(
             &arp_monitor::callback,
             this,
             std::placeholders::_1
@@ -54,36 +58,34 @@ void arp_monitor::run(Sniffer &sniffer)
     );
 }
 
-bool arp_monitor::callback(const PDU &pdu)
-{
+bool arp_monitor::callback(const PDU& pdu) {
     // Retrieve the ARP layer
-    const ARP &arp = pdu.rfind_pdu<ARP>();
+    const ARP& arp = pdu.rfind_pdu<ARP>();
     // Is it an ARP reply?
-    if(arp.opcode() == ARP::REPLY) {
+    if (arp.opcode() == ARP::REPLY) {
         // Let's check if there's already an entry for this address
         auto iter = addresses.find(arp.sender_ip_addr());
-        if(iter == addresses.end()) {
+        if (iter == addresses.end()) {
             // We haven't seen this address. Save it.
             addresses.insert({ arp.sender_ip_addr(), arp.sender_hw_addr()});
-            std::cout << "[INFO] " << arp.sender_ip_addr() << " is at "
-                      << arp.sender_hw_addr() << std::endl;
+            cout << "[INFO] " << arp.sender_ip_addr() << " is at "
+                 << arp.sender_hw_addr() << std::endl;
         }
         else {
             // We've seen this address. If it's not the same HW address, inform it
-            if(arp.sender_hw_addr() != iter->second) {
-                std::cout << "[WARNING] " << arp.sender_ip_addr() << " is at " 
-                          << iter->second << " but also at " << arp.sender_hw_addr() 
-                          << std::endl;
+            if (arp.sender_hw_addr() != iter->second) {
+                cout << "[WARNING] " << arp.sender_ip_addr() << " is at " 
+                     << iter->second << " but also at " << arp.sender_hw_addr() 
+                     << endl;
             }
         }
     }
     return true;
 }
 
-int main(int argc, char *argv[]) 
-{
+int main(int argc, char* argv[]) {
     if(argc != 2) {
-        std::cout << "Usage: " << *argv << " <interface>\n";
+        cout << "Usage: " <<* argv << " <interface>" << endl;
         return 1;
     }
     arp_monitor monitor;
diff --git a/examples/arpspoofing.cpp b/examples/arpspoofing.cpp
index 879fcf1..543ca54 100644
--- a/examples/arpspoofing.cpp
+++ b/examples/arpspoofing.cpp
@@ -44,13 +44,17 @@
 #include <tins/ethernetII.h>
 #include <tins/packet_sender.h>
 
-using namespace std;
+using std::cout;
+using std::runtime_error;
+using std::endl;
+
 using namespace Tins;
 
 
-void do_arp_spoofing(NetworkInterface iface, IPv4Address gw, IPv4Address victim, 
-  const NetworkInterface::Info &info) 
-{
+void do_arp_spoofing(NetworkInterface iface, 
+                     IPv4Address gw,
+                     IPv4Address victim, 
+                     const NetworkInterface::Info& info) {
     PacketSender sender;
     EthernetII::address_type gw_hw, victim_hw;
     
@@ -79,7 +83,7 @@ void do_arp_spoofing(NetworkInterface iface, IPv4Address gw, IPv4Address victim,
      * performed by any routers. */
     EthernetII to_gw = EthernetII(gw_hw, info.hw_addr) / gw_arp;
     EthernetII to_victim = EthernetII(victim_hw, info.hw_addr) / victim_arp;
-    while(true) {
+    while (true) {
         // Just send them once every 5 seconds.
         sender.send(to_gw, iface);
         sender.send(to_victim, iface);
@@ -91,9 +95,11 @@ void do_arp_spoofing(NetworkInterface iface, IPv4Address gw, IPv4Address victim,
     }
 }
 
-int main(int argc, char *argv[]) {
-    if(argc != 3 && cout << "Usage: " << *argv << " <Gateway> <Victim>\n")
+int main(int argc, char* argv[]) {
+    if (argc != 3) {
+        cout << "Usage: " <<* argv << " <Gateway> <Victim>" << endl;
         return 1;
+    }
     IPv4Address gw, victim;
     EthernetII::address_type own_hw;
     try {
@@ -101,7 +107,7 @@ int main(int argc, char *argv[]) {
         gw     = argv[1];
         victim = argv[2];
     }
-    catch(...) {
+    catch (...) {
         cout << "Invalid ip found...\n";
         return 2;
     }
@@ -115,15 +121,15 @@ int main(int argc, char *argv[]) {
         // Find the interface hardware and ip address.
         info = iface.addresses();
     }
-    catch(std::runtime_error &ex) {
+    catch (runtime_error& ex) {
         cout << ex.what() << endl;
         return 3;
     }
     try {
         do_arp_spoofing(iface, gw, victim, info);
     }
-    catch(std::runtime_error &ex) {
-        std::cout << "Runtime error: " << ex.what() << std::endl;
+    catch (runtime_error& ex) {
+        cout << "Runtime error: " << ex.what() << endl;
         return 7;
     }
 }
diff --git a/examples/beacon_display.cpp b/examples/beacon_display.cpp
index 042d7a0..eb99a30 100644
--- a/examples/beacon_display.cpp
+++ b/examples/beacon_display.cpp
@@ -32,21 +32,27 @@
 #include <string>
 #include <tins/tins.h>
  
+using std::set;
+using std::cout;
+using std::endl;
+using std::string;
+using std::runtime_error;
+
 using namespace Tins;
  
 class BeaconSniffer {
 public:
-    void run(const std::string &iface);
+    void run(const string& iface);
 private:
     typedef Dot11::address_type address_type;
-    typedef std::set<address_type> ssids_type;
+    typedef set<address_type> ssids_type;
  
-    bool callback(PDU &pdu);
+    bool callback(PDU& pdu);
      
     ssids_type ssids;
 };
  
-void BeaconSniffer::run(const std::string &iface) {
+void BeaconSniffer::run(const std::string& iface) {
     SnifferConfiguration config;
     config.set_promisc_mode(true);
     config.set_filter("type mgt subtype beacon");
@@ -55,28 +61,28 @@ void BeaconSniffer::run(const std::string &iface) {
     sniffer.sniff_loop(make_sniffer_handler(this, &BeaconSniffer::callback));
 }
  
-bool BeaconSniffer::callback(PDU &pdu) {
+bool BeaconSniffer::callback(PDU& pdu) {
     // Get the Dot11 layer
-    const Dot11Beacon &beacon = pdu.rfind_pdu<Dot11Beacon>();
+    const Dot11Beacon& beacon = pdu.rfind_pdu<Dot11Beacon>();
     // All beacons must have from_ds == to_ds == 0
-    if(!beacon.from_ds() && !beacon.to_ds()) {
+    if (!beacon.from_ds() && !beacon.to_ds()) {
         // Get the AP address
         address_type addr = beacon.addr2();
         // Look it up in our set
         ssids_type::iterator it = ssids.find(addr);
-        if(it == ssids.end()) {
+        if (it == ssids.end()) {
             // First time we encounter this BSSID.
             try {
                 /* If no ssid option is set, then Dot11::ssid will throw 
                  * a std::runtime_error.
                  */
-                std::string ssid = beacon.ssid();
+                string ssid = beacon.ssid();
                 // Save it so we don't show it again.
                 ssids.insert(addr);
                 // Display the tuple "address - ssid".
-                std::cout << addr << " - " << ssid << std::endl;
+                cout << addr << " - " << ssid << endl;
             }
-            catch(std::runtime_error&) {
+            catch (runtime_error&) {
                 // No ssid, just ignore it.
             }
         }
@@ -85,10 +91,11 @@ bool BeaconSniffer::callback(PDU &pdu) {
 }
  
 int main(int argc, char* argv[]) {
-    // By default, sniff wlan0
-    std::string interface = "wlan0";
-    if(argc == 2)
-        interface = argv[1];
+    if (argc != 2) {
+        cout << "Usage: " <<* argv << " <interface>" << endl;
+        return 1;
+    }
+    string interface = argv[1];
     BeaconSniffer sniffer;
     sniffer.run(interface);
 }
diff --git a/examples/dns_queries.cpp b/examples/dns_queries.cpp
index 05d9412..f3d914f 100644
--- a/examples/dns_queries.cpp
+++ b/examples/dns_queries.cpp
@@ -30,10 +30,12 @@
 #include <tins/tins.h>
 #include <iostream>
 
+using std::cout;
+using std::endl;
+
 using namespace Tins;
 
-bool callback(const PDU &pdu) 
-{
+bool callback(const PDU& pdu) {
     // The packet probably looks like this:
     //
     // EthernetII / IP / UDP / RawPDU
@@ -43,15 +45,15 @@ bool callback(const PDU &pdu)
     DNS dns = pdu.rfind_pdu<RawPDU>().to<DNS>();
     
     // Retrieve the queries and print the domain name:
-    for(const auto &query : dns.queries()) 
-        std::cout << query.dname() << std::endl;
+    for (const auto& query : dns.queries()) {
+        cout << query.dname() << std::endl;
+    }
     return true;
 }
 
-int main(int argc, char *argv[]) 
-{
+int main(int argc, char* argv[]) {
     if(argc != 2) {
-        std::cout << "Usage: " << *argv << " <interface>" << std::endl;
+        cout << "Usage: " <<* argv << " <interface>" << endl;
         return 1;
     }
     // Sniff on the provided interface in promiscuos mode
diff --git a/examples/dns_spoof.cpp b/examples/dns_spoof.cpp
index ace62af..0ea4fa4 100644
--- a/examples/dns_spoof.cpp
+++ b/examples/dns_spoof.cpp
@@ -30,11 +30,14 @@
 #include <tins/tins.h>
 #include <iostream>
 
+using std::cout;
+using std::endl;
+
 using namespace Tins;
 
 PacketSender sender;
 
-bool callback(const PDU &pdu) 
+bool callback(const PDU& pdu) 
 {
     // The packet probably looks like this:
     //
@@ -48,10 +51,10 @@ bool callback(const PDU &pdu)
     DNS dns = udp.rfind_pdu<RawPDU>().to<DNS>();
 
     // Is it a DNS query?
-    if(dns.type() == DNS::QUERY) {
+    if (dns.type() == DNS::QUERY) {
         // Let's see if there's any query for an "A" record.
-        for(const auto &query : dns.queries()) {
-            if(query.type() == DNS::A) {
+        for (const auto& query : dns.queries()) {
+            if (query.type() == DNS::A) {
                 // Here's one! Let's add an answer.
                 dns.add_answer(
                     DNS::Resource(
@@ -66,16 +69,16 @@ bool callback(const PDU &pdu)
             }
         }
         // Have we added some answers?
-        if(dns.answers_count() > 0) {
+        if (dns.answers_count() > 0) {
             // It's a response now
             dns.type(DNS::RESPONSE);
             // Recursion is available(just in case)
             dns.recursion_available(1);
             // Build our packet
             auto pkt = EthernetII(eth.src_addr(), eth.dst_addr()) /
-                        IP(ip.src_addr(), ip.dst_addr()) /
-                        UDP(udp.sport(), udp.dport()) /
-                        dns;
+                       IP(ip.src_addr(), ip.dst_addr()) /
+                       UDP(udp.sport(), udp.dport()) /
+                       dns;
             // Send it!
             sender.send(pkt);
         }
@@ -83,10 +86,9 @@ bool callback(const PDU &pdu)
     return true;
 }
 
-int main(int argc, char *argv[]) 
-{
+int main(int argc, char* argv[]) {
     if(argc != 2) {
-        std::cout << "Usage: " << *argv << " <interface>" << std::endl;
+        cout << "Usage: " <<* argv << " <interface>" << endl;
         return 1;
     }
     // Sniff on the provided interface in promiscuos mode
diff --git a/examples/dns_stats.cpp b/examples/dns_stats.cpp
index c467d4f..0d4bda5 100644
--- a/examples/dns_stats.cpp
+++ b/examples/dns_stats.cpp
@@ -39,6 +39,25 @@
 #include <algorithm>
 #include <tins/tins.h>
 
+using std::cout;
+using std::endl;
+using std::thread;
+using std::string;
+using std::bind;
+using std::map;
+using std::mutex;
+using std::max;
+using std::min;
+using std::exception;
+using std::lock_guard;
+using std::tuple;
+using std::make_tuple;
+using std::this_thread::sleep_for;
+using std::chrono::seconds;
+using std::chrono::milliseconds;
+using std::chrono::duration_cast;
+using std::chrono::system_clock;
+
 using namespace Tins;
 
 // Holds the DNS response time statistics. The response time is 
@@ -47,7 +66,7 @@ template<typename Duration>
 class statistics {
 public:
     using duration_type = Duration;
-    using locker_type = std::lock_guard<std::mutex>;
+    using locker_type = lock_guard<mutex>;
     
     struct information {
         duration_type average, worst;
@@ -55,42 +74,41 @@ public:
     };
     
     statistics()
-    : m_duration(), m_worst(duration_type::min()), m_count()
-    {
+    : m_duration(), m_worst(duration_type::min()), m_count() {
         
     }
     
-    void add_response_time(const duration_type& duration)
-    {
+    void add_response_time(const duration_type& duration) {
         locker_type _(m_lock);
         m_duration += duration;
         m_count++;
-        m_worst = std::max(m_worst, duration);
+        m_worst = max(m_worst, duration);
     }
     
-    information get_information() const 
-    {
+    information get_information() const {
         locker_type _(m_lock);
-        if(m_count == 0)
+        if(m_count == 0) {
             return { };
-        else 
+        }
+        else {
             return { m_duration / m_count, m_worst, m_count };
+        }
     };
 private:
     duration_type m_duration, m_worst;
     size_t m_count;
-    mutable std::mutex m_lock;
+    mutable mutex m_lock;
 };
 
 // Sniffs and tracks DNS queries. When a matching DNS response is found,
 // the response time is added to a statistics object.
 //
-// This class performs *no cleanup* on data associated with queries that
+// This class performs* no cleanup* on data associated with queries that
 // weren't answered.
 class dns_monitor {
 public:
     // The response times are measured in milliseconds
-    using duration_type = std::chrono::milliseconds;
+    using duration_type = milliseconds;
     // The statistics type used.
     using statistics_type = statistics<duration_type>;
     
@@ -99,21 +117,21 @@ public:
         return m_stats;
     }
 private:
-    using packet_info = std::tuple<IPv4Address, IPv4Address, uint16_t>;
-    using clock_type = std::chrono::system_clock;
+    using packet_info = tuple<IPv4Address, IPv4Address, uint16_t>;
+    using clock_type = system_clock;
     using time_point_type = clock_type::time_point;
 
     bool callback(const PDU& pdu);
     static packet_info make_packet_info(const PDU& pdu, const DNS& dns);
     
     statistics_type m_stats;    
-    std::map<packet_info, time_point_type> m_packet_info;
+    map<packet_info, time_point_type> m_packet_info;
 };
 
 void dns_monitor::run(BaseSniffer& sniffer)
 {
     sniffer.sniff_loop(
-        std::bind(
+        bind(
             &dns_monitor::callback, 
             this, 
             std::placeholders::_1
@@ -127,7 +145,7 @@ bool dns_monitor::callback(const PDU& pdu)
     auto dns = pdu.rfind_pdu<RawPDU>().to<DNS>();
     auto info = make_packet_info(pdu, dns);
     // If it's a query, add the sniff time to our map.
-    if(dns.type() == DNS::QUERY) {
+    if (dns.type() == DNS::QUERY) {
         m_packet_info.insert(
             std::make_pair(info, now)
         );
@@ -135,11 +153,11 @@ bool dns_monitor::callback(const PDU& pdu)
     else {
         // It's a response, we need to find the query in our map.
         auto iter = m_packet_info.find(info);
-        if(iter != m_packet_info.end()) {
+        if (iter != m_packet_info.end()) {
             // We found the query, let's add the response time to the
             // statistics object.
             m_stats.add_response_time(
-                std::chrono::duration_cast<duration_type>(now - iter->second)
+                duration_cast<duration_type>(now - iter->second)
             );
             // Forget about the query.
             m_packet_info.erase(iter);
@@ -155,17 +173,17 @@ bool dns_monitor::callback(const PDU& pdu)
 auto dns_monitor::make_packet_info(const PDU& pdu, const DNS& dns) -> packet_info
 {
     const auto& ip = pdu.rfind_pdu<IP>();
-    return std::make_tuple( 
+    return make_tuple( 
         // smallest address first
-        std::min(ip.src_addr(), ip.dst_addr()),
+        min(ip.src_addr(), ip.dst_addr()),
         // largest address second
-        std::max(ip.src_addr(), ip.dst_addr()),
+        max(ip.src_addr(), ip.dst_addr()),
         dns.id()
     );
 }
 
-int main(int argc, char *argv[]) {
-    std::string iface;
+int main(int argc, char* argv[]) {
+    string iface;
     if (argc == 2) {
         // Use the provided interface
         iface = argv[1];
@@ -180,21 +198,21 @@ int main(int argc, char *argv[]) {
         config.set_filter("udp and port 53");
         Sniffer sniffer(iface, config);
         dns_monitor monitor;
-        std::thread thread(
+        thread thread(
             [&]() {
                 monitor.run(sniffer);
             }
         );
-        while(true) {
+        while (true) {
             auto info = monitor.stats().get_information();
-            std::cout << "\rAverage " << info.average.count() 
-                        << "ms. Worst: " << info.worst.count() << "ms. Count: "
-                        << info.count;
-            std::cout.flush();
-            std::this_thread::sleep_for(std::chrono::seconds(1));
+            cout << "\rAverage " << info.average.count() 
+                << "ms. Worst: " << info.worst.count() << "ms. Count: "
+                << info.count;
+            cout.flush();
+            sleep_for(seconds(1));
         }
     }
-    catch(std::exception& ex) {
-        std::cout << "[-] Error: " << ex.what() << std::endl;
+    catch (exception& ex) {
+        cout << "[-] Error: " << ex.what() << endl;
     }
 }
diff --git a/examples/icmp_responses.cpp b/examples/icmp_responses.cpp
index 50ace8a..aa65a88 100644
--- a/examples/icmp_responses.cpp
+++ b/examples/icmp_responses.cpp
@@ -33,7 +33,13 @@
 #include <functional>
 #include <tins/tins.h>
 
-using namespace std;
+using std::cout;
+using std::endl;
+using std::bind;
+using std::string;
+using std::runtime_error;
+using std::exception;
+
 using namespace Tins;
 
 // This class captured packets on an interface, using the specified filter
@@ -42,93 +48,93 @@ using namespace Tins;
 // has swapped HW and IP addresses (dst as src, src as dst).
 class ICMPResponder {
 public:
-	// Use the given interface and ICMP type/code on responses
-	ICMPResponder(string iface, int type, int code) 
-	: m_iface(iface), m_sender(iface), m_type(type), m_code(code) {
+    // Use the given interface and ICMP type/code on responses
+    ICMPResponder(string iface, int type, int code) 
+    : m_iface(iface), m_sender(iface), m_type(type), m_code(code) {
 
-	}
+    }
 
-	// Run using the given filter
-	void run(const string& filter) {
-		// Initialize the configuration
-		SnifferConfiguration config;
-		// Use promiscuous mode
-		config.set_promisc_mode(true);
-		// Use this packet filter
-		config.set_filter(filter);
-		// Use immediate mode (we don't want to buffer packets, we want the mright away).
-		config.set_immediate_mode(true);
+    // Run using the given filter
+    void run(const string& filter) {
+        // Initialize the configuration
+        SnifferConfiguration config;
+        // Use promiscuous mode
+        config.set_promisc_mode(true);
+        // Use this packet filter
+        config.set_filter(filter);
+        // Use immediate mode (we don't want to buffer packets, we want the mright away).
+        config.set_immediate_mode(true);
 
-		// Now create the Sniffer
-		Sniffer sniffer(m_iface, config);
-		if (sniffer.link_type() != DLT_EN10MB) {
-			throw runtime_error("Ethernet interfaces only supported");
-		}
-		// Start the sniffing! For each packet, ICMPReponder::callback will be called
-		sniffer.sniff_loop(bind(&ICMPResponder::callback, this, placeholders::_1));
-	}
+        // Now create the Sniffer
+        Sniffer sniffer(m_iface, config);
+        if (sniffer.link_type() != DLT_EN10MB) {
+            throw runtime_error("Ethernet interfaces only supported");
+        }
+        // Start the sniffing! For each packet, ICMPReponder::callback will be called
+        sniffer.sniff_loop(bind(&ICMPResponder::callback, this, std::placeholders::_1));
+    }
 private:
-	// Extracts the payload to be used over the ICMP layer in the response.
-	// This will be the entire IP header + 8 bytes of the next header.
-	RawPDU extract_icmp_payload(IP& pdu) {
-		PDU::serialization_type buffer = pdu.serialize();
-		// Use whole IP + 8 bytes of next header.
-		size_t end_index = pdu.header_size() + 8;
-		return RawPDU(buffer.begin(), buffer.begin() + end_index);
-	}
+    // Extracts the payload to be used over the ICMP layer in the response.
+    // This will be the entire IP header + 8 bytes of the next header.
+    RawPDU extract_icmp_payload(IP& pdu) {
+        PDU::serialization_type buffer = pdu.serialize();
+        // Use whole IP + 8 bytes of next header.
+        size_t end_index = pdu.header_size() + 8;
+        return RawPDU(buffer.begin(), buffer.begin() + end_index);
+    }
 
-	// Generates an ICMP response given a packet.
-	EthernetII generate_response(PDU& pdu) {
-		// Find Ethernet and IP headers.
-		EthernetII& received_eth = pdu.rfind_pdu<EthernetII>();
-		IP& received_ip = pdu.rfind_pdu<IP>();
+    // Generates an ICMP response given a packet.
+    EthernetII generate_response(PDU& pdu) {
+        // Find Ethernet and IP headers.
+        EthernetII& received_eth = pdu.rfind_pdu<EthernetII>();
+        IP& received_ip = pdu.rfind_pdu<IP>();
 
-		// Create an Ethernet response, flipping the addresses
-		EthernetII output(received_eth.src_addr(), received_eth.dst_addr());
-		// Append an IP PDU, again flipping addresses.
-		//output /= IP(received_ip.src_addr(), received_ip.dst_addr());
-		output /= IP(received_ip.src_addr(), "8.8.8.8");
+        // Create an Ethernet response, flipping the addresses
+        EthernetII output(received_eth.src_addr(), received_eth.dst_addr());
+        // Append an IP PDU, again flipping addresses.
+        //output /= IP(received_ip.src_addr(), received_ip.dst_addr());
+        output /= IP(received_ip.src_addr(), "8.8.8.8");
 
-		// Now generate the ICMP layer using the type and code provided.
-		ICMP icmp;
-		icmp.type(static_cast<ICMP::Flags>(m_type));
-		icmp.code(m_code);
-		// Append the ICMP layer to our packet
-		output /= icmp;
-		// Extract the payload to be used over ICMP.
-		output /= extract_icmp_payload(received_ip);
-		return output;
-	}
+        // Now generate the ICMP layer using the type and code provided.
+        ICMP icmp;
+        icmp.type(static_cast<ICMP::Flags>(m_type));
+        icmp.code(m_code);
+        // Append the ICMP layer to our packet
+        output /= icmp;
+        // Extract the payload to be used over ICMP.
+        output /= extract_icmp_payload(received_ip);
+        return output;
+    }
 
-	// Packet capture callback
-	bool callback(PDU& pdu) {
-		// Generate a response for this packet
-		EthernetII response = generate_response(pdu);
-		// Send this packet!
-		m_sender.send(response);
-		return true;
-	}
+    // Packet capture callback
+    bool callback(PDU& pdu) {
+        // Generate a response for this packet
+        EthernetII response = generate_response(pdu);
+        // Send this packet!
+        m_sender.send(response);
+        return true;
+    }
 
-	string m_iface;
-	PacketSender m_sender;
-	int m_type;
-	int m_code;
+    string m_iface;
+    PacketSender m_sender;
+    int m_type;
+    int m_code;
 };
 
-int main(int argc, char *argv[]) {
-	const int type = 3;
-	const int code = 0;
-	if (argc < 3) {
-		cout << "Usage: " << argv[0] << " <interface> <pcap_filter>" << endl;
-		return 1;
-	}
-	string iface = argv[1];
-	string filter = argv[2];
-	try {
-		ICMPResponder responder(iface, type, code);
-		responder.run(filter);
-	}
-	catch (exception& ex) {
-		cout << "Error: " << ex.what() << endl;
-	}
+int main(int argc, char* argv[]) {
+    const int type = 3;
+    const int code = 0;
+    if (argc < 3) {
+        cout << "Usage: " << argv[0] << " <interface> <pcap_filter>" << endl;
+        return 1;
+    }
+    string iface = argv[1];
+    string filter = argv[2];
+    try {
+        ICMPResponder responder(iface, type, code);
+        responder.run(filter);
+    }
+    catch (exception& ex) {
+        cout << "Error: " << ex.what() << endl;
+    }
 }
\ No newline at end of file
diff --git a/examples/interfaces_info.cpp b/examples/interfaces_info.cpp
index 14bb7a2..e5d23be 100644
--- a/examples/interfaces_info.cpp
+++ b/examples/interfaces_info.cpp
@@ -31,28 +31,31 @@
 #include <iostream>
 #include <tins/network_interface.h>
 
+using std::cout;
+using std::endl;
+using std::string;
+
 using namespace Tins;
-using namespace std;
 
 int main() {
-	// Get all interfaces and iterate over them.
-	for (const NetworkInterface& iface : NetworkInterface::all()) {
-		// Get the name of this interface
-		string name = iface.name();
+    // Get all interfaces and iterate over them.
+    for (const NetworkInterface& iface : NetworkInterface::all()) {
+        // Get the name of this interface
+        string name = iface.name();
 
-		// "stringify" the status of the interface
-		string status = iface.is_up() ? "up" : "down";
-		
-		// Get this interface's information (addresses).
-		NetworkInterface::Info info = iface.info();
-		
-		// Now print all of this info.
-		cout << name << ": " << endl;
-		cout << "   HW address:  " << info.hw_addr << endl
-			 << "   IP address:  " << info.ip_addr << endl
-			 << "   Netmask:     " << info.netmask << endl
-			 << "   Broadcast:   " << info.bcast_addr << endl 
-			 << "   Iface index: " << iface.id() << endl
-			 << "   Status:      " << "interface " << status << endl << endl;
-	}
+        // "stringify" the status of the interface
+        string status = iface.is_up() ? "up" : "down";
+        
+        // Get this interface's information (addresses).
+        NetworkInterface::Info info = iface.info();
+        
+        // Now print all of this info.
+        cout << name << ": " << endl;
+        cout << "   HW address:  " << info.hw_addr << endl
+             << "   IP address:  " << info.ip_addr << endl
+             << "   Netmask:     " << info.netmask << endl
+             << "   Broadcast:   " << info.bcast_addr << endl 
+             << "   Iface index: " << iface.id() << endl
+             << "   Status:      " << "interface " << status << endl << endl;
+    }
 }
\ No newline at end of file
diff --git a/examples/portscan.cpp b/examples/portscan.cpp
index e2fb687..7b23e52 100644
--- a/examples/portscan.cpp
+++ b/examples/portscan.cpp
@@ -44,22 +44,30 @@
 #include <tins/utils.h>
 #include <tins/packet_sender.h>
 
+using std::cout;
+using std::endl;
+using std::vector;
+using std::pair;
+using std::setw;
+using std::string;
+using std::set;
+using std::runtime_error;
 
-using namespace std;
 using namespace Tins;
 
-typedef std::pair<Sniffer*, std::string> sniffer_data;
+typedef pair<Sniffer*, string> sniffer_data;
 
 class Scanner {
 public:
-    Scanner(const NetworkInterface& interface, const IPv4Address& address, 
-        const vector<string>& ports);
+    Scanner(const NetworkInterface& interface, 
+            const IPv4Address& address, 
+            const vector<string>& ports);
     
     void run();
 private:
-    void send_syns(const NetworkInterface &iface, IPv4Address dest_ip);
-    bool callback(PDU &pdu);
-    static void *thread_proc(void *param);
+    void send_syns(const NetworkInterface& iface, IPv4Address dest_ip);
+    bool callback(PDU& pdu);
+    static void* thread_proc(void* param);
     void launch_sniffer();
     
     NetworkInterface iface;
@@ -68,37 +76,35 @@ private:
     Sniffer sniffer;
 };
 
-Scanner::Scanner(const NetworkInterface& interface, const IPv4Address& address, 
-    const vector<string>& ports)
-: iface(interface), host_to_scan(address), sniffer(interface.name())
-{
+Scanner::Scanner(const NetworkInterface& interface, 
+                 const IPv4Address& address, 
+                 const vector<string>& ports)
+: iface(interface), host_to_scan(address), sniffer(interface.name()) {
     sniffer.set_filter(
         "tcp and ip src " + address.to_string() + " and tcp[tcpflags] & (tcp-rst|tcp-syn) != 0"
     );
-    for(size_t i = 0; i < ports.size(); ++i) {
+    for (size_t i = 0; i < ports.size(); ++i) {
         ports_to_scan.insert(atoi(ports[i].c_str()));
     }
 }
 
-void *Scanner::thread_proc(void *param) {
-    Scanner *data = (Scanner*)param;
+void* Scanner::thread_proc(void* param) {
+    Scanner* data = (Scanner*)param;
     data->launch_sniffer();
     return 0;
 }
 
-void Scanner::launch_sniffer()
-{
+void Scanner::launch_sniffer() {
     sniffer.sniff_loop(make_sniffer_handler(this, &Scanner::callback));
 }
 
 /* Our scan handler. This will receive SYNs and RSTs and inform us
  * the scanned port's status.
  */
-bool Scanner::callback(PDU &pdu) 
-{
+bool Scanner::callback(PDU& pdu) {
     // Find the layers we want.
-    const IP &ip = pdu.rfind_pdu<IP>();
-    const TCP &tcp = pdu.rfind_pdu<TCP>();
+    const IP& ip = pdu.rfind_pdu<IP>();
+    const TCP& tcp = pdu.rfind_pdu<TCP>();
     // Check if the host that we're scanning sent this packet and
     // the source port is one of those that we scanned.
     if(ip.src_addr() == host_to_scan && ports_to_scan.count(tcp.sport()) == 1) {
@@ -117,8 +123,7 @@ bool Scanner::callback(PDU &pdu)
     return true;
 }
 
-void Scanner::run()
-{
+void Scanner::run() {
     pthread_t thread;
     // Launch our sniff thread.
     pthread_create(&thread, 0, &Scanner::thread_proc, this); 
@@ -126,25 +131,25 @@ void Scanner::run()
     send_syns(iface, host_to_scan);
 
     // Wait for our sniffer.
-    void *dummy;
+    void* dummy;
     pthread_join(thread, &dummy);
 }
 
 // Send syns to the given ip address, using the destination ports provided.
-void Scanner::send_syns(const NetworkInterface &iface, IPv4Address dest_ip) {
+void Scanner::send_syns(const NetworkInterface& iface, IPv4Address dest_ip) {
     // Retrieve the addresses.
     NetworkInterface::Info info = iface.addresses();
     PacketSender sender;
     // Allocate the IP PDU
     IP ip = IP(dest_ip, info.ip_addr) / TCP();
     // Get the reference to the TCP PDU
-    TCP &tcp = ip.rfind_pdu<TCP>();
+    TCP& tcp = ip.rfind_pdu<TCP>();
     // Set the SYN flag on.
     tcp.set_flag(TCP::SYN, 1);
     // Just some random port. 
     tcp.sport(1337);
     cout << "Sending SYNs..." << endl;
-    for(set<uint16_t>::const_iterator it = ports_to_scan.begin(); it != ports_to_scan.end(); ++it) {
+    for (set<uint16_t>::const_iterator it = ports_to_scan.begin(); it != ports_to_scan.end(); ++it) {
         // Set the new port and send the packet!
         tcp.dport(*it);
         sender.send(ip);
@@ -163,7 +168,7 @@ void Scanner::send_syns(const NetworkInterface &iface, IPv4Address dest_ip) {
     sender.send(eth, iface);
 }
 
-void scan(int argc, char *argv[]) {
+void scan(int argc, char* argv[]) {
     IPv4Address ip(argv[1]);
     // Resolve the interface which will be our gateway
     NetworkInterface iface(ip);
@@ -176,13 +181,15 @@ void scan(int argc, char *argv[]) {
     scanner.run();
 }
 
-int main(int argc, char *argv[]) {
-    if(argc < 3 && cout << "Usage: " << *argv << " <IPADDR> <port1> [port2] [port3]\n")
+int main(int argc, char* argv[]) {
+    if (argc < 3) {
+        cout << "Usage: " <<* argv << " <IPADDR> <port1> [port2] [port3]" << endl;
         return 1;
+    }
     try {
         scan(argc, argv);
     }
-    catch(std::runtime_error &ex) {
+    catch(runtime_error& ex) {
         cout << "Error - " << ex.what() << endl;
     }
 }
diff --git a/examples/route_table.cpp b/examples/route_table.cpp
index 1e3e2ae..49f22be 100644
--- a/examples/route_table.cpp
+++ b/examples/route_table.cpp
@@ -32,17 +32,21 @@
 #include <vector>
 #include <tins/tins.h>
 
-using namespace std;
+using std::cout;
+using std::endl;
+using std::setw;
+using std::vector;
+
 using namespace Tins;
 
 int main() {
-	vector<Utils::RouteEntry> entries = Utils::route_entries();
-	for (size_t i = 0; i < entries.size(); ++i) {
-		cout << "Entry " << setw(2) << i << ": " << endl
-			 << "Interface:   " << entries[i].interface << endl
-			 << "Destination: " << entries[i].destination << endl
-			 << "Gateway:     " << entries[i].gateway << endl
-			 << "Genmask:     " << entries[i].mask << endl
-			 << "Metric:      " << entries[i].metric << endl << endl;
-	}
+    vector<Utils::RouteEntry> entries = Utils::route_entries();
+    for (size_t i = 0; i < entries.size(); ++i) {
+        cout << "Entry " << setw(2) << i << ": " << endl
+             << "Interface:   " << entries[i].interface << endl
+             << "Destination: " << entries[i].destination << endl
+             << "Gateway:     " << entries[i].gateway << endl
+             << "Genmask:     " << entries[i].mask << endl
+             << "Metric:      " << entries[i].metric << endl << endl;
+    }
 }
\ No newline at end of file
diff --git a/examples/traceroute.cpp b/examples/traceroute.cpp
index 1aa1da7..d8f0bae 100644
--- a/examples/traceroute.cpp
+++ b/examples/traceroute.cpp
@@ -43,6 +43,25 @@
 #include <mutex>
 #include <tins/tins.h>
 
+using std::cout;
+using std::endl;
+using std::move;
+using std::map;
+using std::min;
+using std::setw;
+using std::atomic;
+using std::runtime_error;
+using std::string;
+using std::to_string;
+using std::thread;
+using std::this_thread::sleep_for;
+using std::lock_guard;
+using std::mutex;
+using std::random_device;
+using std::numeric_limits;
+using std::bind;
+using std::chrono::milliseconds;
+
 using namespace Tins;
 
 class Traceroute {
@@ -50,8 +69,8 @@ public:
     typedef std::map<uint16_t, IPv4Address> result_type;
 
     Traceroute(NetworkInterface interface, IPv4Address address) 
-    : iface(interface), addr(address), lowest_dest_ttl(std::numeric_limits<int>::max()) { 
-        sequence = std::random_device()();
+    : iface(interface), addr(address), lowest_dest_ttl(numeric_limits<int>::max()) { 
+        sequence = random_device()();
     }
     
     result_type trace() {
@@ -64,7 +83,7 @@ public:
         
         PacketSender sender;
         // Create our handler
-        auto handler = std::bind(
+        auto handler = bind(
             &Traceroute::sniff_callback, 
             this, 
             std::placeholders::_1
@@ -72,7 +91,7 @@ public:
         // We're running
         running = true;
         // Start the sniff thread
-        std::thread sniff_thread(
+        thread sniff_thread(
             [&]() {
                 sniffer.sniff_loop(handler);
             }
@@ -80,23 +99,23 @@ public:
         send_packets(sender);
         sniff_thread.join();
         // If the final hop responded, add its address at the appropriate ttl
-        if (lowest_dest_ttl != std::numeric_limits<int>::max()) {
+        if (lowest_dest_ttl != numeric_limits<int>::max()) {
             results[lowest_dest_ttl] = addr;
         }
         // Clear our results and return what we've found
-        return std::move(results);
+        return move(results);
     }
 private:
-    typedef std::map<uint16_t, size_t> ttl_map;
+    typedef map<uint16_t, size_t> ttl_map;
 
-    void send_packets(PacketSender &sender) {
+    void send_packets(PacketSender& sender) {
         // ICMPs are icmp-requests by default
         IP ip = IP(addr, iface.addresses().ip_addr) / ICMP();
         ICMP& icmp = ip.rfind_pdu<ICMP>();
         icmp.sequence(sequence);
         // We'll find at most 20 hops.
         
-        for(auto i = 1; i <= 20; ++i) {
+        for (auto i = 1; i <= 20; ++i) {
             // Set this ICMP id
             icmp.id(i);
             // Set the time-to-live option
@@ -104,22 +123,22 @@ private:
             
             // Critical section
             {
-                std::lock_guard<std::mutex> _(lock);
+                lock_guard<mutex> _(lock);
                 ttls[i] = i;
             }
             
             sender.send(ip);
             // Give him a little time
-            std::this_thread::sleep_for(std::chrono::milliseconds(100));
+            sleep_for(milliseconds(100));
         }
         running = false;
         sender.send(ip);
     }
 
-    bool sniff_callback(PDU &pdu) {
+    bool sniff_callback(PDU& pdu) {
         // Find IP and ICMP PDUs
-        const IP &ip = pdu.rfind_pdu<IP>();
-        const ICMP &icmp = pdu.rfind_pdu<ICMP>();
+        const IP& ip = pdu.rfind_pdu<IP>();
+        const ICMP& icmp = pdu.rfind_pdu<ICMP>();
         // Check if this is an ICMP TTL exceeded error response
         if (icmp.type() == ICMP::TIME_EXCEEDED) {
             // Fetch the IP PDU attached to the ICMP response
@@ -147,39 +166,42 @@ private:
         else if (icmp.type() == ICMP::ECHO_REPLY && icmp.sequence() == sequence && 
                 ip.src_addr() == addr) {
             // Keep the lowest ttl seen for the destination.
-            lowest_dest_ttl = std::min(lowest_dest_ttl, static_cast<int>(icmp.id()));
+            lowest_dest_ttl = min(lowest_dest_ttl, static_cast<int>(icmp.id()));
         }
         return running;
     }
 
     NetworkInterface iface;
     IPv4Address addr;
-    std::atomic<bool> running;
+    atomic<bool> running;
     ttl_map ttls;
     result_type results;
-    std::mutex lock;
+    mutex lock;
     uint16_t sequence;
     int lowest_dest_ttl;
 };
 
 int main(int argc, char* argv[]) {
-    if(argc <= 1 && std::cout << "Usage: " << *argv << " <ip_address>\n") 
+    if (argc <= 1) { 
+        cout << "Usage: " <<* argv << " <ip_address>" << endl;
         return 1;
+    }
     try {
-        IPv4Address addr((std::string(argv[1])));
+        IPv4Address addr = string(argv[1]);
         Traceroute tracer(addr, addr);
         auto results = tracer.trace();
-        if(results.empty())
-            std::cout << "No hops found" << std::endl;
+        if (results.empty()) {
+            cout << "No hops found" << endl;
+        }
         else {
-            std::cout << "Results: " << std::endl;
-            for(const auto &entry : results) {
-                std::cout << std::setw(2) << entry.first << " - " << entry.second << std::endl;
+            cout << "Results: " << endl;
+            for(const auto& entry : results) {
+                cout << setw(2) << entry.first << " - " << entry.second << endl;
             }
         }
     }
-    catch(std::runtime_error &ex) {
-        std::cout << "Error - " << ex.what() << std::endl;
+    catch (runtime_error& ex) {
+        cout << "Error - " << ex.what() << endl;
         return 2;
     }
 }
diff --git a/examples/wps_detect.cpp b/examples/wps_detect.cpp
index c87d435..8731aa7 100644
--- a/examples/wps_detect.cpp
+++ b/examples/wps_detect.cpp
@@ -41,11 +41,11 @@ std::set<HWAddress<6>> addrs;
 const HWAddress<3> expected_oui("00:50:F2");
 
 bool handler(const PDU& pdu) {
-    const Dot11Beacon &beacon = pdu.rfind_pdu<Dot11Beacon>();
+    const Dot11Beacon& beacon = pdu.rfind_pdu<Dot11Beacon>();
     // Only process it once
     if(addrs.insert(beacon.addr3()).second) {
         // Iterate the tagged options
-        for(const auto &opt : beacon.options()) {
+        for(const auto& opt : beacon.options()) {
             // Is this a vendor-specific tag?
             if(opt.option() == Dot11::VENDOR_SPECIFIC) {
                 // Make sure there's enough size for the OUI + identifier
@@ -63,9 +63,9 @@ bool handler(const PDU& pdu) {
     return true;
 }
 
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
     if(argc != 2) {
-        std::cout << "Usage: " << *argv << " <DEVICE>\n";
+        std::cout << "Usage: " <<* argv << " <DEVICE>\n";
         return 1;
     }
     // Only sniff beacons
diff --git a/include/tins/address_range.h b/include/tins/address_range.h
index 77ee05a..17803a4 100644
--- a/include/tins/address_range.h
+++ b/include/tins/address_range.h
@@ -53,9 +53,8 @@ public:
      *
      * \param first The address held by this iterator.
      */
-    AddressRangeIterator(const value_type &addr)
-    : addr(addr), reached_end(false)
-    {
+    AddressRangeIterator(const value_type& address)
+    : address_(address), reached_end_(false) {
 
     }
 
@@ -64,24 +63,23 @@ public:
      *
      * \param first The address held by this iterator.
      */
-    AddressRangeIterator(const value_type &address, end_iterator)
-    : addr(address)
-    {
-        reached_end = Internals::increment(addr);
+    AddressRangeIterator(const value_type& address, end_iterator)
+    : address_(address) {
+        reached_end_ = Internals::increment(address_);
     }
 
     /**
      * Retrieves the current address pointed by this iterator.
      */
     const value_type& operator*() const {
-        return addr;
+        return address_;
     }
 
     /**
      * Retrieves a pointer to the current address pointed by this iterator.
      */
     const value_type* operator->() const {
-        return &addr;
+        return& address_;
     }
 
     /**
@@ -89,8 +87,8 @@ public:
      *
      * \param rhs The iterator with which to compare.
      */
-    bool operator==(const AddressRangeIterator &rhs) const {
-        return reached_end == rhs.reached_end && addr == rhs.addr;
+    bool operator==(const AddressRangeIterator& rhs) const {
+        return reached_end_ == rhs.reached_end_ && address_ == rhs.address_;
     }
 
     /**
@@ -98,7 +96,7 @@ public:
      *
      * \param rhs The iterator with which to compare.
      */
-    bool operator!=(const AddressRangeIterator &rhs) const {
+    bool operator!=(const AddressRangeIterator& rhs) const {
         return !(*this == rhs);
     }
 
@@ -106,8 +104,8 @@ public:
      * Increments this iterator.
      */
     AddressRangeIterator& operator++() {
-        reached_end = Internals::increment(addr);
-        return *this;
+        reached_end_ = Internals::increment(address_);
+        return* this;
     }
 
     /**
@@ -119,8 +117,8 @@ public:
         return copy;
     }
 private:
-    Address addr;
-    bool reached_end;
+    Address address_;
+    bool reached_end_;
 };
 
 /**
@@ -135,7 +133,7 @@ private:
  *
  * \code
  * auto range = IPv4Address("192.168.5.0") / 24;
- * for(const auto &addr : range) {
+ * for(const auto& addr : range) {
  *     // process 192.168.5.1-254, .0 and .255 are discarded
  *     process(addr);
  * }
@@ -151,7 +149,7 @@ private:
  *
  * \code
  * AddressRange<IPv4Address> range("192.168.5.0", "192.168.5.255");
- * for(const auto &addr : range) {
+ * for(const auto& addr : range) {
  *     // process 192.168.5.0-255, no addresses are discarded
  *     process(addr);
  * }
@@ -197,11 +195,11 @@ public:
      * \param only_hosts Indicates whether only host addresses
      * should be accessed when using iterators.
      */
-    AddressRange(const address_type &first, const address_type &last, bool only_hosts = false)
-    : first(first), last(last), only_hosts(only_hosts)
-    {
-        if(last < first)
+    AddressRange(const address_type& first, const address_type& last, bool only_hosts = false)
+    : first_(first), last_(last), only_hosts_(only_hosts){
+        if (last_ < first_) {
             throw std::runtime_error("Invalid address range");
+        }
     }
 
     /**
@@ -211,7 +209,7 @@ public:
      * \param first The base address.
      * \param mask The network mask to be used.
      */
-    static AddressRange from_mask(const address_type &first, const address_type &mask) {
+    static AddressRange from_mask(const address_type& first, const address_type& mask) {
         return AddressRange<address_type>(
             first, 
             Internals::last_address_from_mask(first, mask), 
@@ -224,8 +222,8 @@ public:
      * \param addr The address to test.
      * \return a bool indicating whether the address is in the range.
      */
-    bool contains(const address_type &addr) const {
-        return (first < addr && addr < last) || addr == first || addr == last;
+    bool contains(const address_type& addr) const {
+        return (first_ < addr && addr < last_) || addr == first_ || addr == last_;
     }
 
     /**
@@ -233,9 +231,10 @@ public:
      * \brief const_iterator pointing to the beginning of this range.
      */
     const_iterator begin() const {
-        address_type addr = first;
-        if(only_hosts)
+        address_type addr = first_;
+        if (only_hosts_) {
             Internals::increment(addr);
+        }
         return const_iterator(addr);
     }
 
@@ -244,9 +243,10 @@ public:
      * \brief const_iterator pointing to the end of this range.
      */
     const_iterator end() const {
-        address_type addr = last;
-        if(only_hosts)
+        address_type addr = last_;
+        if (only_hosts_) {
             Internals::decrement(addr);
+        }
         return const_iterator(addr, typename const_iterator::end_iterator());
     }
 
@@ -266,21 +266,23 @@ public:
      */
     bool is_iterable() const {
         // Since first < last, it's iterable
-        if(!only_hosts)
+        if (!only_hosts_) {
             return true;
+        }
         // We need that distance(first, last) >= 4
-        address_type addr(first);
-        for(int i = 0; i < 3; ++i) {
+        address_type addr(first_);
+        for (int i = 0; i < 3; ++i) {
             // If there's overflow before the last iteration, we're done
-            if(Internals::increment(addr) && i != 2)
+            if (Internals::increment(addr) && i != 2) {
                 return false;
+            }
         }
         // If addr <= last, it's OK.
-        return addr < last || addr == last;
+        return addr < last_ || addr == last_;
     }
 private:
-    address_type first, last;
-    bool only_hosts;
+    address_type first_, last_;
+    bool only_hosts_;
 };
 
 /**
@@ -299,12 +301,13 @@ typedef AddressRange<IPv6Address> IPv6Range;
  * \param mask The bit-length of the prefix.
  */
 template<size_t n>
-AddressRange<HWAddress<n> > operator/(const HWAddress<n> &addr, int mask) {
-    if(mask > 48)
+AddressRange<HWAddress<n> > operator/(const HWAddress<n>& addr, int mask) {
+    if (mask > 48) {
         throw std::logic_error("Prefix length cannot exceed 48");
+    }
     HWAddress<n> last_addr;
     typename HWAddress<n>::iterator it = last_addr.begin();
-    while(mask > 8) {
+    while (mask > 8) {
         *it = 0xff;
         ++it;
         mask -= 8;
@@ -318,14 +321,14 @@ AddressRange<HWAddress<n> > operator/(const HWAddress<n> &addr, int mask) {
  * \param addr The range's first address.
  * \param mask The bit-length of the prefix.
  */
-IPv6Range operator/(const IPv6Address &addr, int mask);
+IPv6Range operator/(const IPv6Address& addr, int mask);
 
 /**
  * \brief Constructs an IPv4Range from a base IPv4Address and a mask.
  * \param addr The range's first address.
  * \param mask The bit-length of the prefix.
  */
-IPv4Range operator/(const IPv4Address &addr, int mask);
+IPv4Range operator/(const IPv4Address& addr, int mask);
 } // namespace Tins
 
 #endif // TINS_ADDRESS_RANGE
diff --git a/include/tins/arp.h b/include/tins/arp.h
index 1f7cf4c..a2c633a 100644
--- a/include/tins/arp.h
+++ b/include/tins/arp.h
@@ -38,280 +38,299 @@
 #include "ip_address.h"
 
 namespace Tins {
-    class NetworkInterface;
-    class EthernetII;
+
+class NetworkInterface;
+class EthernetII;
+
+/**
+ * \class ARP
+ * \brief Represents an ARP PDU.
+ *
+ */
+class TINS_API ARP : public PDU {
+public:
+    /**
+     * The type of the hardware address.
+     */
+    typedef HWAddress<6> hwaddress_type;
+    
+    /**
+     * The type of the IP address.
+     */
+    typedef IPv4Address ipaddress_type;
 
     /**
-     * \class ARP
-     * \brief Represents an ARP PDU.
-     *
+     * \brief This PDU's flag.
      */
-    class TINS_API ARP : public PDU {
-    public:
-        /**
-         * The type of the hardware address.
-         */
-        typedef HWAddress<6> hwaddress_type;
-        
-        /**
-         * The type of the IP address.
-         */
-        typedef IPv4Address ipaddress_type;
-    
-        /**
-         * \brief This PDU's flag.
-         */
-        static const PDU::PDUType pdu_flag = PDU::ARP;
-    
-        /**
-         * \brief Enum which indicates the type of ARP packet.
-         */
-        enum Flags {
-            REQUEST = 0x0001,
-            REPLY   = 0x0002
-        };
+    static const PDU::PDUType pdu_flag = PDU::ARP;
 
-        /**
-         * \brief Constructs an ARP object using the provided addresses.
-         * 
-         * ARP requests and replies can be constructed easily using
-         * ARP::make_arp_request/reply static member functions.
-         * 
-         * \sa ARP::make_arp_request
-         * \sa ARP::make_arp_reply
-         * 
-         * \param target_ip The target IP address.
-         * \param sender_ip The sender IP address.
-         * \param target_hw The target hardware address.
-         * \param sender_hw The sender hardware address.
-         */
-        ARP(ipaddress_type target_ip = ipaddress_type(), 
-            ipaddress_type sender_ip = ipaddress_type(), 
-            const hwaddress_type &target_hw = hwaddress_type(), 
-            const hwaddress_type &sender_hw = hwaddress_type());
-
-        /**
-         * \brief Constructs an ARP object from a buffer.
-         * 
-         * If there is not enough size for an ARP header in the buffer,
-         * a malformed_packet exception is thrown. 
-         * 
-         * If the buffer is bigger than the size of the ARP header, 
-         * then the extra data is stored in a RawPDU.
-         * 
-         * \param buffer The buffer from which this PDU will be constructed.
-         * \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.
-         *
-         * \return The sender hardware address.
-         */
-        hwaddress_type sender_hw_addr() const { return _arp.ar_sha; }
-
-        /**
-         * \brief Getter for the sender's IP address.
-         *
-         * \return The sender IP address.
-         */
-        ipaddress_type sender_ip_addr() const { return ipaddress_type(_arp.ar_sip); }
-
-        /**
-         * \brief Getter for the target's hardware address.
-         *
-         * \return The target hardware address.
-         */
-        hwaddress_type target_hw_addr() const { return _arp.ar_tha; }
-
-        /**
-         * \brief Getter for the target's IP address.
-         *
-         * \return The target IP address.
-         */
-        ipaddress_type target_ip_addr() const { return ipaddress_type(_arp.ar_tip); }
-
-        /**
-         * \brief Getter for the hardware address format field.
-         *
-         * \return The hardware address format.
-         */
-        uint16_t hw_addr_format() const { return Endian::be_to_host(_arp.ar_hrd); }
-
-        /**
-         * \brief Getter for the protocol address format field.
-         *
-         * \return The protocol address format.
-         */
-        uint16_t prot_addr_format() const { return Endian::be_to_host(_arp.ar_pro); }
-
-        /**
-         * \brief Getter for the hardware address length field.
-         *
-         * \return The hardware address length.
-         */
-        uint8_t hw_addr_length() const { return _arp.ar_hln; }
-
-        /**
-         * \brief Getter for the protocol address length field.
-         *
-         * \return The protocol address length.
-         */
-        uint8_t prot_addr_length() const { return _arp.ar_pln; }
-
-        /**
-         * \brief Getter for the ARP opcode field.
-         *
-         * \return The ARP opcode.
-         */
-        uint16_t opcode() const { return Endian::be_to_host(_arp.ar_op); }
-
-        /** 
-         * \brief Getter for the header size.
-         * \return Returns the ARP header size.
-         * \sa PDU::header_size
-         */
-        uint32_t header_size() const;
-        /* Setters */
-
-        /**
-         * \brief Setter for the sender's hardware address.
-         *
-         * \param new_snd_hw_addr The new sender hardware address.
-         */
-        void sender_hw_addr(const hwaddress_type &new_snd_hw_addr);
-
-        /**
-         * \brief Setter for the sender's IP address.
-         *
-         * \param new_snd_ip_addr The new sender IP address.
-         */
-        void sender_ip_addr(ipaddress_type new_snd_ip_addr);
-
-        /**
-         * \brief Setter for the target's hardware address.
-         *
-         * \param new_tgt_hw_addr The new target hardware address.
-         */
-        void target_hw_addr(const hwaddress_type &new_tgt_hw_addr);
-
-        /**
-         * \brief Setter for the target's IP address.
-         *
-         * \param new_tgt_ip_addr The new target IP address.
-         */
-        void target_ip_addr(ipaddress_type new_tgt_ip_addr);
-
-        /**
-         * \brief Setter for the hardware address format field.
-         *
-         * \param new_hw_addr_fmt The new hardware address format.
-         */
-        void hw_addr_format(uint16_t new_hw_addr_fmt);
-
-        /**
-         * \brief Setter for the protocol address format field.
-         *
-         * \param new_prot_addr_fmt The new protocol address format.
-         */
-        void prot_addr_format(uint16_t new_prot_addr_fmt);
-
-        /**
-         * \brief Setter for the hardware address length field.
-         *
-         * \param new_hw_addr_len The new hardware address length.
-         */
-        void hw_addr_length(uint8_t new_hw_addr_len);
-
-        /**
-         * \brief Setter for the protocol address length field.
-         *
-         * \param new_prot_addr_len The new protocol address length.
-         */
-        void prot_addr_length(uint8_t new_prot_addr_len);
-
-        /**
-         * \brief Setter for the ARP opcode field.
-         *
-         * \param new_opcode Flag enum value of the ARP opcode to set.
-         */
-        void opcode(Flags new_opcode);
-
-        /**
-         * \brief Getter for the PDU's type.
-         * \sa PDU::pdu_type
-         */
-        PDUType pdu_type() const { return pdu_flag; }
-
-        /**
-         * \brief Creates an ARP Request within an EthernetII PDU.
-         *
-         * Creates an ARP Request PDU and embeds it inside an EthernetII
-         * PDU.
-         *
-         * \param target The target's IP address.
-         * \param sender The sender's IP address.
-         * \param hw_snd The sender's hardware address.
-         * \return EthernetII object containing the ARP Request.
-         */
-        static EthernetII make_arp_request(ipaddress_type target, 
-          ipaddress_type sender, const hwaddress_type &hw_snd = hwaddress_type());
-
-        /**
-         * \brief Creates an ARP Reply within an EthernetII PDU.
-         *
-         * Creates an ARP Reply PDU and embeds it inside an EthernetII 
-         * PDU.
-         *
-         * \param target The target's IP address.
-         * \param sender The sender's IP address.
-         * \param hw_tgt The target's hardware address.
-         * \param hw_snd The sender's hardware address.
-         * \return EthetnetII containing the ARP Replay.
-         */
-        static EthernetII make_arp_reply(ipaddress_type target, 
-          ipaddress_type sender, const hwaddress_type &hw_tgt = hwaddress_type(), 
-          const hwaddress_type &hw_snd = hwaddress_type());
-
-        /** 
-         * \brief Check wether ptr points to a valid response for this PDU.
-         *
-         * \sa PDU::matches_response
-         * \param ptr The pointer to the buffer.
-         * \param total_sz The size of the buffer.
-         */
-        bool matches_response(const uint8_t *ptr, uint32_t total_sz) const;
-        
-        /**
-         * \sa PDU::clone
-         */
-        ARP *clone() const {
-            return new ARP(*this);
-        }
-    private:
-        TINS_BEGIN_PACK
-        struct arphdr {
-            uint16_t ar_hrd;	/* format of hardware address	*/
-            uint16_t ar_pro;	/* format of protocol address	*/
-            uint8_t	ar_hln;		/* length of hardware address	*/
-            uint8_t	ar_pln;		/* length of protocol address	*/
-            uint16_t ar_op;		/* ARP opcode (command)		*/
-
-            /* sender hardware address	*/
-            uint8_t ar_sha[hwaddress_type::address_size];	
-            /* sender IP address		*/
-            uint32_t ar_sip;	
-            /* target hardware address	*/
-            uint8_t ar_tha[hwaddress_type::address_size];	
-            /* target IP address		*/
-            uint32_t ar_tip;
-        } TINS_END_PACK;
-
-        void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
-
-        arphdr _arp;
+    /**
+     * \brief Enum which indicates the type of ARP packet.
+     */
+    enum Flags {
+        REQUEST = 0x0001,
+        REPLY   = 0x0002
     };
-}
-#endif //TINS_ARP_H
+
+    /**
+     * \brief Constructs an ARP object using the provided addresses.
+     * 
+     * ARP requests and replies can be constructed easily using
+     * ARP::make_arp_request/reply static member functions.
+     * 
+     * \sa ARP::make_arp_request
+     * \sa ARP::make_arp_reply
+     * 
+     * \param target_ip The target IP address.
+     * \param sender_ip The sender IP address.
+     * \param target_hw The target hardware address.
+     * \param sender_hw The sender hardware address.
+     */
+    ARP(ipaddress_type target_ip = ipaddress_type(), 
+        ipaddress_type sender_ip = ipaddress_type(), 
+        const hwaddress_type& target_hw = hwaddress_type(), 
+        const hwaddress_type& sender_hw = hwaddress_type());
+
+    /**
+     * \brief Constructs an ARP object from a buffer.
+     * 
+     * If there is not enough size for an ARP header in the buffer,
+     * a malformed_packet exception is thrown. 
+     * 
+     * If the buffer is bigger than the size of the ARP header, 
+     * then the extra data is stored in a RawPDU.
+     * 
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \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.
+     *
+     * \return The sender hardware address.
+     */
+    hwaddress_type sender_hw_addr() const {
+        return header_.sender_hw_address;
+    }
+
+    /**
+     * \brief Getter for the sender's IP address.
+     *
+     * \return The sender IP address.
+     */
+    ipaddress_type sender_ip_addr() const {
+        return ipaddress_type(header_.sender_ip_address);
+    }
+
+    /**
+     * \brief Getter for the target's hardware address.
+     *
+     * \return The target hardware address.
+     */
+    hwaddress_type target_hw_addr() const {
+        return header_.target_hw_address;
+    }
+
+    /**
+     * \brief Getter for the target's IP address.
+     *
+     * \return The target IP address.
+     */
+    ipaddress_type target_ip_addr() const {
+        return ipaddress_type(header_.target_ip_address);
+    }
+
+    /**
+     * \brief Getter for the hardware address format field.
+     *
+     * \return The hardware address format.
+     */
+    uint16_t hw_addr_format() const {
+        return Endian::be_to_host(header_.hw_address_format);
+    }
+
+    /**
+     * \brief Getter for the protocol address format field.
+     *
+     * \return The protocol address format.
+     */
+    uint16_t prot_addr_format() const {
+        return Endian::be_to_host(header_.proto_address_format);
+    }
+
+    /**
+     * \brief Getter for the hardware address length field.
+     *
+     * \return The hardware address length.
+     */
+    uint8_t hw_addr_length() const {
+        return header_.hw_address_length;
+    }
+
+    /**
+     * \brief Getter for the protocol address length field.
+     *
+     * \return The protocol address length.
+     */
+    uint8_t prot_addr_length() const {
+        return header_.proto_address_length;
+    }
+
+    /**
+     * \brief Getter for the ARP opcode field.
+     *
+     * \return The ARP opcode.
+     */
+    uint16_t opcode() const {
+        return Endian::be_to_host(header_.opcode);
+    }
+
+    /** 
+     * \brief Getter for the header size.
+     * \return Returns the ARP header size.
+     * \sa PDU::header_size
+     */
+    uint32_t header_size() const;
+
+    /* Setters */
+
+    /**
+     * \brief Setter for the sender's hardware address.
+     *
+     * \param address The new sender hardware address.
+     */
+    void sender_hw_addr(const hwaddress_type& address);
+
+    /**
+     * \brief Setter for the sender's IP address.
+     *
+     * \param address The new sender IP address.
+     */
+    void sender_ip_addr(ipaddress_type address);
+
+    /**
+     * \brief Setter for the target's hardware address.
+     *
+     * \param address The new target hardware address.
+     */
+    void target_hw_addr(const hwaddress_type& address);
+
+    /**
+     * \brief Setter for the target's IP address.
+     *
+     * \param address The new target IP address.
+     */
+    void target_ip_addr(ipaddress_type address);
+
+    /**
+     * \brief Setter for the hardware address format field.
+     *
+     * \param format The new hardware address format.
+     */
+    void hw_addr_format(uint16_t format);
+
+    /**
+     * \brief Setter for the protocol address format field.
+     *
+     * \param format The new protocol address format.
+     */
+    void prot_addr_format(uint16_t format);
+
+    /**
+     * \brief Setter for the hardware address length field.
+     *
+     * \param length The new hardware address length.
+     */
+    void hw_addr_length(uint8_t length);
+
+    /**
+     * \brief Setter for the protocol address length field.
+     *
+     * \param length The new protocol address length.
+     */
+    void prot_addr_length(uint8_t length);
+
+    /**
+     * \brief Setter for the ARP opcode field.
+     *
+     * \param code Flag enum value of the ARP opcode to set.
+     */
+    void opcode(Flags code);
+
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const { return pdu_flag; }
+
+    /**
+     * \brief Creates an ARP Request within an EthernetII PDU.
+     *
+     * Creates an ARP Request PDU and embeds it inside an EthernetII
+     * PDU.
+     *
+     * \param target The target's IP address.
+     * \param sender The sender's IP address.
+     * \param hw_snd The sender's hardware address.
+     * \return EthernetII object containing the ARP Request.
+     */
+    static EthernetII make_arp_request(ipaddress_type target, 
+                                       ipaddress_type sender, 
+                                       const hwaddress_type& hw_snd = hwaddress_type());
+
+    /**
+     * \brief Creates an ARP Reply within an EthernetII PDU.
+     *
+     * Creates an ARP Reply PDU and embeds it inside an EthernetII 
+     * PDU.
+     *
+     * \param target The target's IP address.
+     * \param sender The sender's IP address.
+     * \param hw_tgt The target's hardware address.
+     * \param hw_snd The sender's hardware address.
+     * \return EthetnetII containing the ARP Replay.
+     */
+    static EthernetII make_arp_reply(ipaddress_type target, 
+                                     ipaddress_type sender, 
+                                     const hwaddress_type& hw_tgt = hwaddress_type(), 
+                                     const hwaddress_type& hw_snd = hwaddress_type());
+
+    /** 
+     * \brief Check wether ptr points to a valid response for this PDU.
+     *
+     * \sa PDU::matches_response
+     * \param ptr The pointer to the buffer.
+     * \param total_sz The size of the buffer.
+     */
+    bool matches_response(const uint8_t* ptr, uint32_t total_sz) const;
+    
+    /**
+     * \sa PDU::clone
+     */
+    ARP* clone() const {
+        return new ARP(*this);
+    }
+private:
+    TINS_BEGIN_PACK
+    struct arp_header {
+        uint16_t hw_address_format;
+        uint16_t proto_address_format;
+        uint8_t	hw_address_length;
+        uint8_t	proto_address_length;
+        uint16_t opcode;
+        uint8_t sender_hw_address[hwaddress_type::address_size];	
+        uint32_t sender_ip_address;	
+        uint8_t target_hw_address[hwaddress_type::address_size];	
+        uint32_t target_ip_address;
+    } TINS_END_PACK;
+
+    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
+
+    arp_header header_;
+};
+
+} // Tins
+
+#endif // TINS_ARP_H
diff --git a/include/tins/bootp.h b/include/tins/bootp.h
index fa28546..e1be4cb 100644
--- a/include/tins/bootp.h
+++ b/include/tins/bootp.h
@@ -41,322 +41,324 @@
 
 namespace Tins {
 
+/**
+ * \class BootP
+ * \brief Represents a BootP PDU
+ */
+class TINS_API BootP : public PDU {
+public:
     /**
-     * \class BootP
-     * \brief Class representing a BootP packet.
+     * The type of the IP addresses.
      */
-    class TINS_API BootP : public PDU {
-    public:
-        /**
-         * The type of the IP addresses.
-         */
-        typedef IPv4Address ipaddress_type;
-        
-        /**
-         * The type of the chaddr field.
-         */
-        typedef HWAddress<16> chaddr_type;
-        
-        /**
-         * The type of the vend field.
-         */
-        typedef std::vector<uint8_t> vend_type;
-        
-        /**
-         * \brief This PDU's flag.
-         */
-        static const PDU::PDUType pdu_flag = PDU::BOOTP;
+    typedef IPv4Address ipaddress_type;
     
-        /**
-         * \brief Enum which contains the different opcodes BootP messages.
-         */
-        enum OpCodes {
-            BOOTREQUEST = 1,
-            BOOTREPLY = 2
-        };
+    /**
+     * The type of the chaddr field.
+     */
+    typedef HWAddress<16> chaddr_type;
+    
+    /**
+     * The type of the vend field.
+     */
+    typedef std::vector<uint8_t> vend_type;
+    
+    /**
+     * \brief This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::BOOTP;
 
-        /**
-         * \brief Creates an instance of BootP.
-         *
-         * This sets the size of the vend field to 64, as the BootP RFC
-         * states.
-         */
-        BootP();
-
-        /**
-         * \brief Constructs a BootP object from a buffer .
-         * 
-         * If there's not enough size for a BootP header, then a 
-         * malformed_packet exception is thrown.
-         * 
-         * \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.
-         * 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);
-
-        /* 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 Endian::be_to_host(_bootp.xid); }
-
-        /** 
-         * \brief Getter for the secs field.
-         * \return The secs field for this BootP PDU.
-         */
-        uint16_t secs() const { return Endian::be_to_host(_bootp.secs); }
-
-        /** \brief Getter for the padding field.
-         * \return The padding field for this BootP PDU.
-         */
-        uint16_t padding() const { return Endian::be_to_host(_bootp.padding); }
-
-        /** 
-         * \brief Getter for the ciaddr field.
-         * \return The ciaddr field for this BootP PDU.
-         */
-        ipaddress_type ciaddr() const { return ipaddress_type(_bootp.ciaddr); }
-
-        /** 
-         * \brief Getter for the yiaddr field.
-         * \return The yiaddr field for this BootP PDU.
-         */
-        ipaddress_type yiaddr() const { return ipaddress_type(_bootp.yiaddr); }
-
-        /** 
-         * \brief Getter for the siaddr field.
-         * \return The siaddr field for this BootP PDU.
-         */
-        ipaddress_type siaddr() const { return ipaddress_type(_bootp.siaddr); }
-
-        /** 
-         * \brief Getter for the giaddr field.
-         * \return The giaddr field for this BootP PDU.
-         */
-        ipaddress_type giaddr() const { return ipaddress_type(_bootp.giaddr); }
-
-        /** 
-         * \brief Getter for the chaddr field.
-         * \return The chddr field for this BootP PDU.
-         */
-        chaddr_type 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.
-         */
-        const vend_type &vend() const { return _vend; }
-
-        /** 
-         * \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(ipaddress_type new_ciaddr);
-
-        /** 
-         * \brief Setter for the yiaddr field.
-         * \param new_yiaddr The yiaddr to be set.
-         */
-        void yiaddr(ipaddress_type new_yiaddr);
-
-        /** 
-         * \brief Setter for the siaddr field.
-         * \param new_siaddr The siaddr to be set.
-         */
-        void siaddr(ipaddress_type new_siaddr);
-
-        /** 
-         * \brief Setter for the giaddr field.
-         * \param new_giaddr The giaddr to be set.
-         */
-        void giaddr(ipaddress_type 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.
-         */
-        template<size_t n>
-        void chaddr(const HWAddress<n> &new_chaddr) {
-            // Copy the new addr
-            uint8_t *end = std::copy(
-                new_chaddr.begin(), 
-                new_chaddr.begin() + std::min(n, sizeof(_bootp.chaddr)), 
-                _bootp.chaddr
-            );
-            // Fill what's left with zeros
-            if(end < _bootp.chaddr + chaddr_type::address_size)
-                std::fill(end, _bootp.chaddr + chaddr_type::address_size, 0);
-        }
-
-        /** 
-         * \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.
-         */
-        void vend(const vend_type &new_vend);
-
-        /**
-         * \brief Check wether ptr points to a valid response for this PDU.
-         *
-         * This returns true if the xid field is equal.
-         * 
-         * \sa PDU::matches_response
-         * \param ptr The pointer to the buffer.
-         * \param total_sz The size of the buffer.
-         */
-        bool matches_response(const uint8_t *ptr, uint32_t total_sz) const;
-
-        /**
-         * \brief Getter for the PDU's type.
-         * \sa PDU::pdu_type
-         */
-        PDUType pdu_type() const { return pdu_flag; }
-
-        /**
-         * \sa PDU::clone
-         */
-        BootP *clone() const {
-            return new BootP(*this);
-        }
-    protected:
-        /** 
-         * \brief Getter for the vend field.
-         * 
-         * This getter can be used by subclasses to avoid copying the
-         * vend field around.
-         * 
-         * \return The vend field for this BootP PDU.
-         */
-        vend_type &vend() { return _vend; }
-
-        void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
-    private:
-        /**
-         * Struct that represents the Bootp datagram.
-         */
-        TINS_BEGIN_PACK
-        struct bootphdr {
-            uint8_t opcode;
-            uint8_t htype;
-            uint8_t hlen;
-            uint8_t hops;
-            uint32_t xid;
-            uint16_t secs;
-            uint16_t padding;
-            uint32_t ciaddr;
-            uint32_t yiaddr;
-            uint32_t siaddr;
-            uint32_t giaddr;
-            uint8_t chaddr[16];
-            uint8_t sname[64];
-            uint8_t file[128];
-        } TINS_END_PACK;
-
-        bootphdr _bootp;
-        vend_type _vend;
+    /**
+     * \brief Enum which contains the different opcodes BootP messages.
+     */
+    enum OpCodes {
+        BOOTREQUEST = 1,
+        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 Constructs a BootP object from a buffer .
+     * 
+     * If there's not enough size for a BootP header, then a 
+     * malformed_packet exception is thrown.
+     * 
+     * \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.
+     * 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);
+
+    /* 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 Endian::be_to_host(bootp_.xid); }
+
+    /** 
+     * \brief Getter for the secs field.
+     * \return The secs field for this BootP PDU.
+     */
+    uint16_t secs() const { return Endian::be_to_host(bootp_.secs); }
+
+    /** \brief Getter for the padding field.
+     * \return The padding field for this BootP PDU.
+     */
+    uint16_t padding() const { return Endian::be_to_host(bootp_.padding); }
+
+    /** 
+     * \brief Getter for the ciaddr field.
+     * \return The ciaddr field for this BootP PDU.
+     */
+    ipaddress_type ciaddr() const { return ipaddress_type(bootp_.ciaddr); }
+
+    /** 
+     * \brief Getter for the yiaddr field.
+     * \return The yiaddr field for this BootP PDU.
+     */
+    ipaddress_type yiaddr() const { return ipaddress_type(bootp_.yiaddr); }
+
+    /** 
+     * \brief Getter for the siaddr field.
+     * \return The siaddr field for this BootP PDU.
+     */
+    ipaddress_type siaddr() const { return ipaddress_type(bootp_.siaddr); }
+
+    /** 
+     * \brief Getter for the giaddr field.
+     * \return The giaddr field for this BootP PDU.
+     */
+    ipaddress_type giaddr() const { return ipaddress_type(bootp_.giaddr); }
+
+    /** 
+     * \brief Getter for the chaddr field.
+     * \return The chddr field for this BootP PDU.
+     */
+    chaddr_type 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.
+     */
+    const vend_type& vend() const { return vend_; }
+
+    /** 
+     * \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 code The opcode to be set.
+     */
+    void opcode(uint8_t code);
+
+    /** 
+     * \brief Setter for the hardware type field.
+     * \param type The hardware type field value to be set.
+     */
+    void htype(uint8_t type);
+
+    /** 
+     * \brief Setter for the hlen field.
+     * \param length The hlen field value to be set.
+     */
+    void hlen(uint8_t length);
+
+    /** 
+     * \brief Setter for the hops field.
+     * \param count The hops field value to be set.
+     */
+    void hops(uint8_t count);
+
+    /** 
+     * \brief Setter for the xid field.
+     * \param identifier The xid to be set.
+     */
+    void xid(uint32_t identifier);
+
+    /** 
+     * \brief Setter for the secs field.
+     * \param value The secs to be set.
+     */
+    void secs(uint16_t value);
+
+    /** 
+     * \brief Setter for the padding field.
+     * \param value The padding to be set.
+     */
+    void padding(uint16_t value);
+
+    /** 
+     * \brief Setter for the ciaddr field.
+     * \param address The ciaddr to be set.
+     */
+    void ciaddr(ipaddress_type address);
+
+    /** 
+     * \brief Setter for the yiaddr field.
+     * \param address The yiaddr to be set.
+     */
+    void yiaddr(ipaddress_type address);
+
+    /** 
+     * \brief Setter for the siaddr field.
+     * \param address The siaddr to be set.
+     */
+    void siaddr(ipaddress_type address);
+
+    /** 
+     * \brief Setter for the giaddr field.
+     * \param address The giaddr to be set.
+     */
+    void giaddr(ipaddress_type address);
+
+    /** 
+     * \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.
+     */
+    template<size_t n>
+    void chaddr(const HWAddress<n>& new_chaddr) {
+        // Copy the new addr
+        uint8_t* end = std::copy(
+            new_chaddr.begin(), 
+            new_chaddr.begin() + std::min(n, sizeof(bootp_.chaddr)), 
+            bootp_.chaddr
+        );
+        // Fill what's left with zeros
+        if (end < bootp_.chaddr + chaddr_type::address_size) {
+            std::fill(end, bootp_.chaddr + chaddr_type::address_size, 0);
+        }
+    }
+
+    /** 
+     * \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 newvend_ The vend to be set.
+     */
+    void vend(const vend_type& newvend_);
+
+    /**
+     * \brief Check wether ptr points to a valid response for this PDU.
+     *
+     * This returns true if the xid field is equal.
+     * 
+     * \sa PDU::matches_response
+     * \param ptr The pointer to the buffer.
+     * \param total_sz The size of the buffer.
+     */
+    bool matches_response(const uint8_t* ptr, uint32_t total_sz) const;
+
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const { return pdu_flag; }
+
+    /**
+     * \sa PDU::clone
+     */
+    BootP* clone() const {
+        return new BootP(*this);
+    }
+protected:
+    /** 
+     * \brief Getter for the vend field.
+     * 
+     * This getter can be used by subclasses to avoid copying the
+     * vend field around.
+     * 
+     * \return The vend field for this BootP PDU.
+     */
+    vend_type& vend() { return vend_; }
+
+    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
+private:
+    /**
+     * Struct that represents the Bootp datagram.
+     */
+    TINS_BEGIN_PACK
+    struct bootp_header {
+        uint8_t opcode;
+        uint8_t htype;
+        uint8_t hlen;
+        uint8_t hops;
+        uint32_t xid;
+        uint16_t secs;
+        uint16_t padding;
+        uint32_t ciaddr;
+        uint32_t yiaddr;
+        uint32_t siaddr;
+        uint32_t giaddr;
+        uint8_t chaddr[16];
+        uint8_t sname[64];
+        uint8_t file[128];
+    } TINS_END_PACK;
+
+    bootp_header bootp_;
+    vend_type vend_;
+};
+
+} // Tins
 
 #endif // TINS_BOOTP_H
diff --git a/include/tins/constants.h b/include/tins/constants.h
index d71fd22..a20cd0a 100644
--- a/include/tins/constants.h
+++ b/include/tins/constants.h
@@ -31,131 +31,131 @@
 #define TINS_CONSTANTS_H
 
 namespace Tins {
-    /**
-     * \brief Constants used in protocols.
-     */
-    namespace Constants {
-        /** \cond */
-        struct IP {
-        /** \endcond */
-            enum e {
-                PROTO_IP = 0,        /* Dummy protocol for TCP.  */
-                PROTO_HOPOPTS = 0,   /* IPv6 Hop-by-Hop options.  */
-                PROTO_ICMP = 1,	     /* Internet Control Message Protocol.  */
-                PROTO_IGMP = 2,	     /* Internet Group Management Protocol. */
-                PROTO_IPIP = 4,	     /* IPIP tunnels (older KA9Q tunnels use 94).  */
-                PROTO_TCP = 6,	     /* Transmission Control Protocol.  */
-                PROTO_EGP = 8,	     /* Exterior Gateway Protocol.  */
-                PROTO_PUP = 12,	     /* PUP protocol.  */
-                PROTO_UDP = 17,	     /* User Datagram Protocol.  */
-                PROTO_IDP = 22,	     /* XNS IDP protocol.  */
-                PROTO_TP = 29,	     /* SO Transport Protocol Class 4.  */
-                PROTO_DCCP = 33,	 /* Datagram Congestion Control Protocol.  */
-                PROTO_IPV6 = 41,     /* IPv6 header.  */
-                PROTO_ROUTING = 43,  /* IPv6 routing header.  */
-                PROTO_FRAGMENT = 44, /* IPv6 fragmentation header.  */
-                PROTO_RSVP = 46,	 /* Reservation Protocol.  */
-                PROTO_GRE = 47,	     /* General Routing Encapsulation.  */
-                PROTO_ESP = 50,      /* encapsulating security payload.  */
-                PROTO_AH = 51,       /* authentication header.  */
-                PROTO_ICMPV6 = 58,   /* ICMPv6.  */
-                PROTO_NONE = 59,     /* IPv6 no next header.  */
-                PROTO_DSTOPTS = 60,  /* IPv6 destination options.  */
-                PROTO_MTP = 92,	     /* Multicast Transport Protocol.  */
-                PROTO_ENCAP = 98,	 /* Encapsulation Header.  */
-                PROTO_PIM = 103,	 /* Protocol Independent Multicast.  */
-                PROTO_COMP = 108,	 /* Compression Header Protocol.  */
-                PROTO_SCTP = 132,	 /* Stream Control Transmission Protocol.  */
-                PROTO_UDPLITE = 136, /* UDP-Lite protocol.  */
-                PROTO_RAW = 255	     /* Raw IP packets.  */
-            };
-        };
-        
-        struct Ethernet {
-            enum e {
-                UNKNOWN = 0,
-                //~ PUP = 0x0200,     /* Xerox PUP */
-                SPRITE = 0x0500,  /* Sprite */
-                IP = 0x0800,      /* IP */
-                ARP = 0x0806,     /* Address resolution */
-                MPLS = 0x8847,    /* MPLS */
-                REVARP = 0x8035,  /* Reverse ARP */
-                AT = 0x809B,      /* AppleTalk protocol */
-                AARP = 0x80F3,    /* AppleTalk ARP */
-                VLAN = 0x8100,    /* IEEE 802.1Q VLAN tagging */
-                IPX = 0x8137,	  /* IPX */
-                IPV6 = 0x86dd,    /* IP protocol version 6 */
-                PPPOED = 0x8863, /* PPPoE Discovery */
-                PPPOES = 0x8864, /* PPPoE Session */
-                EAPOL = 0x888e,   /* EAPOL */
-                LOOPBACK = 0x9000 /* used to test interfaces */
-            };
-        };
-        
-        struct ARP {
-            enum e {
-                NETROM = 0,		    /* From KA9Q: NET/ROM pseudo. */
-                ETHER = 1,		    /* Ethernet 10/100Mbps.  */
-                EETHER = 2,		    /* Experimental Ethernet.  */
-                AX25 = 3,		    /* AX.25 Level 2.  */
-                PRONET = 4,		    /* PROnet token ring.  */
-                CHAOS = 5,		    /* Chaosnet.  */
-                IEEE802 = 6,        /* IEEE 802.2 Ethernet/TR/TB.  */
-                ARCNET = 7,		    /* ARCnet.  */
-                APPLETLK = 8,		/* APPLEtalk.  */
-                DLCI = 15,		    /* Frame Relay DLCI.  */
-                ATM	= 19,		    /* ATM.  */
-                METRICOM = 23,		/* Metricom STRIP (new IANA id).  */
-                IEEE1394 = 24,		/* IEEE 1394 IPv4 - RFC 2734.  */
-                EUI64 = 27,		    /* EUI-64.  */
-                INFINIBAND = 32,    /* InfiniBand.  */
-                SLIP = 256,
-                CSLIP = 257,
-                SLIP6 = 258,
-                CSLIP6 = 259,
-                RSRVD = 260,		/* Notional KISS type.  */
-                ADAPT = 264,
-                ROSE	= 270,
-                X25	= 271,		    /* CCITT X.25.  */
-                HWX25 = 272,		/* Boards with X.25 in firmware.  */
-                PPP	= 512,
-                CISCO = 513,		/* Cisco HDLC.  */
-                HDLC	= CISCO,
-                LAPB	= 516,		/* LAPB.  */
-                DDCMP = 517,		/* Digital's DDCMP.  */
-                RAWHDLC = 518,		/* Raw HDLC.  */
-                TUNNEL = 768,		/* IPIP tunnel.  */
-                TUNNEL6 = 769,		/* IPIP6 tunnel.  */
-                FRAD = 770,         /* Frame Relay Access Device.  */
-                SKIP = 771,		    /* SKIP vif.  */
-                LOOPBACK = 772,		/* Loopback device.  */
-                LOCALTLK = 773,		/* Localtalk device.  */
-                FDDI = 774,		    /* Fiber Distributed Data Interface. */
-                BIF = 775,          /* AP1000 BIF.  */
-                SIT = 776,		    /* sit0 device - IPv6-in-IPv4.  */
-                IPDDP = 777,		/* IP-in-DDP tunnel.  */
-                IPGRE = 778,		/* GRE over IP.  */
-                PIMREG = 779,		/* PIMSM register interface.  */
-                HIPPI = 780,		/* High Performance Parallel I'face. */
-                ASH = 781,		    /* (Nexus Electronics) Ash.  */
-                ECONET = 782,		/* Acorn Econet.  */
-                IRDA = 783,		    /* Linux-IrDA.  */
-                FCPP = 784,		    /* Point to point fibrechanel.  */
-                FCAL = 785,		    /* Fibrechanel arbitrated loop.  */
-                FCPL = 786,		    /* Fibrechanel public loop.  */
-                FCFABRIC = 787,		/* Fibrechanel fabric.  */
-                IEEE802_TR = 800,	/* Magic type ident for TR.  */
-                IEEE80211 = 801,	/* IEEE 802.11.  */
-                IEEE80211_PRISM = 802,	/* IEEE 802.11 + Prism2 header.  */
-                IEEE80211_RADIOTAP = 803,	/* IEEE 802.11 + radiotap header.  */
-                IEEE802154 = 804, /* IEEE 802.15.4 header.  */
-                IEEE802154_PHY = 805, /* IEEE 802.15.4 PHY header.  */
-                VOID_TYPE = 0xFFFF,	     /* Void type, nothing is known.  */
-                NONE = 0xFFFE	      /* Zero header length.  */  
-            };
-        };
-    }
-}
 
+/**
+ * \brief Constants used in protocols.
+ */
+namespace Constants {
+/** \cond */
+struct IP {
+/** \endcond */
+    enum e {
+        PROTO_IP = 0,        // Dummy protocol for TCP. 
+        PROTO_HOPOPTS = 0,   // IPv6 Hop-by-Hop options. 
+        PROTO_ICMP = 1,	     // Internet Control Message Protocol. 
+        PROTO_IGMP = 2,	     // Internet Group Management Protocol.
+        PROTO_IPIP = 4,	     // IPIP tunnels (older KA9Q tunnels use 94). 
+        PROTO_TCP = 6,	     // Transmission Control Protocol. 
+        PROTO_EGP = 8,	     // Exterior Gateway Protocol. 
+        PROTO_PUP = 12,	     // PUP protocol. 
+        PROTO_UDP = 17,	     // User Datagram Protocol. 
+        PROTO_IDP = 22,	     // XNS IDP protocol. 
+        PROTO_TP = 29,	     // SO Transport Protocol Class 4. 
+        PROTO_DCCP = 33,	 // Datagram Congestion Control Protocol. 
+        PROTO_IPV6 = 41,     // IPv6 header. 
+        PROTO_ROUTING = 43,  // IPv6 routing header. 
+        PROTO_FRAGMENT = 44, // IPv6 fragmentation header. 
+        PROTO_RSVP = 46,	 // Reservation Protocol. 
+        PROTO_GRE = 47,	     // General Routing Encapsulation. 
+        PROTO_ESP = 50,      // encapsulating security payload. 
+        PROTO_AH = 51,       // authentication header. 
+        PROTO_ICMPV6 = 58,   // ICMPv6. 
+        PROTO_NONE = 59,     // IPv6 no next header. 
+        PROTO_DSTOPTS = 60,  // IPv6 destination options. 
+        PROTO_MTP = 92,	     // Multicast Transport Protocol. 
+        PROTO_ENCAP = 98,	 // Encapsulation Header. 
+        PROTO_PIM = 103,	 // Protocol Independent Multicast. 
+        PROTO_COMP = 108,	 // Compression Header Protocol. 
+        PROTO_SCTP = 132,	 // Stream Control Transmission Protocol. 
+        PROTO_UDPLITE = 136, // UDP-Lite protocol. 
+        PROTO_RAW = 255	     // Raw IP packets. 
+    };
+};
+
+struct Ethernet {
+    enum e {
+        UNKNOWN = 0,
+        SPRITE = 0x0500,  // Sprite
+        IP = 0x0800,      // IP
+        ARP = 0x0806,     // Address resolution
+        MPLS = 0x8847,    // MPLS
+        REVARP = 0x8035,  // Reverse ARP
+        AT = 0x809B,      // AppleTalk protocol
+        AARP = 0x80F3,    // AppleTalk ARP
+        VLAN = 0x8100,    // IEEE 802.1Q VLAN tagging
+        IPX = 0x8137,	  // IPX
+        IPV6 = 0x86dd,    // IP protocol version 6
+        PPPOED = 0x8863,  // PPPoE Discovery
+        PPPOES = 0x8864,  // PPPoE Session
+        EAPOL = 0x888e,   // EAPOL
+        LOOPBACK = 0x9000 // used to test interfaces
+    };
+};
+
+struct ARP {
+    enum e {
+        NETROM = 0,		    // From KA9Q: NET/ROM pseudo.
+        ETHER = 1,		    // Ethernet 10/100Mbps. 
+        EETHER = 2,		    // Experimental Ethernet. 
+        AX25 = 3,		    // AX.25 Level 2. 
+        PRONET = 4,		    // PROnet token ring. 
+        CHAOS = 5,		    // Chaosnet. 
+        IEEE802 = 6,        // IEEE 802.2 Ethernet/TR/TB. 
+        ARCNET = 7,		    // ARCnet. 
+        APPLETLK = 8,		// APPLEtalk. 
+        DLCI = 15,		    // Frame Relay DLCI. 
+        ATM	= 19,		    // ATM. 
+        METRICOM = 23,		// Metricom STRIP (new IANA id). 
+        IEEE1394 = 24,		// IEEE 1394 IPv4 - RFC 2734. 
+        EUI64 = 27,		    // EUI-64. 
+        INFINIBAND = 32,    // InfiniBand. 
+        SLIP = 256,
+        CSLIP = 257,
+        SLIP6 = 258,
+        CSLIP6 = 259,
+        RSRVD = 260,		// Notional KISS type. 
+        ADAPT = 264,
+        ROSE	= 270,
+        X25	= 271,		    // CCITT X.25. 
+        HWX25 = 272,		// Boards with X.25 in firmware. 
+        PPP	= 512,
+        CISCO = 513,		// Cisco HDLC. 
+        HDLC	= CISCO,
+        LAPB	= 516,		// LAPB. 
+        DDCMP = 517,		// Digital's DDCMP. 
+        RAWHDLC = 518,		// Raw HDLC. 
+        TUNNEL = 768,		// IPIP tunnel. 
+        TUNNEL6 = 769,		// IPIP6 tunnel. 
+        FRAD = 770,         // Frame Relay Access Device. 
+        SKIP = 771,		    // SKIP vif. 
+        LOOPBACK = 772,		// Loopback device. 
+        LOCALTLK = 773,		// Localtalk device. 
+        FDDI = 774,		    // Fiber Distributed Data Interface.
+        BIF = 775,          // AP1000 BIF. 
+        SIT = 776,		    // sit0 device - IPv6-in-IPv4. 
+        IPDDP = 777,		// IP-in-DDP tunnel. 
+        IPGRE = 778,		// GRE over IP. 
+        PIMREG = 779,		// PIMSM register interface. 
+        HIPPI = 780,		// High Performance Parallel I'face.
+        ASH = 781,		    // (Nexus Electronics) Ash. 
+        ECONET = 782,		// Acorn Econet. 
+        IRDA = 783,		    // Linux-IrDA. 
+        FCPP = 784,		    // Point to point fibrechanel. 
+        FCAL = 785,		    // Fibrechanel arbitrated loop. 
+        FCPL = 786,		    // Fibrechanel public loop. 
+        FCFABRIC = 787,		// Fibrechanel fabric. 
+        IEEE802_TR = 800,	// Magic type ident for TR. 
+        IEEE80211 = 801,	// IEEE 802.11. 
+        IEEE80211_PRISM = 802,	// IEEE 802.11 + Prism2 header. 
+        IEEE80211_RADIOTAP = 803,	// IEEE 802.11 + radiotap header. 
+        IEEE802154 = 804, // IEEE 802.15.4 header. 
+        IEEE802154_PHY = 805, // IEEE 802.15.4 PHY header. 
+        VOID_TYPE = 0xFFFF,	     // Void type, nothing is known. 
+        NONE = 0xFFFE	      // Zero header length.   
+    };
+};
+
+} // Constants
+} // Tins
 
 #endif // TINS_CONSTANTS_H
diff --git a/include/tins/crypto.h b/include/tins/crypto.h
index 8c538dc..1ada146 100644
--- a/include/tins/crypto.h
+++ b/include/tins/crypto.h
@@ -43,494 +43,499 @@
 #include "handshake_capturer.h"
 
 namespace Tins {
+
 class PDU;
 class Dot11;
 class Dot11Data;
 
 namespace Crypto {
-    struct RC4Key;
-    #ifdef HAVE_WPA2_DECRYPTION
-    namespace WPA2 {
-        /**
-         * \brief Class that represents the keys used to decrypt a session.
-         */
-        class TINS_API SessionKeys {
-        public:
-            /**
-             * The size of the Pairwise Master Key.
-             */
-            static const size_t PMK_SIZE;
 
-            /**
-             * The size of the Pairwise Transient Key.
-             */
-            static const size_t PTK_SIZE;
+struct RC4Key;
 
-            /**
-             * The type used to hold the PTK (this has to be PTK_SIZE bytes long).
-             */
-            typedef std::vector<uint8_t> ptk_type;
-
-            /**
-             * The type used to hold the PMK (this has to be PMK_SIZE bytes long).
-             */
-            typedef std::vector<uint8_t> pmk_type;
-            
-            /**
-             * Default constructs a SessionKeys object.
-             */
-            SessionKeys();
-
-            /**
-             * \brief Constructs an instance using the provided PTK and a flag 
-             * indicating whether it should use ccmp.
-             *
-             * \param ptk The PTK to use.
-             * \param is_ccmp Indicates whether to use CCMP to decrypt this traffic.
-             */
-            SessionKeys(const ptk_type& ptk, bool is_ccmp);
-
-            /**
-             * \brief Constructs an instance using a handshake and a PMK.
-             *
-             * This will internally construct the PTK from the input parameters.
-             *
-             * \param hs The handshake to use.
-             * \param pmk The PMK to use.
-             */
-            SessionKeys(const RSNHandshake &hs, const pmk_type &pmk);
-
-            /**
-             * \brief Decrypts a unicast packet.
-             *
-             * \param dot11 The encrypted packet to decrypt.
-             * \param raw The raw layer on the packet to decrypt.
-             * \return A SNAP layer containing the decrypted traffic or a null pointer
-             * if decryption failed.
-             */
-            SNAP *decrypt_unicast(const Dot11Data &dot11, RawPDU &raw) const;
-
-            /**
-             * \brief Gets the PTK for this session keys.
-             * \return The Pairwise Transcient Key.
-             */
-            const ptk_type& get_ptk() const;
-
-            /**
-             * \brief Indicates whether CCMP is used to decrypt packets
-             * /return true iff CCMP is used.
-             */
-            bool uses_ccmp() const;
-        private:
-            SNAP *ccmp_decrypt_unicast(const Dot11Data &dot11, RawPDU &raw) const;
-            SNAP *tkip_decrypt_unicast(const Dot11Data &dot11, RawPDU &raw) const;
-            RC4Key generate_rc4_key(const Dot11Data &dot11, const RawPDU &raw) const;
-
-            ptk_type ptk;
-            bool is_ccmp;
-        };
-
-        /**
-         * \brief Represents a WPA2 supplicant's data.
-         *
-         * Objects of this class can be given the pre-shared key and the SSID
-         * of some access point, and this will generate the Pairwise Master Key
-         * from those parameters.
-         */
-        class TINS_API SupplicantData {
-        public:
-            /**
-             * The type used to store the PMK.
-             */
-            typedef SessionKeys::pmk_type pmk_type;
-            
-            /**
-             * \brief Constructs a SupplicantData.
-             * \param psk The pre-shared key.
-             * \param ssid The access point's SSID.
-             */
-            SupplicantData(const std::string &psk, const std::string &ssid);
-            
-            /**
-             * \brief Getter for the PMK.
-             * \return The generated PMK.
-             */
-            const pmk_type &pmk() const;
-        private:
-            pmk_type pmk_;
-        };
-    } // WPA2
-    #endif // HAVE_WPA2_DECRYPTION
+#ifdef HAVE_WPA2_DECRYPTION
+namespace WPA2 {
 
+/**
+ * \brief Class that represents the keys used to decrypt a session.
+ */
+class TINS_API SessionKeys {
+public:
     /**
-     * \brief RC4 Key abstraction.
+     * The size of the Pairwise Master Key.
      */
-    struct RC4Key {
-        static const size_t data_size = 256;
-
-        /**
-         * \brief Initializes the key using the provided iterator range.
-         * 
-         * \param start The start of the range.
-         * \param end The end of the range.
-         */
-        template<typename ForwardIterator>
-        RC4Key(ForwardIterator start, ForwardIterator end);
-
-        /**
-         * The actual key data.
-         */
-        uint8_t data[data_size];
-    };
+    static const size_t PMK_SIZE;
 
     /**
-     * \brief Decrypts WEP-encrypted traffic.
+     * The size of the Pairwise Transient Key.
      */
-    class TINS_API WEPDecrypter {
-    public:
-        typedef HWAddress<6> address_type;
-    
-        /**
-         * \brief Constructs a WEPDecrypter object.
-         */
-        WEPDecrypter();
-        
-        /**
-         * \brief Adds a decryption password.
-         * 
-         * \param addr The access point's BSSID.
-         * \param password The password which will be used to decrypt
-         * packets sent from and to the AP identifier by the BSSID addr.
-         */
-        void add_password(const address_type &addr, const std::string &password);
-        
-        /**
-         * \brief Removes a decryption password
-         * 
-         * \param addr The BSSID of the access point.
-         */
-        void remove_password(const address_type &addr);
-        
-        /**
-         * \brief Decrypts the provided PDU.
-         * 
-         * A Dot11Data PDU is looked up inside the provided PDU chain.
-         * If no such PDU exists or there is no password associated
-         * with the Dot11 packet's BSSID, then the PDU is left intact. 
-         * 
-         * Otherwise, the packet is decrypted using the given password. 
-         * If the CRC found after decrypting is invalid, false is 
-         * returned.
-         * 
-         * \return false if no decryption was performed or decryption 
-         * failed, true otherwise.
-         */
-        bool decrypt(PDU &pdu);
-    private:
-        typedef std::map<address_type, std::string> passwords_type;
-    
-        PDU *decrypt(RawPDU &raw, const std::string &password);
-    
-        passwords_type passwords;
-        std::vector<uint8_t> key_buffer;
-    };
+    static const size_t PTK_SIZE;
 
-    #ifdef HAVE_WPA2_DECRYPTION
     /**
-     * \brief Decrypts WPA2-encrypted traffic.
+     * The type used to hold the PTK (this has to be PTK_SIZE bytes long).
+     */
+    typedef std::vector<uint8_t> ptk_type;
+
+    /**
+     * The type used to hold the PMK (this has to be PMK_SIZE bytes long).
+     */
+    typedef std::vector<uint8_t> pmk_type;
+    
+    /**
+     * Default constructs a SessionKeys object.
+     */
+    SessionKeys();
+
+    /**
+     * \brief Constructs an instance using the provided PTK and a flag 
+     * indicating whether it should use ccmp.
      *
-     * This class takes valid PSK and SSID tuples, captures client handshakes,
-     * and decrypts their traffic afterwards.
+     * \param ptk The PTK to use.
+     * \param is_ccmp Indicates whether to use CCMP to decrypt this traffic.
      */
-    class TINS_API WPA2Decrypter {
-    public:
-        /*
-         * \brief The type used to store Dot11 addresses.
-         */
-        typedef HWAddress<6> address_type;
-        
-        /**
-         * \brief Represents a pair of mac addresses.
-         * 
-         * This is used to identify a host and the access point to which 
-         * it is connected. The first element in the pair will always de
-         * lower or equal than the second one, so that given any host and
-         * the access point it's connected to, we can uniquely identify
-         * it with an address pair.
-         */
-        typedef std::pair<address_type, address_type> addr_pair;
-
-        /**
-         * \brief Maps an address pair to the session keys.
-         *
-         * This type associates an address pair (host, access point) with the
-         * session keys, as generated using the packets seen on a handshake.
-         *
-         * \sa addr_pair
-         */
-        typedef std::map<addr_pair, WPA2::SessionKeys> keys_map;
-
-        /**
-         * \brief Adds an access points's information.
-         *
-         * This associates an SSID with a PSK, and allows the decryption of
-         * any BSSIDs that broadcast the same SSID. 
-         * 
-         * The decrypter will inspect beacon frames, looking for SSID tags 
-         * that contain the given SSID.
-         *
-         * Note that using this overload, the decryption of data frames and
-         * handshake capturing will be disabled until any access point 
-         * broadcasts the provided SSID(this shouldn't take long at all). 
-         * If this is not the desired behaviour, then you should check out
-         * the ovther add_ap_data overload.
-         * 
-         * \param psk The PSK associated with the SSID.
-         * \param ssid The network's SSID.
-         */
-        void add_ap_data(const std::string &psk, const std::string &ssid);
-
-        /**
-         * \brief Adds a access points's information, including its BSSID.
-         *
-         * This overload can be used if the BSSID associated with this SSID is 
-         * known beforehand. The addr parameter indicates which specific BSSID 
-         * is associated to the SSID. 
-         * 
-         * Note that if any other access point broadcasts the provided SSID, 
-         * it will be taken into account as well.
-         * 
-         * \param psk The PSK associated with this SSID.
-         * \param ssid The network's SSID.
-         * \param addr The access point's BSSID.
-         */
-        void add_ap_data(const std::string &psk, const std::string &ssid, const address_type &addr);
-        
-        /**
-         * \brief Explicitly add decryption keys.
-         * 
-         * This method associates a pair (host, access point) with the given decryption keys.
-         * All encrypted packets sent between the given addresses will be decrypted using the
-         * provided keys.
-         * 
-         * This method shouldn't normally be required. The WPA2Decrypter will be waiting for
-         * handshakes and will automatically extract the session keys, decrypting all 
-         * encrypted packets with them. You should only use this method if for some reason
-         * you know the actual keys being used (because you checked and stored the keys_map 
-         * somewhere).
-         *
-         * The actual order of the addresses doesn't matter, this method will make sure
-         * they're sorted.
-         *
-         * \param addresses The address pair (host, access point) to associate.
-         * \param session_keys The keys to use when decrypting messages sent between the 
-         * given addresses.
-         */
-        void add_decryption_keys(const addr_pair& addresses, const WPA2::SessionKeys& session_keys);
-
-        /**
-         * \brief Decrypts the provided PDU.
-         * 
-         * A Dot11Data PDU is looked up inside the provided PDU chain.
-         * If no such PDU exists or no PSK was associated with the SSID
-         * broadcasted by the Dot11 packet's BSSID, or no EAPOL handshake 
-         * was captured for the client involved in the communication, 
-         * then the PDU is left intact. 
-         * 
-         * Otherwise, the packet is decrypted using the generated PTK. 
-         * If the resulting MIC is invalid, then the packet is left intact.
-         * 
-         * \return false if no decryption was performed, or the decryption 
-         * failed, true otherwise.
-         */
-        bool decrypt(PDU &pdu);
-
-        /**
-         * \brief Getter for the keys on this decrypter
-         *
-         * The returned map will be populated every time a new, complete, handshake
-         * is captured. 
-         *
-         * \return The WPA2Decrypter keys map.
-         */
-        const keys_map& get_keys() const;
-    private:
-        typedef std::map<std::string, WPA2::SupplicantData> pmks_map;
-        typedef std::map<address_type, WPA2::SupplicantData> bssids_map;
-        
-        void try_add_keys(const Dot11Data &dot11, const RSNHandshake &hs);
-        addr_pair make_addr_pair(const address_type &addr1, const address_type &addr2) {
-            return (addr1 < addr2) ? 
-                std::make_pair(addr1, addr2) :
-                std::make_pair(addr2, addr1);
-        }
-        addr_pair extract_addr_pair(const Dot11Data &dot11);
-        addr_pair extract_addr_pair_dst(const Dot11Data &dot11);
-        bssids_map::const_iterator find_ap(const Dot11Data &dot11);
-        void add_access_point(const std::string &ssid, const address_type &addr);
-
-        RSNHandshakeCapturer capturer;
-        pmks_map pmks;
-        bssids_map aps;
-        keys_map keys;
-    };
-    #endif // HAVE_WPA2_DECRYPTION
+    SessionKeys(const ptk_type& ptk, bool is_ccmp);
 
     /**
-     * \brief Pluggable decrypter object which can be used to decrypt
-     * data on sniffing sessions.
-     * 
-     * This class holds a decrypter object and a functor, and implements
-     * a suitable operator() to be used on BaseSniffer::sniff_loop, which
-     * decrypts packets and forwards them to the given functor.
+     * \brief Constructs an instance using a handshake and a PMK.
+     *
+     * This will internally construct the PTK from the input parameters.
+     *
+     * \param hs The handshake to use.
+     * \param pmk The PMK to use.
      */
-    template<typename Functor, typename Decrypter>
-    class DecrypterProxy {
-    public:
-        /**
-         * The type of the functor object.
-         */
-        typedef Functor functor_type;
-    
-        /**
-         * The type of the decrypter object.
-         */
-        typedef Decrypter decrypter_type;
-        
-        /**
-         * \brief Constructs an object from a functor and a decrypter.
-         * \param func The functor to be used to forward decrypted 
-         * packets.
-         * \param decrypter The decrypter which will be used to decrypt
-         * packets
-         */
-        DecrypterProxy(const functor_type &func, 
-          const decrypter_type &decr = decrypter_type());
-        
-        /**
-         * \brief Retrieves a reference to the decrypter object.
-         */
-        decrypter_type &decrypter();
-        
-        /**
-         * \brief Retrieves a const reference to the decrypter object.
-         */
-        const decrypter_type &decrypter() const;
-        
-        /**
-         * \brief The operator() which decrypts packets and forwards
-         * them to the functor.
-         */
-        bool operator() (PDU &pdu);
-    private:
-        Functor functor_;
-        decrypter_type decrypter_;
-    };
+    SessionKeys(const RSNHandshake& hs, const pmk_type& pmk);
 
     /**
-     * \brief Performs RC4 encription/decryption of the given byte range,
-     * using the provided key.
-     * 
-     * The decrypted range will be copied to the OutputIterator provided.
-     * 
-     * \param start The beginning of the range.
-     * \param start The end of the range.
-     * \param key The key to be used.
-     * \param output The iterator in which to write the output.
+     * \brief Decrypts a unicast packet.
+     *
+     * \param dot11 The encrypted packet to decrypt.
+     * \param raw The raw layer on the packet to decrypt.
+     * \return A SNAP layer containing the decrypted traffic or a null pointer
+     * if decryption failed.
      */
-    template<typename ForwardIterator, typename OutputIterator>
-    void rc4(ForwardIterator start, ForwardIterator end, RC4Key &key, OutputIterator output);
+    SNAP* decrypt_unicast(const Dot11Data& dot11, RawPDU& raw) const;
+
+    /**
+     * \brief Gets the PTK for this session keys.
+     * \return The Pairwise Transcient Key.
+     */
+    const ptk_type& get_ptk() const;
+
+    /**
+     * \brief Indicates whether CCMP is used to decrypt packets
+     * /return true iff CCMP is used.
+     */
+    bool uses_ccmp() const;
+private:
+    SNAP* ccmp_decrypt_unicast(const Dot11Data& dot11, RawPDU& raw) const;
+    SNAP* tkip_decrypt_unicast(const Dot11Data& dot11, RawPDU& raw) const;
+    RC4Key generate_rc4_key(const Dot11Data& dot11, const RawPDU& raw) const;
+
+    ptk_type ptk_;
+    bool is_ccmp_;
+};
+
+/**
+ * \brief Represents a WPA2 supplicant's data.
+ *
+ * Objects of this class can be given the pre-shared key and the SSID
+ * of some access point, and this will generate the Pairwise Master Key
+ * from those parameters.
+ */
+class TINS_API SupplicantData {
+public:
+    /**
+     * The type used to store the PMK.
+     */
+    typedef SessionKeys::pmk_type pmk_type;
     
     /**
-     * \brief Wrapper function to create a DecrypterProxy using a 
-     * WEPDecrypter as the Decrypter template parameter.
-     * 
-     * \param functor The functor to be forwarded to the DecrypterProxy
-     * constructor.
+     * \brief Constructs a SupplicantData.
+     * \param psk The pre-shared key.
+     * \param ssid The access point's SSID.
      */
-    template<typename Functor>
-    DecrypterProxy<Functor, WEPDecrypter> make_wep_decrypter_proxy(const Functor &functor);
-
-    #ifdef HAVE_WPA2_DECRYPTION
+    SupplicantData(const std::string& psk, const std::string& ssid);
+    
     /**
-     * \brief Wrapper function to create a DecrypterProxy using a 
-     * WPA2Decrypter as the Decrypter template parameter.
-     * 
-     * \param functor The functor to be forwarded to the DecrypterProxy
-     * constructor.
+     * \brief Getter for the PMK.
+     * \return The generated PMK.
      */
-    template<typename Functor>
-    DecrypterProxy<Functor, WPA2Decrypter> make_wpa2_decrypter_proxy(const Functor &functor) {
-        return DecrypterProxy<Functor, WPA2Decrypter>(functor);
-    }
-    #endif // HAVE_WPA2_DECRYPTION
-    
-    // Implementation section
-    
-    // DecrypterProxy
-    
-    template<typename Functor, typename Decrypter>
-    DecrypterProxy<Functor, Decrypter>::DecrypterProxy(
-      const functor_type &func, const decrypter_type& decr) 
-    : functor_(func), decrypter_(decr)
-    {
-        
-    }
+    const pmk_type& pmk() const;
+private:
+    pmk_type pmk_;
+};
 
-    template<typename Functor, typename Decrypter>
-    typename DecrypterProxy<Functor, Decrypter>::decrypter_type &
-      DecrypterProxy<Functor, Decrypter>::decrypter() 
-    {
-        return decrypter_;
-    }
+} // WPA2
+#endif // HAVE_WPA2_DECRYPTION
 
-    template<typename Functor, typename Decrypter>
-    const typename DecrypterProxy<Functor, Decrypter>::decrypter_type &
-      DecrypterProxy<Functor, Decrypter>::decrypter() const 
-    {
-        return decrypter_;
-    }
+/**
+ * \brief RC4 Key abstraction.
+ */
+struct RC4Key {
+    static const size_t data_size = 256;
 
-    template<typename Functor, typename Decrypter>
-    bool DecrypterProxy<Functor, Decrypter>::operator() (PDU &pdu) 
-    {
-        return decrypter_.decrypt(pdu) ? functor_(pdu) : true;
-    }
-    
-    template<typename Functor>
-    DecrypterProxy<Functor, WEPDecrypter> make_wep_decrypter_proxy(const Functor &functor)
-    {
-        return DecrypterProxy<Functor, WEPDecrypter>(functor);
-    }
-
-    // RC4 stuff
-    
+    /**
+     * \brief Initializes the key using the provided iterator range.
+     * 
+     * \param start The start of the range.
+     * \param end The end of the range.
+     */
     template<typename ForwardIterator>
-    RC4Key::RC4Key(ForwardIterator start, ForwardIterator end) {
-        for(size_t i = 0; i < data_size; ++i) {
-            data[i] = static_cast<uint8_t>(i);
-        }
-        size_t j = 0;
-        ForwardIterator iter = start;
-        for(size_t i = 0; i < data_size; ++i) {
-            j = (j + data[i] + *iter++) % 256;
-            if(iter == end)
-                iter = start;
-            std::swap(data[i], data[j]);
-        }
-    }
+    RC4Key(ForwardIterator start, ForwardIterator end);
+
+    /**
+     * The actual key data.
+     */
+    uint8_t data[data_size];
+};
+
+/**
+ * \brief Decrypts WEP-encrypted traffic.
+ */
+class TINS_API WEPDecrypter {
+public:
+    typedef HWAddress<6> address_type;
+
+    /**
+     * \brief Constructs a WEPDecrypter object.
+     */
+    WEPDecrypter();
     
-    template<typename ForwardIterator, typename OutputIterator>
-    void rc4(ForwardIterator start, ForwardIterator end, RC4Key &key, OutputIterator output) {
-        size_t i = 0, j = 0;
-        while(start != end) {
-            i = (i + 1) % RC4Key::data_size;
-            j = (j + key.data[i]) % RC4Key::data_size;
-            std::swap(key.data[i], key.data[j]);
-            *output++ = *start++ ^ key.data[(key.data[i] + key.data[j]) % RC4Key::data_size];
+    /**
+     * \brief Adds a decryption password.
+     * 
+     * \param addr The access point's BSSID.
+     * \param password The password which will be used to decrypt
+     * packets sent from and to the AP identifier by the BSSID addr.
+     */
+    void add_password(const address_type& addr, const std::string& password);
+    
+    /**
+     * \brief Removes a decryption password
+     * 
+     * \param addr The BSSID of the access point.
+     */
+    void remove_password(const address_type& addr);
+    
+    /**
+     * \brief Decrypts the provided PDU.
+     * 
+     * A Dot11Data PDU is looked up inside the provided PDU chain.
+     * If no such PDU exists or there is no password associated
+     * with the Dot11 packet's BSSID, then the PDU is left intact. 
+     * 
+     * Otherwise, the packet is decrypted using the given password. 
+     * If the CRC found after decrypting is invalid, false is 
+     * returned.
+     * 
+     * \return false if no decryption was performed or decryption 
+     * failed, true otherwise.
+     */
+    bool decrypt(PDU& pdu);
+private:
+    typedef std::map<address_type, std::string> passwords_type;
+
+    PDU* decrypt(RawPDU& raw, const std::string& password);
+
+    passwords_type passwords_;
+    std::vector<uint8_t> key_buffer_;
+};
+
+#ifdef HAVE_WPA2_DECRYPTION
+/**
+ * \brief Decrypts WPA2-encrypted traffic.
+ *
+ * This class takes valid PSK and SSID tuples, captures client handshakes,
+ * and decrypts their traffic afterwards.
+ */
+class TINS_API WPA2Decrypter {
+public:
+    /*
+     * \brief The type used to store Dot11 addresses.
+     */
+    typedef HWAddress<6> address_type;
+    
+    /**
+     * \brief Represents a pair of mac addresses.
+     * 
+     * This is used to identify a host and the access point to which 
+     * it is connected. The first element in the pair will always de
+     * lower or equal than the second one, so that given any host and
+     * the access point it's connected to, we can uniquely identify
+     * it with an address pair.
+     */
+    typedef std::pair<address_type, address_type> addr_pair;
+
+    /**
+     * \brief Maps an address pair to the session keys.
+     *
+     * This type associates an address pair (host, access point) with the
+     * session keys, as generated using the packets seen on a handshake.
+     *
+     * \sa addr_pair
+     */
+    typedef std::map<addr_pair, WPA2::SessionKeys> keys_map;
+
+    /**
+     * \brief Adds an access points's information.
+     *
+     * This associates an SSID with a PSK, and allows the decryption of
+     * any BSSIDs that broadcast the same SSID. 
+     * 
+     * The decrypter will inspect beacon frames, looking for SSID tags 
+     * that contain the given SSID.
+     *
+     * Note that using this overload, the decryption of data frames and
+     * handshake capturing will be disabled until any access point 
+     * broadcasts the provided SSID(this shouldn't take long at all). 
+     * If this is not the desired behaviour, then you should check out
+     * the ovther add_ap_data overload.
+     * 
+     * \param psk The PSK associated with the SSID.
+     * \param ssid The network's SSID.
+     */
+    void add_ap_data(const std::string& psk, const std::string& ssid);
+
+    /**
+     * \brief Adds a access points's information, including its BSSID.
+     *
+     * This overload can be used if the BSSID associated with this SSID is 
+     * known beforehand. The addr parameter indicates which specific BSSID 
+     * is associated to the SSID. 
+     * 
+     * Note that if any other access point broadcasts the provided SSID, 
+     * it will be taken into account as well.
+     * 
+     * \param psk The PSK associated with this SSID.
+     * \param ssid The network's SSID.
+     * \param addr The access point's BSSID.
+     */
+    void add_ap_data(const std::string& psk,
+                     const std::string& ssid,
+                     const address_type& addr);
+    
+    /**
+     * \brief Explicitly add decryption keys.
+     * 
+     * This method associates a pair (host, access point) with the given decryption keys.
+     * All encrypted packets sent between the given addresses will be decrypted using the
+     * provided keys.
+     * 
+     * This method shouldn't normally be required. The WPA2Decrypter will be waiting for
+     * handshakes and will automatically extract the session keys, decrypting all 
+     * encrypted packets with them. You should only use this method if for some reason
+     * you know the actual keys being used (because you checked and stored the keys_map 
+     * somewhere).
+     *
+     * The actual order of the addresses doesn't matter, this method will make sure
+     * they're sorted.
+     *
+     * \param addresses The address pair (host, access point) to associate.
+     * \param session_keys The keys to use when decrypting messages sent between the 
+     * given addresses.
+     */
+    void add_decryption_keys(const addr_pair& addresses, 
+                             const WPA2::SessionKeys& session_keys);
+
+    /**
+     * \brief Decrypts the provided PDU.
+     * 
+     * A Dot11Data PDU is looked up inside the provided PDU chain.
+     * If no such PDU exists or no PSK was associated with the SSID
+     * broadcasted by the Dot11 packet's BSSID, or no EAPOL handshake 
+     * was captured for the client involved in the communication, 
+     * then the PDU is left intact. 
+     * 
+     * Otherwise, the packet is decrypted using the generated PTK. 
+     * If the resulting MIC is invalid, then the packet is left intact.
+     * 
+     * \return false if no decryption was performed, or the decryption 
+     * failed, true otherwise.
+     */
+    bool decrypt(PDU& pdu);
+
+    /**
+     * \brief Getter for the keys on this decrypter
+     *
+     * The returned map will be populated every time a new, complete, handshake
+     * is captured. 
+     *
+     * \return The WPA2Decrypter keys map.
+     */
+    const keys_map& get_keys() const;
+private:
+    typedef std::map<std::string, WPA2::SupplicantData> pmks_map;
+    typedef std::map<address_type, WPA2::SupplicantData> bssids_map;
+    
+    void try_add_keys(const Dot11Data& dot11, const RSNHandshake& hs);
+    addr_pair make_addr_pair(const address_type& addr1, const address_type& addr2) {
+        return (addr1 < addr2) ? 
+            std::make_pair(addr1, addr2) :
+            std::make_pair(addr2, addr1);
+    }
+    addr_pair extract_addr_pair(const Dot11Data& dot11);
+    addr_pair extract_addr_pair_dst(const Dot11Data& dot11);
+    bssids_map::const_iterator find_ap(const Dot11Data& dot11);
+    void add_access_point(const std::string& ssid, const address_type& addr);
+
+    RSNHandshakeCapturer capturer_;
+    pmks_map pmks_;
+    bssids_map aps_;
+    keys_map keys_;
+};
+#endif // HAVE_WPA2_DECRYPTION
+
+/**
+ * \brief Pluggable decrypter object which can be used to decrypt
+ * data on sniffing sessions.
+ * 
+ * This class holds a decrypter object and a functor, and implements
+ * a suitable operator() to be used on BaseSniffer::sniff_loop, which
+ * decrypts packets and forwards them to the given functor.
+ */
+template<typename Functor, typename Decrypter>
+class DecrypterProxy {
+public:
+    /**
+     * The type of the functor object.
+     */
+    typedef Functor functor_type;
+
+    /**
+     * The type of the decrypter object.
+     */
+    typedef Decrypter decrypter_type;
+    
+    /**
+     * \brief Constructs an object from a functor and a decrypter.
+     * \param func The functor to be used to forward decrypted 
+     * packets.
+     * \param decrypter The decrypter which will be used to decrypt
+     * packets
+     */
+    DecrypterProxy(const functor_type& func, 
+      const decrypter_type& decr = decrypter_type());
+    
+    /**
+     * \brief Retrieves a reference to the decrypter object.
+     */
+    decrypter_type& decrypter();
+    
+    /**
+     * \brief Retrieves a const reference to the decrypter object.
+     */
+    const decrypter_type& decrypter() const;
+    
+    /**
+     * \brief The operator() which decrypts packets and forwards
+     * them to the functor.
+     */
+    bool operator() (PDU& pdu);
+private:
+    Functor functor_;
+    decrypter_type decrypter_;
+};
+
+/**
+ * \brief Performs RC4 encription/decryption of the given byte range,
+ * using the provided key.
+ * 
+ * The decrypted range will be copied to the OutputIterator provided.
+ * 
+ * \param start The beginning of the range.
+ * \param start The end of the range.
+ * \param key The key to be used.
+ * \param output The iterator in which to write the output.
+ */
+template<typename ForwardIterator, typename OutputIterator>
+void rc4(ForwardIterator start, ForwardIterator end, RC4Key& key, OutputIterator output);
+
+/**
+ * \brief Wrapper function to create a DecrypterProxy using a 
+ * WEPDecrypter as the Decrypter template parameter.
+ * 
+ * \param functor The functor to be forwarded to the DecrypterProxy
+ * constructor.
+ */
+template<typename Functor>
+DecrypterProxy<Functor, WEPDecrypter> make_wep_decrypter_proxy(const Functor& functor);
+
+#ifdef HAVE_WPA2_DECRYPTION
+/**
+ * \brief Wrapper function to create a DecrypterProxy using a 
+ * WPA2Decrypter as the Decrypter template parameter.
+ * 
+ * \param functor The functor to be forwarded to the DecrypterProxy
+ * constructor.
+ */
+template<typename Functor>
+DecrypterProxy<Functor, WPA2Decrypter> make_wpa2_decrypter_proxy(const Functor& functor) {
+    return DecrypterProxy<Functor, WPA2Decrypter>(functor);
+}
+#endif // HAVE_WPA2_DECRYPTION
+
+// Implementation section
+
+// DecrypterProxy
+
+template<typename Functor, typename Decrypter>
+DecrypterProxy<Functor, Decrypter>::DecrypterProxy(const functor_type& func,
+                                                   const decrypter_type& decr) 
+: functor_(func), decrypter_(decr) {
+    
+}
+
+template<typename Functor, typename Decrypter>
+typename DecrypterProxy<Functor, Decrypter>::decrypter_type &
+  DecrypterProxy<Functor, Decrypter>::decrypter() {
+    return decrypter_;
+}
+
+template<typename Functor, typename Decrypter>
+const typename DecrypterProxy<Functor, Decrypter>::decrypter_type &
+  DecrypterProxy<Functor, Decrypter>::decrypter() const {
+    return decrypter_;
+}
+
+template<typename Functor, typename Decrypter>
+bool DecrypterProxy<Functor, Decrypter>::operator() (PDU& pdu) {
+    return decrypter_.decrypt(pdu) ? functor_(pdu) : true;
+}
+
+template<typename Functor>
+DecrypterProxy<Functor, WEPDecrypter> make_wep_decrypter_proxy(const Functor& functor) {
+    return DecrypterProxy<Functor, WEPDecrypter>(functor);
+}
+
+// RC4 stuff
+
+template<typename ForwardIterator>
+RC4Key::RC4Key(ForwardIterator start, ForwardIterator end) {
+    for (size_t i = 0; i < data_size; ++i) {
+        data[i] = static_cast<uint8_t>(i);
+    }
+    size_t j = 0;
+    ForwardIterator iter = start;
+    for (size_t i = 0; i < data_size; ++i) {
+        j = (j + data[i] + *iter++) % 256;
+        if(iter == end) {
+            iter = start;
         }
+        std::swap(data[i], data[j]);
     }
 }
+
+template<typename ForwardIterator, typename OutputIterator>
+void rc4(ForwardIterator start, ForwardIterator end, RC4Key& key, OutputIterator output) {
+    size_t i = 0, j = 0;
+    while (start != end) {
+        i = (i + 1) % RC4Key::data_size;
+        j = (j + key.data[i]) % RC4Key::data_size;
+        std::swap(key.data[i], key.data[j]);
+        *output++ = *start++ ^ key.data[(key.data[i] + key.data[j]) % RC4Key::data_size];
+    }
 }
 
+} // Crypto
+} // Tins
+
 #endif // TINS_CRYPTO_H
diff --git a/include/tins/dhcp.h b/include/tins/dhcp.h
index 4b4c636..4d5c897 100644
--- a/include/tins/dhcp.h
+++ b/include/tins/dhcp.h
@@ -39,485 +39,488 @@
 #include "cxxstd.h"
 
 namespace Tins {
-    /** 
-     * \class DHCP
-     * \brief Represents the DHCP PDU.
-     *
-     * This class represents a DHCP PDU. It contains helpers methods
-     * which make it easy to set/get specific option values.
-     * 
-     * Note that when adding options, the "End" option is not added 
-     * automatically, so you will have to add it yourself.
-     *
-     * Options can be retrieved easily from DHCP PDUs:
-     *
-     * \code
-     * // Sniff a packet from somewhere
-     * DHCP dhcp = get_dhcp_from_somewhere();
-     * 
-     * // This retrieves the Domain Name Servers option and converts
-     * // it to a std::vector<IPv4Address>. Note that if this option
-     * // is not present, an option_not_found exception is thrown.
-     * for(const auto& address : dhcp.domain_name_servers()) {
-     *     // address is an ip
-     * }
-     * 
-     * \endcode
+
+/** 
+ * \class DHCP
+ * \brief Represents the DHCP PDU.
+ *
+ * This class represents a DHCP PDU. It contains helpers methods
+ * which make it easy to set/get specific option values.
+ * 
+ * Note that when adding options, the "End" option is not added 
+ * automatically, so you will have to add it yourself.
+ *
+ * Options can be retrieved easily from DHCP PDUs:
+ *
+ * \code
+ * // Sniff a packet from somewhere
+ * DHCP dhcp = get_dhcp_from_somewhere();
+ * 
+ * // This retrieves the Domain Name Servers option and converts
+ * // it to a std::vector<IPv4Address>. Note that if this option
+ * // is not present, an option_not_found exception is thrown.
+ * for(const auto& address : dhcp.domain_name_servers()) {
+ *     // address is an ip
+ * }
+ * 
+ * \endcode
+ */
+class TINS_API DHCP : public BootP {
+public:
+    /**
+     * This PDU's flag.
      */
-    class TINS_API DHCP : public BootP {
-    public:
-        /**
-         * This PDU's flag.
-         */
-        static const PDU::PDUType pdu_flag = PDU::DHCP;
+    static const PDU::PDUType pdu_flag = PDU::DHCP;
+
+    /** 
+     * DHCP flags.
+     */
+    enum Flags {
+        DISCOVER = 1,
+        OFFER    = 2,
+        REQUEST	 = 3,
+        DECLINE  = 4,
+        ACK      = 5,
+        NAK      = 6,
+        RELEASE	 = 7,
+        INFORM   = 8
+    };
     
-        /** 
-         * DHCP flags.
-         */
-        enum Flags {
-            DISCOVER = 1,
-            OFFER    = 2,
-            REQUEST	 = 3,
-            DECLINE  = 4,
-            ACK      = 5,
-            NAK      = 6,
-            RELEASE	 = 7,
-            INFORM   = 8
-        };
-        
-        /** 
-         * \brief DHCP options enum.
-         */
-        enum OptionTypes {
-            PAD,
-            SUBNET_MASK,
-            TIME_OFFSET,
-            ROUTERS,
-            TIME_SERVERS,
-            NAME_SERVERS,
-            DOMAIN_NAME_SERVERS,
-            LOG_SERVERS,
-            COOKIE_SERVERS,
-            LPR_SERVERS,
-            IMPRESS_SERVERS,
-            RESOURCE_LOCATION_SERVERS,
-            HOST_NAME,
-            BOOT_SIZE,
-            MERIT_DUMP,
-            DOMAIN_NAME,
-            SWAP_SERVER,
-            ROOT_PATH,
-            EXTENSIONS_PATH,
-            IP_FORWARDING,
-            NON_LOCAL_SOURCE_ROUTING,
-            POLICY_FILTER,
-            MAX_DGRAM_REASSEMBLY,
-            DEFAULT_IP_TTL,
-            PATH_MTU_AGING_TIMEOUT,
-            PATH_MTU_PLATEAU_TABLE,
-            INTERFACE_MTU,
-            ALL_SUBNETS_LOCAL,
-            BROADCAST_ADDRESS,
-            PERFORM_MASK_DISCOVERY,
-            MASK_SUPPLIER,
-            ROUTER_DISCOVERY,
-            ROUTER_SOLICITATION_ADDRESS,
-            STATIC_ROUTES,
-            TRAILER_ENCAPSULATION,
-            ARP_CACHE_TIMEOUT,
-            IEEE802_3_ENCAPSULATION,
-            DEFAULT_TCP_TTL,
-            TCP_KEEPALIVE_INTERVAL,
-            TCP_KEEPALIVE_GARBAGE,
-            NIS_DOMAIN,
-            NIS_SERVERS,
-            NTP_SERVERS,
-            VENDOR_ENCAPSULATED_OPTIONS,
-            NETBIOS_NAME_SERVERS,
-            NETBIOS_DD_SERVER,
-            NETBIOS_NODE_TYPE,
-            NETBIOS_SCOPE,
-            FONT_SERVERS,
-            X_DISPLAY_MANAGER,
-            DHCP_REQUESTED_ADDRESS,
-            DHCP_LEASE_TIME,
-            DHCP_OPTION_OVERLOAD,
-            DHCP_MESSAGE_TYPE,
-            DHCP_SERVER_IDENTIFIER,
-            DHCP_PARAMETER_REQUEST_LIST,
-            DHCP_MESSAGE,
-            DHCP_MAX_MESSAGE_SIZE,
-            DHCP_RENEWAL_TIME,
-            DHCP_REBINDING_TIME,
-            VENDOR_CLASS_IDENTIFIER,
-            DHCP_CLIENT_IDENTIFIER,
-            NWIP_DOMAIN_NAME,
-            NWIP_SUBOPTIONS,
-            USER_CLASS = 77,
-            FQDN = 81,
-            DHCP_AGENT_OPTIONS = 82,
-            SUBNET_SELECTION = 118,
-            AUTHENTICATE = 210,
-            END	= 255
-        };
-        
-        /**
-         * The DHCP option type.
-         */
-        typedef PDUOption<uint8_t, DHCP> option;
-        
-        /**
-         * The type used to store the DHCP options.
-         */
-        typedef std::list<option> options_type;
-        
-        /** 
-         * \brief Creates an instance of DHCP.
-         * 
-         * This sets the hwtype and hlen fields to match the ethernet
-         * type and length.
-         */
-        DHCP();
-        
-        /**
-         * \brief Constructs a DHCP object from a buffer.
-         * 
-         * If there is not enough size for a BootP header, or any of
-         * the TLV options contains an invalid size field, then a
-         * malformed_packet exception is thrown.
-         * 
-         * \param buffer The buffer from which this PDU will be constructed.
-         * \param total_sz The total size of the buffer.
-         */
-        DHCP(const uint8_t *buffer, uint32_t total_sz);
-        
+    /** 
+     * \brief DHCP options enum.
+     */
+    enum OptionTypes {
+        PAD,
+        SUBNET_MASK,
+        TIME_OFFSET,
+        ROUTERS,
+        TIME_SERVERS,
+        NAME_SERVERS,
+        DOMAIN_NAME_SERVERS,
+        LOG_SERVERS,
+        COOKIE_SERVERS,
+        LPR_SERVERS,
+        IMPRESS_SERVERS,
+        RESOURCE_LOCATION_SERVERS,
+        HOST_NAME,
+        BOOT_SIZE,
+        MERIT_DUMP,
+        DOMAIN_NAME,
+        SWAP_SERVER,
+        ROOT_PATH,
+        EXTENSIONS_PATH,
+        IP_FORWARDING,
+        NON_LOCAL_SOURCE_ROUTING,
+        POLICY_FILTER,
+        MAX_DGRAM_REASSEMBLY,
+        DEFAULT_IP_TTL,
+        PATH_MTU_AGING_TIMEOUT,
+        PATH_MTU_PLATEAU_TABLE,
+        INTERFACE_MTU,
+        ALL_SUBNETS_LOCAL,
+        BROADCAST_ADDRESS,
+        PERFORM_MASK_DISCOVERY,
+        MASK_SUPPLIER,
+        ROUTER_DISCOVERY,
+        ROUTER_SOLICITATION_ADDRESS,
+        STATIC_ROUTES,
+        TRAILER_ENCAPSULATION,
+        ARP_CACHE_TIMEOUT,
+        IEEE802_3_ENCAPSULATION,
+        DEFAULT_TCP_TTL,
+        TCP_KEEPALIVE_INTERVAL,
+        TCP_KEEPALIVE_GARBAGE,
+        NIS_DOMAIN,
+        NIS_SERVERS,
+        NTP_SERVERS,
+        VENDOR_ENCAPSULATED_OPTIONS,
+        NETBIOS_NAME_SERVERS,
+        NETBIOS_DD_SERVER,
+        NETBIOS_NODE_TYPE,
+        NETBIOS_SCOPE,
+        FONT_SERVERS,
+        X_DISPLAY_MANAGER,
+        DHCP_REQUESTED_ADDRESS,
+        DHCP_LEASE_TIME,
+        DHCP_OPTION_OVERLOAD,
+        DHCP_MESSAGE_TYPE,
+        DHCP_SERVER_IDENTIFIER,
+        DHCP_PARAMETER_REQUEST_LIST,
+        DHCP_MESSAGE,
+        DHCP_MAX_MESSAGE_SIZE,
+        DHCP_RENEWAL_TIME,
+        DHCP_REBINDING_TIME,
+        VENDOR_CLASS_IDENTIFIER,
+        DHCP_CLIENT_IDENTIFIER,
+        NWIP_DOMAIN_NAME,
+        NWIP_SUBOPTIONS,
+        USER_CLASS = 77,
+        FQDN = 81,
+        DHCP_AGENT_OPTIONS = 82,
+        SUBNET_SELECTION = 118,
+        AUTHENTICATE = 210,
+        END	= 255
+    };
+    
+    /**
+     * The DHCP option type.
+     */
+    typedef PDUOption<uint8_t, DHCP> option;
+    
+    /**
+     * The type used to store the DHCP options.
+     */
+    typedef std::list<option> options_type;
+    
+    /** 
+     * \brief Creates an instance of DHCP.
+     * 
+     * This sets the hwtype and hlen fields to match the ethernet
+     * type and length.
+     */
+    DHCP();
+    
+    /**
+     * \brief Constructs a DHCP object from a buffer.
+     * 
+     * If there is not enough size for a BootP header, or any of
+     * the TLV options contains an invalid size field, then a
+     * malformed_packet exception is thrown.
+     * 
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    DHCP(const uint8_t* buffer, uint32_t total_sz);
+    
+    /** 
+     * \brief Adds a new option to this DHCP PDU.
+     * \param opt The option to be added.
+     */
+    void add_option(const option& opt);
+    
+    #if TINS_IS_CXX11
         /** 
          * \brief Adds a new option to this DHCP PDU.
+         * 
+         * The option is move-constructed.
+         * 
          * \param opt The option to be added.
          */
-        void add_option(const option &opt);
-        
-        #if TINS_IS_CXX11
-            /** 
-             * \brief Adds a new option to this DHCP PDU.
-             * 
-             * The option is move-constructed.
-             * 
-             * \param opt The option to be added.
-             */
-            void add_option(option &&opt) {
-                internal_add_option(opt);
-                _options.push_back(std::move(opt));
-            }
-        #endif 
+        void add_option(option &&opt) {
+            internal_add_option(opt);
+            options_.push_back(std::move(opt));
+        }
+    #endif 
 
-        /**
-         * \brief Removes a DHCP option.
-         * 
-         * If there are multiple options of the given type, only the first one
-         * will be removed.
-         *
-         * \param type The type of the option to be removed.
-         * \return true if the option was removed, false otherwise.
-         */
-        bool remove_option(OptionTypes type);
+    /**
+     * \brief Removes a DHCP option.
+     * 
+     * If there are multiple options of the given type, only the first one
+     * will be removed.
+     *
+     * \param type The type of the option to be removed.
+     * \return true if the option was removed, false otherwise.
+     */
+    bool remove_option(OptionTypes type);
+
+    /**
+     * \brief Searchs for an option that matchs the given flag.
+     * \param opt_flag The flag to be searched.
+     * \return A pointer to the option, or 0 if it was not found.
+     */
+    const option* search_option(OptionTypes opt) const;
     
-        /**
-         * \brief Searchs for an option that matchs the given flag.
-         * \param opt_flag The flag to be searched.
-         * \return A pointer to the option, or 0 if it was not found.
-         */
-        const option *search_option(OptionTypes opt) const;
-        
-        /** 
-         * \brief Adds a type option to the option list.
-         * 
-         * The new option is appended at the end of the list.
-         * 
-         * \param type The type of this DHCP PDU.
-         */
-        void type(Flags type);
-        
-        /** 
-         * \brief Adds an end option to the option list.
-         * 
-         * The new option is appended at the end of the list.
-         * 
-         * The END option is not added automatically. You should explicitly
-         * add it at the end of the DHCP options for the PDU to be
-         * standard-compliant.
-         */
-        void end();
-        
-        /** 
-         * \brief Adds a server identifier option.
-         * 
-         * The new option is appended at the end of the list.
-         * 
-         * \param ip The server's IP address.
-         */
-        void server_identifier(ipaddress_type ip);
-        
-        /** 
-         * \brief Adds an IP address lease time option.
-         * 
-         * The new option is appended at the end of the list.
-         * 
-         * \param time The lease time.
-         */
-        void lease_time(uint32_t time);
-        
-        /** 
-         * \brief Adds a lease renewal time option.
-         * 
-         * The new option is appended at the end of the list.
-         * 
-         * \param time The lease renew time.
-         */
-        void renewal_time(uint32_t time);
-        
-        /** 
-         * \brief Adds a rebind time option.
-         * 
-         * The new option is appended at the end of the list.
-         * 
-         * \param time The lease rebind time.
-         */
-        void rebind_time(uint32_t time);
-        
-        /**
-         * \brief Adds a subnet mask option.
-         * 
-         * The new option is appended at the end of the list.
-         * 
-         * \param mask The subnet mask.
-         */
-        void subnet_mask(ipaddress_type mask);
-        
-        /** 
-         * \brief Adds a routers option.
-         * 
-         * The new option is appended at the end of the list.
-         * 
-         * \param routers A list of ip addresses.
-         */
-        void routers(const std::vector<ipaddress_type> &routers);
-        
-        /** 
-         * \brief Adds a domain name servers option.
-         * 
-         * The new option is appended at the end of the list.
-         * 
-         * \param dns A list of ip addresses.
-         */
-        void domain_name_servers(const std::vector<ipaddress_type> &dns);
-        
-        /** 
-         * \brief Adds a broadcast address option.
-         * 
-         * The new option is appended at the end of the list.
-         * 
-         * \param addr The broadcast address.
-         */
-        void broadcast(ipaddress_type addr);
-        
-        /** 
-         * \brief Adds a requested address option.
-         * 
-         * The new option is appended at the end of the list.
-         * 
-         * \param addr The requested address.
-         */
-        void requested_ip(ipaddress_type addr);
-        
-        /** 
-         * \brief Adds a domain name option.
-         * 
-         * The new option is appended at the end of the list.
-         * 
-         * \param name The domain name.
-         */
-        void domain_name(const std::string &name);
+    /** 
+     * \brief Adds a type option to the option list.
+     * 
+     * The new option is appended at the end of the list.
+     * 
+     * \param type The type of this DHCP PDU.
+     */
+    void type(Flags type);
+    
+    /** 
+     * \brief Adds an end option to the option list.
+     * 
+     * The new option is appended at the end of the list.
+     * 
+     * The END option is not added automatically. You should explicitly
+     * add it at the end of the DHCP options for the PDU to be
+     * standard-compliant.
+     */
+    void end();
+    
+    /** 
+     * \brief Adds a server identifier option.
+     * 
+     * The new option is appended at the end of the list.
+     * 
+     * \param ip The server's IP address.
+     */
+    void server_identifier(ipaddress_type ip);
+    
+    /** 
+     * \brief Adds an IP address lease time option.
+     * 
+     * The new option is appended at the end of the list.
+     * 
+     * \param time The lease time.
+     */
+    void lease_time(uint32_t time);
+    
+    /** 
+     * \brief Adds a lease renewal time option.
+     * 
+     * The new option is appended at the end of the list.
+     * 
+     * \param time The lease renew time.
+     */
+    void renewal_time(uint32_t time);
+    
+    /** 
+     * \brief Adds a rebind time option.
+     * 
+     * The new option is appended at the end of the list.
+     * 
+     * \param time The lease rebind time.
+     */
+    void rebind_time(uint32_t time);
+    
+    /**
+     * \brief Adds a subnet mask option.
+     * 
+     * The new option is appended at the end of the list.
+     * 
+     * \param mask The subnet mask.
+     */
+    void subnet_mask(ipaddress_type mask);
+    
+    /** 
+     * \brief Adds a routers option.
+     * 
+     * The new option is appended at the end of the list.
+     * 
+     * \param routers A list of ip addresses.
+     */
+    void routers(const std::vector<ipaddress_type>& routers);
+    
+    /** 
+     * \brief Adds a domain name servers option.
+     * 
+     * The new option is appended at the end of the list.
+     * 
+     * \param dns A list of ip addresses.
+     */
+    void domain_name_servers(const std::vector<ipaddress_type>& dns);
+    
+    /** 
+     * \brief Adds a broadcast address option.
+     * 
+     * The new option is appended at the end of the list.
+     * 
+     * \param addr The broadcast address.
+     */
+    void broadcast(ipaddress_type addr);
+    
+    /** 
+     * \brief Adds a requested address option.
+     * 
+     * The new option is appended at the end of the list.
+     * 
+     * \param addr The requested address.
+     */
+    void requested_ip(ipaddress_type addr);
+    
+    /** 
+     * \brief Adds a domain name option.
+     * 
+     * The new option is appended at the end of the list.
+     * 
+     * \param name The domain name.
+     */
+    void domain_name(const std::string& name);
 
-        /** 
-         * \brief Adds a hostname option.
-         * 
-         * The new option is appended at the end of the list.
-         * 
-         * \param name The hostname.
-         */
-        void hostname(const std::string &name);
-        
-        // Option getters
-        
-        /**
-         * \brief Searchs for a type option.
-         * 
-         * If the option is not found, an option_not_found exception
-         * is thrown.
-         * 
-         * \return uint8_t containing the type option.
-         */
-        uint8_t type() const;
-        
-        /**
-         * \brief Searchs for a server identifier option.
-         * 
-         * If the option is not found, an option_not_found exception
-         * is thrown.
-         * 
-         * \return ipaddress_type Containing the server identifier.
-         */
-        ipaddress_type server_identifier() const;
-        
-        /**
-         * \brief Searchs for a lease time option.
-         * 
-         * If the option is not found, an option_not_found exception
-         * is thrown.
-         * 
-         * \return uint32_t Containing the lease time.
-         */
-        uint32_t lease_time() const;
-                
-        /**
-         * \brief Searchs for a lease renewal time option.
-         * 
-         * If the option is not found, an option_not_found exception
-         * is thrown.
-         * 
-         * \return uint32_t Containing the renewal time.
-         */
-        uint32_t renewal_time() const;
-        
-        /**
-         * \brief Searchs for a rebind time option.
-         * 
-         * If the option is not found, an option_not_found exception
-         * is thrown.
-         * 
-         * \return uint32_t Containing the rebind time.
-         */
-        uint32_t rebind_time() const;
-        
-        /**
-         * \brief Searchs for a subnet mask option.
-         * 
-         * If the option is not found, an option_not_found exception
-         * is thrown.
-         * 
-         * \return ipaddress_type Containing the subnet mask.
-         */
-        ipaddress_type subnet_mask() const;
-        
-        /**
-         * \brief Searchs for a routers option.
-         * 
-         * If the option is not found, an option_not_found exception
-         * is thrown.
-         * 
-         * \return std::vector<ipaddress_type> Containing the routers 
-         * option data.
-         */
-        std::vector<ipaddress_type> routers() const;
-        
-        /**
-         * \brief Searchs for a dns option.
-         * 
-         * If the option is not found, an option_not_found exception
-         * is thrown.
-         * 
-         * \return std::list<ipaddress_type> Contanining the DNS servers
-         * provided.
-         */
-        std::vector<ipaddress_type> domain_name_servers() const; 
-        
-        /**
-         * \brief Searchs for a broadcast option.
-         * 
-         * If the option is not found, an option_not_found exception
-         * is thrown.
-         * 
-         * \return ipaddress_type Containing the broadcast address.
-         */
-        ipaddress_type broadcast() const;
-        
-        /**
-         * \brief Searchs for a requested option.
-         * 
-         * If the option is not found, an option_not_found exception
-         * is thrown.
-         * 
-         * \return ipaddress_type Containing the requested IP address.
-         */
-        ipaddress_type requested_ip() const;
-        
-        /**
-         * \brief Searchs for a domain name option.
-         * 
-         * If the option is not found, an option_not_found exception
-         * is thrown.
-         * 
-         * \return std::string Containing the domain name.
-         */
-        std::string domain_name() const;
+    /** 
+     * \brief Adds a hostname option.
+     * 
+     * The new option is appended at the end of the list.
+     * 
+     * \param name The hostname.
+     */
+    void hostname(const std::string& name);
+    
+    // Option getters
+    
+    /**
+     * \brief Searchs for a type option.
+     * 
+     * If the option is not found, an option_not_found exception
+     * is thrown.
+     * 
+     * \return uint8_t containing the type option.
+     */
+    uint8_t type() const;
+    
+    /**
+     * \brief Searchs for a server identifier option.
+     * 
+     * If the option is not found, an option_not_found exception
+     * is thrown.
+     * 
+     * \return ipaddress_type Containing the server identifier.
+     */
+    ipaddress_type server_identifier() const;
+    
+    /**
+     * \brief Searchs for a lease time option.
+     * 
+     * If the option is not found, an option_not_found exception
+     * is thrown.
+     * 
+     * \return uint32_t Containing the lease time.
+     */
+    uint32_t lease_time() const;
+            
+    /**
+     * \brief Searchs for a lease renewal time option.
+     * 
+     * If the option is not found, an option_not_found exception
+     * is thrown.
+     * 
+     * \return uint32_t Containing the renewal time.
+     */
+    uint32_t renewal_time() const;
+    
+    /**
+     * \brief Searchs for a rebind time option.
+     * 
+     * If the option is not found, an option_not_found exception
+     * is thrown.
+     * 
+     * \return uint32_t Containing the rebind time.
+     */
+    uint32_t rebind_time() const;
+    
+    /**
+     * \brief Searchs for a subnet mask option.
+     * 
+     * If the option is not found, an option_not_found exception
+     * is thrown.
+     * 
+     * \return ipaddress_type Containing the subnet mask.
+     */
+    ipaddress_type subnet_mask() const;
+    
+    /**
+     * \brief Searchs for a routers option.
+     * 
+     * If the option is not found, an option_not_found exception
+     * is thrown.
+     * 
+     * \return std::vector<ipaddress_type> Containing the routers 
+     * option data.
+     */
+    std::vector<ipaddress_type> routers() const;
+    
+    /**
+     * \brief Searchs for a dns option.
+     * 
+     * If the option is not found, an option_not_found exception
+     * is thrown.
+     * 
+     * \return std::list<ipaddress_type> Contanining the DNS servers
+     * provided.
+     */
+    std::vector<ipaddress_type> domain_name_servers() const; 
+    
+    /**
+     * \brief Searchs for a broadcast option.
+     * 
+     * If the option is not found, an option_not_found exception
+     * is thrown.
+     * 
+     * \return ipaddress_type Containing the broadcast address.
+     */
+    ipaddress_type broadcast() const;
+    
+    /**
+     * \brief Searchs for a requested option.
+     * 
+     * If the option is not found, an option_not_found exception
+     * is thrown.
+     * 
+     * \return ipaddress_type Containing the requested IP address.
+     */
+    ipaddress_type requested_ip() const;
+    
+    /**
+     * \brief Searchs for a domain name option.
+     * 
+     * If the option is not found, an option_not_found exception
+     * is thrown.
+     * 
+     * \return std::string Containing the domain name.
+     */
+    std::string domain_name() const;
 
-        /**
-         * \brief Searchs for a hostname option.
-         * 
-         * If the option is not found, an option_not_found exception
-         * is thrown.
-         * 
-         * \return std::string Containing the hostname.
-         */
-        std::string hostname() const;
-        
-        /** 
-         * \brief Getter for the options list.
-         * \return The option list.
-         */
-        const options_type options() const { return _options; }
-        
-        /**
-         * \brief Getter for the PDU's type.
-         * \sa PDU::pdu_type
-         */
-        PDUType pdu_type() const { return pdu_flag; }
-        
-        /** 
-         * \brief Getter for the header size.
-         * \return Returns the BOOTP header size.
-         * \sa PDU::header_size
-         */ 
-        uint32_t header_size() const;
-        
-        /**
-         * \sa PDU::clone
-         */
-        DHCP *clone() const {
-            return new DHCP(*this);
+    /**
+     * \brief Searchs for a hostname option.
+     * 
+     * If the option is not found, an option_not_found exception
+     * is thrown.
+     * 
+     * \return std::string Containing the hostname.
+     */
+    std::string hostname() const;
+    
+    /** 
+     * \brief Getter for the options list.
+     * \return The option list.
+     */
+    const options_type options() const { return options_; }
+    
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const { return pdu_flag; }
+    
+    /** 
+     * \brief Getter for the header size.
+     * \return Returns the BOOTP header size.
+     * \sa PDU::header_size
+     */ 
+    uint32_t header_size() const;
+    
+    /**
+     * \sa PDU::clone
+     */
+    DHCP* clone() const {
+        return new DHCP(*this);
+    }
+private:
+    static const uint32_t MAX_DHCP_SIZE;
+  
+    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
+
+    template<class T> 
+    T search_and_convert(OptionTypes opt) const {
+        const option* option = search_option(opt);
+        if (!option) {
+            throw option_not_found();
         }
-    private:
-        static const uint32_t MAX_DHCP_SIZE;
-      
-        void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
+        return option->to<T>();
+    }
+    
+    void internal_add_option(const option& opt);
+    serialization_type serialize_list(const std::vector<ipaddress_type>& ip_list);
+    options_type::const_iterator search_option_iterator(OptionTypes opt) const;
+    options_type::iterator search_option_iterator(OptionTypes opt);
+    
+    options_type options_;
+    uint32_t size_;
+};
 
-        template<class T> 
-        T search_and_convert(OptionTypes opt) const {
-            const option *option = search_option(opt);
-            if(!option)
-                throw option_not_found();
-            return option->to<T>();
-        }
-        
-        void internal_add_option(const option &opt);
-        serialization_type serialize_list(const std::vector<ipaddress_type> &ip_list);
-        options_type::const_iterator search_option_iterator(OptionTypes opt) const;
-        options_type::iterator search_option_iterator(OptionTypes opt);
-        
-        options_type _options;
-        uint32_t _size;
-    };
-}
+} // Tins
 
 #endif // TINS_DHCP_H
diff --git a/include/tins/dhcpv6.h b/include/tins/dhcpv6.h
index 327b8ab..7633292 100644
--- a/include/tins/dhcpv6.h
+++ b/include/tins/dhcpv6.h
@@ -41,7 +41,9 @@
 
 namespace Tins {
 namespace Memory  {
+
 class OutputMemoryStream;
+
 } // Memory
 
 /**
@@ -187,7 +189,7 @@ public:
           const options_type& options = options_type())
         : id(id), t1(t1), t2(t2), options(options) {}
 
-        static ia_na_type from_option(const option &opt);
+        static ia_na_type from_option(const option& opt);
     };
     
     /**
@@ -204,7 +206,7 @@ public:
           const options_type& options = options_type())
         : id(id), options(options) {}
 
-        static ia_ta_type from_option(const option &opt);
+        static ia_ta_type from_option(const option& opt);
     };
 
     /**
@@ -223,7 +225,7 @@ public:
         : address(address), preferred_lifetime(preferred_lifetime), 
           valid_lifetime(valid_lifetime), options(options) {}
 
-        static ia_address_type from_option(const option &opt);
+        static ia_address_type from_option(const option& opt);
     };
     
     /**
@@ -238,11 +240,11 @@ public:
         
         authentication_type(uint8_t protocol = 0, uint8_t algorithm = 0,
           uint8_t rdm = 0, uint64_t replay_detection = 0,
-          const auth_info_type &auth_info = auth_info_type())
+          const auth_info_type& auth_info = auth_info_type())
         : protocol(protocol), algorithm(algorithm), rdm(rdm),
         replay_detection(replay_detection), auth_info(auth_info) {}
 
-        static authentication_type from_option(const option &opt);
+        static authentication_type from_option(const option& opt);
     };
     
     /**
@@ -252,10 +254,10 @@ public:
         uint16_t code;
         std::string message;
         
-        status_code_type(uint16_t code = 0, const std::string &message = "")
+        status_code_type(uint16_t code = 0, const std::string& message = "")
         : code(code), message(message) { }
 
-        static status_code_type from_option(const option &opt);
+        static status_code_type from_option(const option& opt);
     };
     
     /**
@@ -268,10 +270,10 @@ public:
         data_type data;
         
         vendor_info_type(uint32_t enterprise_number = 0, 
-          const data_type &data = data_type())
+          const data_type& data = data_type())
         : enterprise_number(enterprise_number), data(data) { }
 
-        static vendor_info_type from_option(const option &opt);
+        static vendor_info_type from_option(const option& opt);
     };
     
     
@@ -288,13 +290,10 @@ public:
         typedef std::vector<class_option_data_type> data_type;
         data_type data;
 
-        user_class_type(const data_type &data = data_type())
-        : data(data)
-        {
+        user_class_type(const data_type& data = data_type())
+        : data(data) { }
 
-        }
-
-        static user_class_type from_option(const option &opt);
+        static user_class_type from_option(const option& opt);
     };
     
     /**
@@ -307,11 +306,11 @@ public:
         class_data_type vendor_class_data;
         
         vendor_class_type(uint32_t enterprise_number = 0, 
-          const class_data_type &vendor_class_data = class_data_type())
+          const class_data_type& vendor_class_data = class_data_type())
         : enterprise_number(enterprise_number), 
         vendor_class_data(vendor_class_data) { }
 
-        static vendor_class_type from_option(const option &opt);
+        static vendor_class_type from_option(const option& opt);
     };
     
     /**
@@ -327,12 +326,12 @@ public:
         lladdress_type lladdress;
         
         duid_llt(uint16_t hw_type = 0, uint32_t time = 0,
-          const lladdress_type &lladdress = lladdress_type())
+          const lladdress_type& lladdress = lladdress_type())
         : hw_type(hw_type), time(time), lladdress(lladdress) {}
         
         PDU::serialization_type serialize() const;
         
-        static duid_llt from_bytes(const uint8_t *buffer, uint32_t total_sz);
+        static duid_llt from_bytes(const uint8_t* buffer, uint32_t total_sz);
     };
     
     /**
@@ -346,12 +345,12 @@ public:
         identifier_type identifier;
         
         duid_en(uint32_t enterprise_number = 0,
-          const identifier_type &identifier = identifier_type())
+          const identifier_type& identifier = identifier_type())
         : enterprise_number(enterprise_number), identifier(identifier) {}
         
         PDU::serialization_type serialize() const;
         
-        static duid_en from_bytes(const uint8_t *buffer, uint32_t total_sz);
+        static duid_en from_bytes(const uint8_t* buffer, uint32_t total_sz);
     };
     
     /**
@@ -365,12 +364,12 @@ public:
         lladdress_type lladdress;
         
         duid_ll(uint16_t hw_type = 0, 
-          const lladdress_type &lladdress = lladdress_type())
+          const lladdress_type& lladdress = lladdress_type())
         : hw_type(hw_type), lladdress(lladdress) {}
         
         PDU::serialization_type serialize() const;
         
-        static duid_ll from_bytes(const uint8_t *buffer, uint32_t total_sz);
+        static duid_ll from_bytes(const uint8_t* buffer, uint32_t total_sz);
     };
     
     /**
@@ -383,19 +382,19 @@ public:
         uint16_t id;
         data_type data;
         
-        duid_type(uint16_t id = 0, const data_type &data = data_type())
+        duid_type(uint16_t id = 0, const data_type& data = data_type())
         : id(id), data(data) {}
         
-        duid_type(const duid_llt &identifier)
+        duid_type(const duid_llt& identifier)
         : id(duid_llt::duid_id), data(identifier.serialize()) {}
         
-        duid_type(const duid_en &identifier)
+        duid_type(const duid_en& identifier)
         : id(duid_en::duid_id), data(identifier.serialize()) {}
         
-        duid_type(const duid_ll &identifier)
+        duid_type(const duid_ll& identifier)
         : id(duid_en::duid_id), data(identifier.serialize()) {}
 
-        static duid_type from_option(const option &opt);
+        static duid_type from_option(const option& opt);
     };
         
     /**
@@ -428,7 +427,7 @@ public:
      * \param buffer The buffer from which this PDU will be constructed.
      * \param total_sz The total size of the buffer.
      */
-    DHCPv6(const uint8_t *buffer, uint32_t total_sz);
+    DHCPv6(const uint8_t* buffer, uint32_t total_sz);
 
     // Getters
     
@@ -438,7 +437,7 @@ public:
      * \return The stored message type field.
      */
     MessageType msg_type() const { 
-        return static_cast<MessageType>(header_data[0]); 
+        return static_cast<MessageType>(header_data_[0]); 
     }
     
     /**
@@ -446,7 +445,9 @@ public:
      *
      * \return The stored hop count field.
      */
-    uint8_t hop_count() const { return header_data[1]; }
+    uint8_t hop_count() const {
+        return header_data_[1];
+    }
     
     /**
      * \brief Getter for the transaction id field.
@@ -454,7 +455,7 @@ public:
      * \return The stored transaction id field.
      */
     small_uint<24> transaction_id() const { 
-        return (header_data[1] << 16) | (header_data[2] << 8) | header_data[3];
+        return (header_data_[1] << 16) | (header_data_[2] << 8) | header_data_[3];
     }
 
     /**
@@ -462,21 +463,27 @@ public:
      *
      * \return The stored peer address field.
      */
-    const ipaddress_type &peer_address() const { return peer_addr; }
+    const ipaddress_type& peer_address() const {
+        return peer_addr_;
+    }
     
     /**
      * \brief Getter for the link address field.
      *
      * \return The stored link address field.
      */
-    const ipaddress_type &link_address() const { return link_addr; }
+    const ipaddress_type& link_address() const {
+        return link_addr_;
+    }
     
     /**
      * \brief Getter for the DHCPv6 options.
      *
      * \return The stored options.
      */
-    const options_type &options() const { return options_; }
+    const options_type& options() const {
+        return options_;
+    }
 
     // Setters
     /**
@@ -505,14 +512,14 @@ public:
      *
      * \param count The new peer address.
      */
-    void peer_address(const ipaddress_type &addr);
+    void peer_address(const ipaddress_type& addr);
     
     /**
      * \brief Setter for the link address field.
      *
      * \param count The new link address.
      */
-    void link_address(const ipaddress_type &addr);
+    void link_address(const ipaddress_type& addr);
     
     // Option getters
     
@@ -678,7 +685,7 @@ public:
      * 
      * \param value The new IA_NA option data.
      */
-    void ia_na(const ia_na_type &value);
+    void ia_na(const ia_na_type& value);
     
     /**
      * \brief Setter for the Identity Association for Temporary
@@ -686,21 +693,21 @@ public:
      * 
      * \param value The new IA_TA option data.
      */
-    void ia_ta(const ia_ta_type &value);
+    void ia_ta(const ia_ta_type& value);
     
     /**
      * \brief Setter for the Identity Association Address option.
      * 
      * \param value The new IA Address option data.
      */
-    void ia_address(const ia_address_type &value);
+    void ia_address(const ia_address_type& value);
     
     /**
      * \brief Setter for the Identity Association Address option.
      * 
      * \param value The new Option Request option data.
      */
-    void option_request(const option_request_type &value);
+    void option_request(const option_request_type& value);
     
     /**
      * \brief Setter for the Preference option.
@@ -721,28 +728,28 @@ public:
      * 
      * \param value The new Relay Message option data.
      */
-    void relay_message(const relay_msg_type &value);
+    void relay_message(const relay_msg_type& value);
     
     /**
      * \brief Setter for the Authentication option.
      * 
      * \param value The new Authentication option data.
      */
-    void authentication(const authentication_type &value);
+    void authentication(const authentication_type& value);
     
     /**
      * \brief Setter for the Server Unicast option.
      * 
      * \param value The new Server Unicast option data.
      */
-    void server_unicast(const ipaddress_type &value);
+    void server_unicast(const ipaddress_type& value);
     
     /**
      * \brief Setter for the Status Code option.
      * 
      * \param value The new Status Code option data.
      */
-    void status_code(const status_code_type &value);
+    void status_code(const status_code_type& value);
     
     /**
      * \brief Adds a Rapid Commit option.
@@ -754,28 +761,28 @@ public:
      * 
      * \param value The new User Class option data.
      */
-    void user_class(const user_class_type &value);
+    void user_class(const user_class_type& value);
     
     /**
      * \brief Setter for the Vendor Class option.
      * 
      * \param value The new Vendor Class option data.
      */
-    void vendor_class(const vendor_class_type &value);
+    void vendor_class(const vendor_class_type& value);
     
     /**
      * \brief Setter for the Vendor-specific Information option.
      * 
      * \param value The new Vendor-specific Information option data.
      */
-    void vendor_info(const vendor_info_type &value);
+    void vendor_info(const vendor_info_type& value);
     
     /**
      * \brief Setter for the Interface ID option.
      * 
      * \param value The new Interface ID option data.
      */
-    void interface_id(const interface_id_type &value);
+    void interface_id(const interface_id_type& value);
     
     /**
      * \brief Setter for the Reconfigure Message option.
@@ -794,14 +801,14 @@ public:
      * 
      * \param value The new Client Identifier option data.
      */
-    void client_id(const duid_type &value);
+    void client_id(const duid_type& value);
     
     /**
      * \brief Setter for the Server Identifier option.
      * 
      * \param value The new Server Identifier option data.
      */
-    void server_id(const duid_type &value);
+    void server_id(const duid_type& value);
     
     // Other stuff
     
@@ -818,7 +825,7 @@ public:
      * 
      * \param opt The option to be added
      */
-    void add_option(const option &opt);
+    void add_option(const option& opt);
     
     /**
      * \brief Removes a DHCPv6 option.
@@ -840,7 +847,7 @@ public:
      * 
      * \param type The option identifier to be searched.
      */
-    const option *search_option(OptionTypes type) const;
+    const option* search_option(OptionTypes type) const;
 
     // PDU stuff
     
@@ -858,56 +865,62 @@ public:
      * \param ptr The pointer to the buffer.
      * \param total_sz The size of the buffer.
      */
-    bool matches_response(const uint8_t *ptr, uint32_t total_sz) const;
+    bool matches_response(const uint8_t* ptr, uint32_t total_sz) const;
     
     /**
      * \brief Getter for the PDU's type.
      * \sa PDU::pdu_type
      */
-    PDUType pdu_type() const { return pdu_flag; }
+    PDUType pdu_type() const { 
+        return pdu_flag;
+    }
     
     /**
      * \sa PDU::clone
      */
-    DHCPv6 *clone() const {
+    DHCPv6* clone() const {
         return new DHCPv6(*this);
     }
 private:
-    void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *);
-    void write_option(const option &option, Memory::OutputMemoryStream& stream) const;
+    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU *);
+    void write_option(const option& option, Memory::OutputMemoryStream& stream) const;
     options_type::const_iterator search_option_iterator(OptionTypes type) const;
     options_type::iterator search_option_iterator(OptionTypes type);
     
     template<template <typename> class Functor>
-    const option *safe_search_option(OptionTypes opt, uint32_t size) const {
-        const option *option = search_option(opt);
-        if(!option || Functor<uint32_t>()(option->data_size(), size))
+    const option* safe_search_option(OptionTypes opt, uint32_t size) const {
+        const option* option = search_option(opt);
+        if (!option || Functor<uint32_t>()(option->data_size(), size)) {
             throw option_not_found();
+        }
         return option;
     }
 
     template<typename T>
     T search_and_convert(OptionTypes opt) const {
-        const option *option = search_option(opt);
-        if(!option)
+        const option* option = search_option(opt);
+        if (!option) {
             throw option_not_found();
+        }
         return option->to<T>();
     }
 
-    uint8_t header_data[4];
-    uint32_t options_size;
-    ipaddress_type link_addr, peer_addr;
+    uint8_t header_data_[4];
+    uint32_t options_size_;
+    ipaddress_type link_addr_, peer_addr_;
     options_type options_;
 };   
 
 namespace Internals {
+
 template<typename InputIterator>
-void class_option_data2option(InputIterator start, InputIterator end, 
-  std::vector<uint8_t>& buffer, size_t start_index = 0) 
-{
+void class_option_data2option(InputIterator start,
+                              InputIterator end, 
+                              std::vector<uint8_t>& buffer,
+                              size_t start_index = 0) {
     size_t index = start_index;
     uint16_t uint16_t_buffer;
-    while(start != end) {
+    while (start != end) {
         buffer.resize(buffer.size() + sizeof(uint16_t) + start->size());
         uint16_t_buffer = Endian::host_to_be(static_cast<uint16_t>(start->size()));
         std::memcpy(&buffer[index], &uint16_t_buffer, sizeof(uint16_t));
@@ -920,28 +933,30 @@ void class_option_data2option(InputIterator start, InputIterator end,
 }
 
 template<typename OutputType>
-OutputType option2class_option_data(const uint8_t *ptr, uint32_t total_sz)
-{
+OutputType option2class_option_data(const uint8_t* ptr, uint32_t total_sz) {
     typedef typename OutputType::value_type value_type;
     OutputType output;
     size_t index = 0;
-    while(index + 2 < total_sz) {
+    while (index + 2 < total_sz) {
         uint16_t size;
         std::memcpy(&size, ptr + index, sizeof(uint16_t));
         size = Endian::be_to_host(size);
         index += sizeof(uint16_t);
-        if(index + size > total_sz)
+        if (index + size > total_sz) {
             throw option_not_found();
+        }
         output.push_back(
             value_type(ptr + index, ptr + index + size)
         );
         index += size;
     }
-    if(index != total_sz)
+    if (index != total_sz) {
         throw malformed_option();
+    }
     return output;
 }
-} 
-}
+
+} // Internals 
+} // Tins
 
 #endif // TINS_DHCPV6_H
diff --git a/include/tins/dns.h b/include/tins/dns.h
index 0db2074..4598e15 100644
--- a/include/tins/dns.h
+++ b/include/tins/dns.h
@@ -41,653 +41,692 @@
 #include "endianness.h"
 
 namespace Tins {
-    class IPv4Address;
-    class IPv6Address;
+namespace Memory {
+
+class InputMemoryStream;
+
+} // Memory
+
+class IPv4Address;
+class IPv6Address;
+
+/**
+ * \class DNS
+ * \brief Represents a DNS PDU.
+ *
+ * This class represents the DNS PDU, and allows easy access
+ * to queries and answer records. 
+ *
+ * The DNS PDU is not parsed automatically while sniffing, so you will
+ * have to parse it manually from an UDP packet's payload, for example:
+ *
+ * \code
+ * // Assume we get an udp packet from somewhere.
+ * UDP udp = get_udp_packet();
+ *
+ * // Now:
+ * // 1 - Get the RawPDU layer (contains the payload).
+ * // 2 - Construct a DNS object over its contents.
+ * DNS dns = udp.rfind_pdu<RawPDU>().to<DNS>();
+ *
+ * // Now use the DNS object!
+ * for(const auto& query : dns.queries()) {
+ *     // Process a query
+ * }
+ * \endcode
+ */
+class TINS_API DNS : public PDU {
+public:
+    /**
+     * \brief This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::DNS;
     
     /**
-     * \class DNS
-     * \brief Represents a DNS PDU.
-     *
-     * This class represents the DNS PDU, and allows easy access
-     * to queries and answer records. 
-     *
-     * The DNS PDU is not parsed automatically while sniffing, so you will
-     * have to parse it manually from an UDP packet's payload, for example:
-     *
-     * \code
-     * // Assume we get an udp packet from somewhere.
-     * UDP udp = get_udp_packet();
-     *
-     * // Now:
-     * // 1 - Get the RawPDU layer (contains the payload).
-     * // 2 - Construct a DNS object over its contents.
-     * DNS dns = udp.rfind_pdu<RawPDU>().to<DNS>();
-     *
-     * // Now use the DNS object!
-     * for(const auto& query : dns.queries()) {
-     *     // Process a query
-     * }
-     * \endcode
+     * The DNS type.
      */
-    class TINS_API DNS : public PDU {
+    enum QRType {
+        QUERY = 0,
+        RESPONSE = 1
+    };
+    
+    /**
+     * \brief Query types enum.
+     */
+    enum QueryType {
+        A = 1,
+        NS,
+        MD,
+        MF,
+        CNAME,
+        SOA,
+        MB,
+        MG,
+        MR,
+        NULL_R,
+        WKS,
+        PTR,
+        HINFO,
+        MINFO,
+        MX,
+        TXT,
+        RP,
+        AFSDB,
+        X25,
+        ISDN,
+        RT,
+        NSAP,
+        NSAP_PTR,
+        SIG,
+        KEY,
+        PX,
+        GPOS,
+        AAAA,
+        LOC,
+        NXT,
+        EID,
+        NIMLOC,
+        SRV,
+        ATMA,
+        NAPTR,
+        KX,
+        CERT,
+        A6,
+        DNAM,
+        SINK,
+        OPT,
+        APL,
+        DS,
+        SSHFP,
+        IPSECKEY,
+        RRSIG,
+        NSEC,
+        DNSKEY,
+        DHCID,
+        NSEC3,
+        NSEC3PARAM
+    };
+    
+    enum QueryClass {
+        IN = 1,
+        CH = 3,
+        HS = 4,
+        ANY = 255
+    };
+    
+    /**
+     * \brief Struct that represent DNS queries.
+     */
+    class Query {
     public:
         /**
-         * \brief This PDU's flag.
-         */
-        static const PDU::PDUType pdu_flag = PDU::DNS;
-        
-        /**
-         * The DNS type.
-         */
-        enum QRType {
-            QUERY = 0,
-            RESPONSE = 1
-        };
-        
-        /**
-         * \brief Query types enum.
-         */
-        enum QueryType {
-            A = 1,
-            NS,
-            MD,
-            MF,
-            CNAME,
-            SOA,
-            MB,
-            MG,
-            MR,
-            NULL_R,
-            WKS,
-            PTR,
-            HINFO,
-            MINFO,
-            MX,
-            TXT,
-            RP,
-            AFSDB,
-            X25,
-            ISDN,
-            RT,
-            NSAP,
-            NSAP_PTR,
-            SIG,
-            KEY,
-            PX,
-            GPOS,
-            AAAA,
-            LOC,
-            NXT,
-            EID,
-            NIMLOC,
-            SRV,
-            ATMA,
-            NAPTR,
-            KX,
-            CERT,
-            A6,
-            DNAM,
-            SINK,
-            OPT,
-            APL,
-            DS,
-            SSHFP,
-            IPSECKEY,
-            RRSIG,
-            NSEC,
-            DNSKEY,
-            DHCID,
-            NSEC3,
-            NSEC3PARAM
-        };
-        
-        enum QueryClass {
-            IN = 1,
-            CH = 3,
-            HS = 4,
-            ANY = 255
-        };
-        
-        /**
-         * \brief Struct that represent DNS queries.
-         */
-        class Query {
-        public:
-            /**
-             * \brief Constructs a DNS query.
-             * 
-             * \param nm The name of the domain being resolved.
-             * \param tp The query type.
-             * \param cl The query class.
-             */
-            Query(const std::string &nm, QueryType tp, QueryClass cl) 
-            : name_(nm), type_(tp), qclass_(cl) {}
-            
-            /**
-             * \brief Default constructs this Query.
-             */
-            Query() : type_(), qclass_() {}
-            
-            /**
-             * \brief Setter for the name field.
-             * 
-             * \param nm The name to be set.
-             */
-            void dname(const std::string &nm) {
-                name_ = nm;
-            }
-            
-            /**
-             * \brief Setter for the query type field.
-             * 
-             * \param tp The query type to be set.
-             */
-            void type(QueryType tp) {
-                type_ = tp;
-            }
-            
-            /**
-             * \brief Setter for the query class field.
-             * 
-             * \param cl The query class to be set.
-             */
-            void query_class(QueryClass cl) {
-                qclass_ = cl;
-            }
-            
-            /**
-             * \brief Getter for the name field.
-             */
-            const std::string &dname() const { return name_; }
-            
-            /**
-             * \brief Getter for the query type field.
-             */
-            QueryType type() const { return type_; }
-            
-            /**
-             * \brief Getter for the query class field.
-             */
-            QueryClass query_class() const { return qclass_; }
-        private:
-            std::string name_;
-            QueryType type_;
-            QueryClass qclass_;
-        };
-        
-        /**
-         * \brief Struct that represent DNS resource records.
-         */
-        class Resource {
-        public:
-            /**
-             * Constructs a Resource object.
-             *
-             * \param dname The domain name for which this records 
-             * provides an answer.
-             * \param data The resource's payload.
-             * \param type The type of this record.
-             * \param rclass The class of this record.
-             * \param ttl The time-to-live of this record.
-             */
-            Resource(const std::string &dname, const std::string &data, 
-              uint16_t type, uint16_t rclass, uint32_t ttl) 
-            : dname_(dname), data_(data), type_(type), qclass_(rclass), ttl_(ttl) {}
-            
-            Resource() : type_(), qclass_(), ttl_() {}
-            
-            /**
-             * \brief Getter for the domain name field.
-             * 
-             * This returns the domain name for which this record 
-             * provides an answer.
-             */
-            const std::string &dname() const { return dname_; }
-            
-            /**
-             * Getter for the data field. 
-             */
-            const std::string &data() const { return data_; }
-            
-            /**
-             * Getter for the query type field.
-             */
-            uint16_t type() const { return type_; }
-            
-            /**
-             * Getter for the query class field.
-             */
-            uint16_t query_class() const { return qclass_; }
-            
-            /**
-             * Getter for the type field.
-             */
-            uint32_t ttl() const { return ttl_; }
-
-            /**
-             * Setter for the domain name field.
-             */
-            void dname(const std::string &data) {
-                dname_ = data;
-            }
-
-            /**
-             * \brief Setter for the data field.
-             *
-             * The data will be encoded properly by the DNS class before
-             * being added to this packet. That means that if the type is
-             * A or AAAA, it will be properly encoded as an IPv4 or
-             * IPv6 address. 
-             * 
-             * The same happens for records that contain domain names,
-             * such as NS or CNAME. This data will be encoded using 
-             * DNS domain name encoding.
-             */
-            void data(const std::string &data) {
-                data_ = data;
-            }
-
-            /**
-             * Setter for the type field.
-             */
-            void type(uint16_t data) {
-                type_ = data;
-            }
-
-            /**
-             * Setter for the class field.
-             */
-            void query_class(uint16_t data) {
-                qclass_ = data;
-            }
-
-            /**
-             * Setter for the time-to-live field.
-             */
-            void ttl(uint32_t data) {
-                ttl_ = data;
-            }
-        private:
-            std::string dname_, data_;
-            uint16_t type_, qclass_;
-            uint32_t ttl_;
-        };
-        
-        typedef std::list<Query> queries_type;
-        typedef std::list<Resource> resources_type;
-        typedef IPv4Address address_type;
-        typedef IPv6Address address_v6_type;
-        
-        /**
-         * \brief Default constructor.
+         * \brief Constructs a DNS query.
          * 
-         * This constructor initializes every field to 0.
+         * \param nm The name of the domain being resolved.
+         * \param tp The query type.
+         * \param cl The query class.
          */
-        DNS();
+        Query(const std::string& nm, QueryType tp, QueryClass cl) 
+        : name_(nm), type_(tp), qclass_(cl) {}
         
         /**
-         * \brief Constructs a DNS object from a buffer.
-         * 
-         * If there's not enough size for the DNS header, or any of the
-         * records are malformed, a malformed_packet is be thrown.
-         * 
-         * \param buffer The buffer from which this PDU will be 
-         * constructed.
-         * \param total_sz The total size of the buffer.
+         * \brief Default constructs this Query.
          */
-        DNS(const uint8_t *buffer, uint32_t total_sz);
-        
-        // Getters
+        Query() : type_(), qclass_() {}
         
         /**
-         * \brief Setter for the id field.
+         * \brief Setter for the name field.
          * 
-         * \return uint16_t containing the value of the id field.
+         * \param nm The name to be set.
          */
-        uint16_t id() const { return Endian::be_to_host(dns.id); }
+        void dname(const std::string& nm) {
+            name_ = nm;
+        }
         
         /**
-         * \brief Setter for the query response field.
+         * \brief Setter for the query type field.
          * 
-         * \return QRType containing the value of the query response
-         * field.
+         * \param tp The query type to be set.
          */
-        QRType type() const { return static_cast<QRType>(dns.qr); }
+        void type(QueryType tp) {
+            type_ = tp;
+        }
         
         /**
-         * \brief Setter for the opcode field.
+         * \brief Setter for the query class field.
          * 
-         * \return uint8_t containing the value of the opcode field.
+         * \param cl The query class to be set.
          */
-        uint8_t opcode() const { return dns.opcode; }
+        void query_class(QueryClass cl) {
+            qclass_ = cl;
+        }
         
         /**
-         * \brief Setter for the authoritative answer field.
-         * 
-         * \return uint8_t containing the value of the authoritative 
-         * answer field.
+         * \brief Getter for the name field.
          */
-        uint8_t authoritative_answer() const { return dns.aa; }
+        const std::string& dname() const { return name_; }
         
         /**
-         * \brief Setter for the truncated field.
-         * 
-         * \return uint8_t containing the value of the truncated field.
+         * \brief Getter for the query type field.
          */
-        uint8_t truncated() const { return dns.tc; }
+        QueryType type() const { return type_; }
         
         /**
-         * \brief Setter for the recursion desired field.
-         * 
-         * \return uint8_t containing the value of the recursion
-         * desired field.
+         * \brief Getter for the query class field.
          */
-        uint8_t recursion_desired() const { return dns.rd; }
-        
+        QueryClass query_class() const { return qclass_; }
+    private:
+        std::string name_;
+        QueryType type_;
+        QueryClass qclass_;
+    };
+    
+    /**
+     * \brief Struct that represent DNS resource records.
+     */
+    class Resource {
+    public:
         /**
-         * \brief Setter for the recursion available field.
-         * 
-         * \return uint8_t containing the value of the recursion
-         * available field.
-         */
-        uint8_t recursion_available() const { return dns.ra; }
-        
-        /**
-         * \brief Setter for the z desired field.
-         * 
-         * \return uint8_t containing the value of the z field.
-         */
-        uint8_t z() const { return dns.z; }
-        
-        /**
-         * \brief Setter for the authenticated data field.
-         * 
-         * \return uint8_t containing the value of the authenticated
-         * data field.
-         */
-        uint8_t authenticated_data() const { return dns.ad; }
-        
-        /**
-         * \brief Setter for the checking disabled field.
-         * 
-         * \return uint8_t containing the value of the checking 
-         * disabled field.
-         */
-        uint8_t checking_disabled() const { return dns.cd; }
-        
-        /**
-         * \brief Setter for the rcode field.
-         * 
-         * \return uint8_t containing the value of the rcode field.
-         */
-        uint8_t rcode() const { return dns.rcode; }
-        
-        /**
-         * \brief Setter for the questions field.
-         * 
-         * \return uint16_t containing the value of the questions field.
-         */
-        uint16_t questions_count() const { return Endian::be_to_host(dns.questions); }
-        
-        /**
-         * \brief Setter for the answers field.
-         * 
-         * \return uint16_t containing the value of the answers field.
-         */
-        uint16_t answers_count() const { return Endian::be_to_host(dns.answers); }
-        
-        /**
-         * \brief Setter for the authority field.
-         * 
-         * \return uint16_t containing the value of the authority field.
-         */
-        uint16_t authority_count() const { return Endian::be_to_host(dns.authority); }
-        
-        /**
-         * \brief Setter for the additional field.
-         * 
-         * \return uint16_t containing the value of the additional field.
-         */
-        uint16_t additional_count() const { return Endian::be_to_host(dns.additional); }
-
-        /**
-         * \brief Getter for the PDU's type.
+         * Constructs a Resource object.
          *
-         * \return Returns the PDUType corresponding to the PDU.
+         * \param dname The domain name for which this records 
+         * provides an answer.
+         * \param data The resource's payload.
+         * \param type The type of this record.
+         * \param rclass The class of this record.
+         * \param ttl The time-to-live of this record.
          */
-        PDUType pdu_type() const { return PDU::DNS; }
+        Resource(const std::string& dname, const std::string& data, 
+          uint16_t type, uint16_t rclass, uint32_t ttl) 
+        : dname_(dname), data_(data), type_(type), qclass_(rclass), ttl_(ttl) {}
         
-        /** 
-         * \brief The header's size
-         */
-        uint32_t header_size() const;
-
-        // Setters
-         
-        /**
-         * \brief Setter for the id field.
-         * 
-         * \param new_id The new id to be set.
-         */
-        void id(uint16_t new_id);
+        Resource() : type_(), qclass_(), ttl_() {}
         
         /**
-         * \brief Setter for the query response field.
+         * \brief Getter for the domain name field.
          * 
-         * \param new_qr The new qr to be set.
+         * This returns the domain name for which this record 
+         * provides an answer.
          */
-        void type(QRType new_qr);
+        const std::string& dname() const { return dname_; }
         
         /**
-         * \brief Setter for the opcode field.
-         * 
-         * \param new_opcode The new opcode to be set.
+         * Getter for the data field. 
          */
-        void opcode(uint8_t new_opcode);
+        const std::string& data() const { return data_; }
         
         /**
-         * \brief Setter for the authoritative answer field.
-         * 
-         * \param new_aa The new authoritative answer field value to 
-         * be set.
+         * Getter for the query type field.
          */
-        void authoritative_answer(uint8_t new_aa);
+        uint16_t type() const { return type_; }
         
         /**
-         * \brief Setter for the truncated field.
-         * 
-         * \param new_tc The new truncated field value to 
-         * be set.
+         * Getter for the query class field.
          */
-        void truncated(uint8_t new_tc);
+        uint16_t query_class() const { return qclass_; }
         
         /**
-         * \brief Setter for the recursion desired field.
-         * 
-         * \param new_rd The new recursion desired value to 
-         * be set.
+         * Getter for the type field.
          */
-        void recursion_desired(uint8_t new_rd);
-        
-        /**
-         * \brief Setter for the recursion available field.
-         * 
-         * \param new_ra The new recursion available value to 
-         * be set.
-         */
-        void recursion_available(uint8_t new_ra);
-        
-        /**
-         * \brief Setter for the z(reserved) field.
-         * 
-         * \param new_z The new z value to be set.
-         */
-        void z(uint8_t new_z);
-        
-        /**
-         * \brief Setter for the authenticated data field.
-         * 
-         * \param new_ad The new authenticated data value to 
-         * be set.
-         */
-        void authenticated_data(uint8_t new_ad);
-        
-        /**
-         * \brief Setter for the checking disabled field.
-         * 
-         * \param new_z The new checking disabled value to be set.
-         */
-        void checking_disabled(uint8_t new_cd);
-        
-        /**
-         * \brief Setter for the rcode field.
-         * 
-         * \param new_rcode The new rcode value to be set.
-         */
-        void rcode(uint8_t new_rcode);
-        
-        // Methods
-        
-        /**
-         * \brief Add a query to perform.
-         * 
-         * \param query The query to be added.
-         */
-        void add_query(const Query &query);
-        
-        /**
-         * \brief Add an answer resource record.
-         * 
-         * \param resource The resource to be added.
-         */
-        void add_answer(const Resource &resource);
+        uint32_t ttl() const { return ttl_; }
 
         /**
-         * \brief Add an authority resource record.
-         * 
-         * \param resource The resource to be added.
+         * Setter for the domain name field.
          */
-        void add_authority(const Resource &resource);
-        
-        /**
-         * \brief Add an additional resource record.
-         * 
-         * \param resource The resource to be added.
-         */
-        void add_additional(const Resource &resource);
-        
-        /**
-         * \brief Getter for this PDU's DNS queries.
-         * 
-         * \return The query records in this PDU.
-         */
-        queries_type queries() const;
-        
-        /**
-         * \brief Getter for this PDU's DNS answers
-         * 
-         * \return The answer records in this PDU.
-         */
-        resources_type answers() const;
+        void dname(const std::string& data) {
+            dname_ = data;
+        }
 
         /**
-         * \brief Getter for this PDU's DNS authority records.
-         * 
-         * \return The authority records in this PDU.
-         */
-        resources_type authority() const;
-
-        /**
-         * \brief Getter for this PDU's DNS additional records.
-         * 
-         * \return The additional records in this PDU.
-         */
-        resources_type additional() const;
-        
-        /**
-         * \brief Encodes a domain name.
+         * \brief Setter for the data field.
          *
-         * This processes the input domain name and returns the encoded 
-         * version. Each label in the original domain name will be 
-         * prefixed with a byte that indicates the label's length. 
-         * The null-terminator byte <b>will</b> be included in the encoded
-         * string. No compression is performed.
-         *
-         * For example, given the input "www.example.com", the output would
-         * be "\x03www\x07example\x03com\x00".
+         * The data will be encoded properly by the DNS class before
+         * being added to this packet. That means that if the type is
+         * A or AAAA, it will be properly encoded as an IPv4 or
+         * IPv6 address. 
          * 
-         * \param domain_name The domain name to encode.
-         * \return The encoded domain name.
+         * The same happens for records that contain domain names,
+         * such as NS or CNAME. This data will be encoded using 
+         * DNS domain name encoding.
          */
-        static std::string encode_domain_name(const std::string &domain_name);
+        void data(const std::string& data) {
+            data_ = data;
+        }
 
-        /** 
-         * \brief Check wether ptr points to a valid response for this PDU.
-         *
-         * \sa PDU::matches_response
-         * \param ptr The pointer to the buffer.
-         * \param total_sz The size of the buffer.
-         */
-        bool matches_response(const uint8_t *ptr, uint32_t total_sz) const;
-        
         /**
-         * \sa PDU::clone
+         * Setter for the type field.
          */
-        DNS *clone() const {
-            return new DNS(*this);
+        void type(uint16_t data) {
+            type_ = data;
+        }
+
+        /**
+         * Setter for the class field.
+         */
+        void query_class(uint16_t data) {
+            qclass_ = data;
+        }
+
+        /**
+         * Setter for the time-to-live field.
+         */
+        void ttl(uint32_t data) {
+            ttl_ = data;
         }
     private:
-        TINS_BEGIN_PACK
-        struct dnshdr {
-            uint16_t id;
-            #if TINS_IS_LITTLE_ENDIAN
-                uint16_t 
-                    rd:1,
-                    tc:1,
-                    aa:1,
-                    opcode:4,
-                    qr:1,
-                    rcode:4,
-                    cd:1,
-                    ad:1,
-                    z:1,
-                    ra:1;
-            #elif TINS_IS_BIG_ENDIAN
-                uint16_t 
-                    qr:1,
-                    opcode:4,
-                    aa:1,
-                    tc:1,
-                    rd:1,
-                    ra:1,
-                    z:1,
-                    ad:1,
-                    cd:1,
-                    rcode:4;
-            #endif
-            uint16_t questions, answers,
-                     authority, additional;
-        } TINS_END_PACK;
-        
-        typedef std::list<Query> QueriesType;
-        typedef std::vector<std::pair<uint32_t*, uint32_t> > sections_type;
-        
-        const uint8_t* compose_name(const uint8_t *ptr, char *out_ptr) const;
-        void convert_records(const uint8_t *ptr, const uint8_t *end, resources_type &res) const;
-        const uint8_t* find_section_end(const uint8_t *ptr, const uint32_t num_records) const;
-        const uint8_t* find_dname_end(const uint8_t *ptr) const;
-        void update_records(uint32_t &section_start, uint32_t num_records, uint32_t threshold, uint32_t offset);
-        uint8_t *update_dname(uint8_t *ptr, uint32_t threshold, uint32_t offset);
-        static void inline_convert_v4(uint32_t value, char *output);
-        static bool contains_dname(uint16_t type);
-        void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
-        void add_record(const Resource &resource, const sections_type &sections);
-        
-        dnshdr dns;
-        byte_array records_data;
-        uint32_t answers_idx, authority_idx, additional_idx;
+        std::string dname_, data_;
+        uint16_t type_, qclass_;
+        uint32_t ttl_;
     };
-}
+    
+    typedef std::list<Query> queries_type;
+    typedef std::list<Resource> resources_type;
+    typedef IPv4Address address_type;
+    typedef IPv6Address address_v6_type;
+    
+    /**
+     * \brief Default constructor.
+     * 
+     * This constructor initializes every field to 0.
+     */
+    DNS();
+    
+    /**
+     * \brief Constructs a DNS object from a buffer.
+     * 
+     * If there's not enough size for the DNS header, or any of the
+     * records are malformed, a malformed_packet is be thrown.
+     * 
+     * \param buffer The buffer from which this PDU will be 
+     * constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    DNS(const uint8_t* buffer, uint32_t total_sz);
+    
+    // Getters
+    
+    /**
+     * \brief Setter for the id field.
+     * 
+     * \return uint16_t containing the value of the id field.
+     */
+    uint16_t id() const { 
+        return Endian::be_to_host(header_.id); 
+    }
+    
+    /**
+     * \brief Setter for the query response field.
+     * 
+     * \return QRType containing the value of the query response
+     * field.
+     */
+    QRType type() const {
+        return static_cast<QRType>(header_.qr);
+    }
+    
+    /**
+     * \brief Setter for the opcode field.
+     * 
+     * \return uint8_t containing the value of the opcode field.
+     */
+    uint8_t opcode() const {
+        return header_.opcode;
+    }
+    
+    /**
+     * \brief Setter for the authoritative answer field.
+     * 
+     * \return uint8_t containing the value of the authoritative 
+     * answer field.
+     */
+    uint8_t authoritative_answer() const {
+        return header_.aa;
+    }
+    
+    /**
+     * \brief Setter for the truncated field.
+     * 
+     * \return uint8_t containing the value of the truncated field.
+     */
+    uint8_t truncated() const {
+        return header_.tc;
+    }
+    
+    /**
+     * \brief Setter for the recursion desired field.
+     * 
+     * \return uint8_t containing the value of the recursion
+     * desired field.
+     */
+    uint8_t recursion_desired() const {
+        return header_.rd;
+    }
+    
+    /**
+     * \brief Setter for the recursion available field.
+     * 
+     * \return uint8_t containing the value of the recursion
+     * available field.
+     */
+    uint8_t recursion_available() const {
+        return header_.ra;
+    }
+    
+    /**
+     * \brief Setter for the z desired field.
+     * 
+     * \return uint8_t containing the value of the z field.
+     */
+    uint8_t z() const {
+        return header_.z;
+    }
+    
+    /**
+     * \brief Setter for the authenticated data field.
+     * 
+     * \return uint8_t containing the value of the authenticated
+     * data field.
+     */
+    uint8_t authenticated_data() const {
+        return header_.ad;
+    }
+    
+    /**
+     * \brief Setter for the checking disabled field.
+     * 
+     * \return uint8_t containing the value of the checking 
+     * disabled field.
+     */
+    uint8_t checking_disabled() const {
+        return header_.cd;
+    }
+    
+    /**
+     * \brief Setter for the rcode field.
+     * 
+     * \return uint8_t containing the value of the rcode field.
+     */
+    uint8_t rcode() const {
+        return header_.rcode;
+    }
+    
+    /**
+     * \brief Setter for the questions field.
+     * 
+     * \return uint16_t containing the value of the questions field.
+     */
+    uint16_t questions_count() const {
+        return Endian::be_to_host(header_.questions);
+    }
+    
+    /**
+     * \brief Setter for the answers field.
+     * 
+     * \return uint16_t containing the value of the answers field.
+     */
+    uint16_t answers_count() const {
+        return Endian::be_to_host(header_.answers);
+    }
+    
+    /**
+     * \brief Setter for the authority field.
+     * 
+     * \return uint16_t containing the value of the authority field.
+     */
+    uint16_t authority_count() const {
+        return Endian::be_to_host(header_.authority);
+    }
+    
+    /**
+     * \brief Setter for the additional field.
+     * 
+     * \return uint16_t containing the value of the additional field.
+     */
+    uint16_t additional_count() const {
+        return Endian::be_to_host(header_.additional);
+    }
+
+    /**
+     * \brief Getter for the PDU's type.
+     *
+     * \return Returns the PDUType corresponding to the PDU.
+     */
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
+    
+    /** 
+     * \brief The header's size
+     */
+    uint32_t header_size() const;
+
+    // Setters
+     
+    /**
+     * \brief Setter for the id field.
+     * 
+     * \param new_id The new id to be set.
+     */
+    void id(uint16_t new_id);
+    
+    /**
+     * \brief Setter for the query response field.
+     * 
+     * \param new_qr The new qr to be set.
+     */
+    void type(QRType new_qr);
+    
+    /**
+     * \brief Setter for the opcode field.
+     * 
+     * \param new_opcode The new opcode to be set.
+     */
+    void opcode(uint8_t new_opcode);
+    
+    /**
+     * \brief Setter for the authoritative answer field.
+     * 
+     * \param new_aa The new authoritative answer field value to 
+     * be set.
+     */
+    void authoritative_answer(uint8_t new_aa);
+    
+    /**
+     * \brief Setter for the truncated field.
+     * 
+     * \param new_tc The new truncated field value to 
+     * be set.
+     */
+    void truncated(uint8_t new_tc);
+    
+    /**
+     * \brief Setter for the recursion desired field.
+     * 
+     * \param new_rd The new recursion desired value to 
+     * be set.
+     */
+    void recursion_desired(uint8_t new_rd);
+    
+    /**
+     * \brief Setter for the recursion available field.
+     * 
+     * \param new_ra The new recursion available value to 
+     * be set.
+     */
+    void recursion_available(uint8_t new_ra);
+    
+    /**
+     * \brief Setter for the z(reserved) field.
+     * 
+     * \param new_z The new z value to be set.
+     */
+    void z(uint8_t new_z);
+    
+    /**
+     * \brief Setter for the authenticated data field.
+     * 
+     * \param new_ad The new authenticated data value to 
+     * be set.
+     */
+    void authenticated_data(uint8_t new_ad);
+    
+    /**
+     * \brief Setter for the checking disabled field.
+     * 
+     * \param new_z The new checking disabled value to be set.
+     */
+    void checking_disabled(uint8_t new_cd);
+    
+    /**
+     * \brief Setter for the rcode field.
+     * 
+     * \param new_rcode The new rcode value to be set.
+     */
+    void rcode(uint8_t new_rcode);
+    
+    // Methods
+    
+    /**
+     * \brief Add a query to perform.
+     * 
+     * \param query The query to be added.
+     */
+    void add_query(const Query& query);
+    
+    /**
+     * \brief Add an answer resource record.
+     * 
+     * \param resource The resource to be added.
+     */
+    void add_answer(const Resource& resource);
+
+    /**
+     * \brief Add an authority resource record.
+     * 
+     * \param resource The resource to be added.
+     */
+    void add_authority(const Resource& resource);
+    
+    /**
+     * \brief Add an additional resource record.
+     * 
+     * \param resource The resource to be added.
+     */
+    void add_additional(const Resource& resource);
+    
+    /**
+     * \brief Getter for this PDU's DNS queries.
+     * 
+     * \return The query records in this PDU.
+     */
+    queries_type queries() const;
+    
+    /**
+     * \brief Getter for this PDU's DNS answers
+     * 
+     * \return The answer records in this PDU.
+     */
+    resources_type answers() const;
+
+    /**
+     * \brief Getter for this PDU's DNS authority records.
+     * 
+     * \return The authority records in this PDU.
+     */
+    resources_type authority() const;
+
+    /**
+     * \brief Getter for this PDU's DNS additional records.
+     * 
+     * \return The additional records in this PDU.
+     */
+    resources_type additional() const;
+    
+    /**
+     * \brief Encodes a domain name.
+     *
+     * This processes the input domain name and returns the encoded 
+     * version. Each label in the original domain name will be 
+     * prefixed with a byte that indicates the label's length. 
+     * The null-terminator byte <b>will</b> be included in the encoded
+     * string. No compression is performed.
+     *
+     * For example, given the input "www.example.com", the output would
+     * be "\x03www\x07example\x03com\x00".
+     * 
+     * \param domain_name The domain name to encode.
+     * \return The encoded domain name.
+     */
+    static std::string encode_domain_name(const std::string& domain_name);
+
+    /** 
+     * \brief Check wether ptr points to a valid response for this PDU.
+     *
+     * \sa PDU::matches_response
+     * \param ptr The pointer to the buffer.
+     * \param total_sz The size of the buffer.
+     */
+    bool matches_response(const uint8_t* ptr, uint32_t total_sz) const;
+    
+    /**
+     * \sa PDU::clone
+     */
+    DNS* clone() const {
+        return new DNS(*this);
+    }
+private:
+    TINS_BEGIN_PACK
+    struct dns_header {
+        uint16_t id;
+        #if TINS_IS_LITTLE_ENDIAN
+            uint16_t 
+                rd:1,
+                tc:1,
+                aa:1,
+                opcode:4,
+                qr:1,
+                rcode:4,
+                cd:1,
+                ad:1,
+                z:1,
+                ra:1;
+        #elif TINS_IS_BIG_ENDIAN
+            uint16_t 
+                qr:1,
+                opcode:4,
+                aa:1,
+                tc:1,
+                rd:1,
+                ra:1,
+                z:1,
+                ad:1,
+                cd:1,
+                rcode:4;
+        #endif
+        uint16_t questions, answers,
+                 authority, additional;
+    } TINS_END_PACK;
+    
+    typedef std::list<Query> QueriesType;
+    typedef std::vector<std::pair<uint32_t*, uint32_t> > sections_type;
+    
+    uint32_t compose_name(const uint8_t* ptr, char* out_ptr) const;
+    void convert_records(const uint8_t* ptr, const uint8_t* end, resources_type& res) const;
+    void skip_to_section_end(Memory::InputMemoryStream& stream, 
+                             const uint32_t num_records) const;
+    void skip_to_dname_end(Memory::InputMemoryStream& stream) const;
+    void update_records(uint32_t& section_start, uint32_t num_records, uint32_t threshold, uint32_t offset);
+    uint8_t* update_dname(uint8_t* ptr, uint32_t threshold, uint32_t offset);
+    static void inline_convert_v4(uint32_t value, char* output);
+    static bool contains_dname(uint16_t type);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
+    void add_record(const Resource& resource, const sections_type& sections);
+    
+    dns_header header_;
+    byte_array records_data_;
+    uint32_t answers_idx_, authority_idx_, additional_idx_;
+};
+
+} // Tins
 
 #endif // TINS_DNS_H
-
diff --git a/include/tins/dot11/dot11_assoc.h b/include/tins/dot11/dot11_assoc.h
index 017d905..73dbd4c 100644
--- a/include/tins/dot11/dot11_assoc.h
+++ b/include/tins/dot11/dot11_assoc.h
@@ -56,8 +56,8 @@ public:
      * \param dst_hw_addr The destination hardware address.
      * \param src_hw_addr The source hardware address.
      */
-    Dot11Disassoc(const address_type &dst_hw_addr = address_type(), 
-                const address_type &src_hw_addr = address_type());
+    Dot11Disassoc(const address_type& dst_hw_addr = address_type(), 
+                  const address_type& src_hw_addr = address_type());
 
     /**
      * \brief Constructs a Dot11Disassoc object from a buffer and 
@@ -73,14 +73,16 @@ public:
      * \param buffer The buffer from which this PDU will be constructed.
      * \param total_sz The total size of the buffer.
      */
-    Dot11Disassoc(const uint8_t *buffer, uint32_t total_sz);
+    Dot11Disassoc(const uint8_t* buffer, uint32_t total_sz);
 
     /**
      * \brief Getter for the reason code field.
      *
      * \return The stored reason code.
      */
-    uint16_t reason_code() const { return Endian::le_to_host(_body.reason_code); }
+    uint16_t reason_code() const {
+        return Endian::le_to_host(body_.reason_code);
+    }
 
     /**
      * \brief Setter for the reason code field.
@@ -101,7 +103,9 @@ public:
      * \brief Getter for the PDU's type.
      * \sa PDU::pdu_type
      */
-    PDUType pdu_type() const { return pdu_flag; }
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
 
     /**
      * \brief Check wether this PDU matches the specified flag.
@@ -117,17 +121,17 @@ public:
      *
      * \sa PDU::clone
      */
-    Dot11Disassoc *clone() const {
+    Dot11Disassoc* clone() const {
         return new Dot11Disassoc(*this);
     }
 private:
-    struct DisassocBody {
+    struct dot11_disassoc_body {
         uint16_t reason_code;
     };
 
     void write_fixed_parameters(Memory::OutputMemoryStream& stream);
 
-    DisassocBody _body;
+    dot11_disassoc_body body_;
 };
 
 /**
@@ -150,8 +154,8 @@ public:
      * \param dst_hw_addr The destination hardware address.
      * \param src_hw_addr The source hardware address.
      */
-    Dot11AssocRequest(const address_type &dst_hw_addr = address_type(), 
-                    const address_type &src_hw_addr = address_type());
+    Dot11AssocRequest(const address_type& dst_hw_addr = address_type(), 
+                      const address_type& src_hw_addr = address_type());
 
     /**
      * \brief Constructs a Dot11AssocRequest object from a buffer 
@@ -167,7 +171,7 @@ public:
      * \param buffer The buffer from which this PDU will be constructed.
      * \param total_sz The total size of the buffer.
      */
-    Dot11AssocRequest(const uint8_t *buffer, uint32_t total_sz);
+    Dot11AssocRequest(const uint8_t* buffer, uint32_t total_sz);
 
     /**
      * \brief Getter for the Capabilities Information.
@@ -175,7 +179,9 @@ public:
      * \return A constant refereence to the stored Capabilities 
      * Information field.
      */
-    const capability_information& capabilities() const { return _body.capability;}
+    const capability_information& capabilities() const {
+        return body_.capability;
+    }
 
     /**
      * \brief Getter for the Capabilities Information.
@@ -183,14 +189,18 @@ public:
      * \return A refereence to the stored Capabilities Information 
      * field.
      */
-    capability_information& capabilities() { return _body.capability;}
+    capability_information& capabilities() {
+        return body_.capability;
+    }
 
     /**
      * \brief Getter for the listen interval field.
      *
      * \return The stored listen interval field.
      */
-    uint16_t listen_interval() const { return Endian::le_to_host(_body.listen_interval); }
+    uint16_t listen_interval() const {
+        return Endian::le_to_host(body_.listen_interval);
+    }
 
     /**
      * \brief Setter for the listen interval field.
@@ -211,7 +221,9 @@ public:
      * \brief Getter for the PDU's type.
      * \sa PDU::pdu_type
      */
-    PDUType pdu_type() const { return pdu_flag; }
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
 
     /**
      * \brief Check wether this PDU matches the specified flag.
@@ -227,18 +239,18 @@ public:
      *
      * \sa PDU::clone
      */
-    Dot11AssocRequest *clone() const {
+    Dot11AssocRequest* clone() const {
         return new Dot11AssocRequest(*this);
     }
 private:
-    struct AssocReqBody {
+    struct dot11_assoc_request_body {
         capability_information capability;
         uint16_t listen_interval;
     };
 
     void write_fixed_parameters(Memory::OutputMemoryStream& stream);
 
-    AssocReqBody _body;
+    dot11_assoc_request_body body_;
 };
 
 /**
@@ -261,8 +273,8 @@ public:
      * \param dst_hw_addr The destination hardware address.
      * \param src_hw_addr The source hardware address.
      */
-    Dot11AssocResponse(const address_type &dst_hw_addr = address_type(), 
-                        const address_type &src_hw_addr = address_type());
+    Dot11AssocResponse(const address_type& dst_hw_addr = address_type(), 
+                       const address_type& src_hw_addr = address_type());
 
     /**
      * \brief Constructor which creates a Dot11AssocResponse object 
@@ -278,7 +290,7 @@ public:
      * \param buffer The buffer from which this PDU will be constructed.
      * \param total_sz The total size of the buffer.
      */
-    Dot11AssocResponse(const uint8_t *buffer, uint32_t total_sz);
+    Dot11AssocResponse(const uint8_t* buffer, uint32_t total_sz);
 
     /**
      * \brief Getter for the Capabilities Information field.
@@ -286,7 +298,9 @@ public:
      * \return A constant reference to the stored Capabilities 
      * Information field.
      */
-    const capability_information& capabilities() const { return _body.capability;}
+    const capability_information& capabilities() const {
+        return body_.capability;
+    }
 
     /**
      * \brief Getter for the Capabilities Information field.
@@ -294,21 +308,27 @@ public:
      * \return A reference to the stored Capabilities 
      * Information field.
      */
-    capability_information& capabilities() { return _body.capability;}
+    capability_information& capabilities() {
+        return body_.capability;
+    }
 
     /**
      * \brief Getter for the status code field.
      *
      * \return The stored status code.
      */
-    uint16_t status_code() const { return Endian::le_to_host(_body.status_code); }
+    uint16_t status_code() const {
+        return Endian::le_to_host(body_.status_code);
+    }
 
     /**
      * \brief Getter for the AID field.
      *
      * \return The stored AID field.
      */
-    uint16_t aid() const { return Endian::le_to_host(_body.aid); }
+    uint16_t aid() const {
+        return Endian::le_to_host(body_.aid);
+    }
 
     /**
      * \brief Setter for the status code.
@@ -336,7 +356,9 @@ public:
      * \brief Getter for the PDU's type.
      * \sa PDU::pdu_type
      */
-    PDUType pdu_type() const { return pdu_flag; }
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
 
     /**
      * \brief Check wether this PDU matches the specified flag.
@@ -352,11 +374,11 @@ public:
      *
      * \sa PDU::clone
      */
-    Dot11AssocResponse *clone() const {
+    Dot11AssocResponse* clone() const {
         return new Dot11AssocResponse(*this);
     }
 private:
-    struct AssocRespBody {
+    struct dot11_assoc_response_body {
         capability_information capability;
         uint16_t status_code;
         uint16_t aid;
@@ -364,7 +386,7 @@ private:
 
     void write_fixed_parameters(Memory::OutputMemoryStream& stream);
 
-    AssocRespBody _body;
+    dot11_assoc_response_body body_;
 };
 
 /**
@@ -387,8 +409,8 @@ public:
      * \param dst_hw_addr The destination hardware address.
      * \param src_hw_addr The source hardware address.
      */
-    Dot11ReAssocRequest(const address_type &dst_hw_addr = address_type(), 
-                        const address_type &src_hw_addr = address_type());
+    Dot11ReAssocRequest(const address_type& dst_hw_addr = address_type(), 
+                        const address_type& src_hw_addr = address_type());
 
     /**
      * \brief Constructs a Dot11AssocRequest object from a buffer 
@@ -404,7 +426,7 @@ public:
      * \param buffer The buffer from which this PDU will be constructed.
      * \param total_sz The total size of the buffer.
      */
-    Dot11ReAssocRequest(const uint8_t *buffer, uint32_t total_sz);
+    Dot11ReAssocRequest(const uint8_t* buffer, uint32_t total_sz);
 
     /**
      * \brief Getter for the Capabilities Information.
@@ -412,7 +434,9 @@ public:
      * \return A constant reference to the stored Capabilities 
      * Information field.
      */
-    const capability_information& capabilities() const { return _body.capability;}
+    const capability_information& capabilities() const {
+        return body_.capability;
+    }
 
     /**
      * \brief Getter for the Capabilities Information.
@@ -420,21 +444,27 @@ public:
      * \return A reference to the stored Capabilities Information 
      * field.
      */
-    capability_information& capabilities() { return _body.capability;}
+    capability_information& capabilities() {
+        return body_.capability;
+    }
 
     /**
      * \brief Getter for the listen interval field.
      *
      * \return The stored listen interval.
      */
-    uint16_t listen_interval() const { return Endian::le_to_host(_body.listen_interval); }
+    uint16_t listen_interval() const {
+        return Endian::le_to_host(body_.listen_interval);
+    }
 
     /**
      * \brief Getter for the current ap field.
      *
      * \return The current ap.
      */
-    address_type current_ap() const { return _body.current_ap; }
+    address_type current_ap() const {
+        return body_.current_ap;
+    }
 
     /**
      * \brief Setter for the listen interval field.
@@ -448,7 +478,7 @@ public:
      *
      * \param new_current_ap The address of the current ap.
      */
-    void current_ap(const address_type &new_current_ap);
+    void current_ap(const address_type& new_current_ap);
 
     /**
      * \brief Returns the frame's header length.
@@ -462,7 +492,9 @@ public:
      * \brief Getter for the PDU's type.
      * \sa PDU::pdu_type
      */
-    PDUType pdu_type() const { return pdu_flag; }
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
 
     /**
      * \brief Check wether this PDU matches the specified flag.
@@ -478,11 +510,11 @@ public:
      *
      * \sa PDU::clone
      */
-    Dot11ReAssocRequest *clone() const {
+    Dot11ReAssocRequest* clone() const {
         return new Dot11ReAssocRequest(*this);
     }
 private:
-    struct ReAssocReqBody {
+    struct dot11_reassoc_request_body {
         capability_information capability;
         uint16_t listen_interval;
         uint8_t current_ap[address_type::address_size];
@@ -490,7 +522,7 @@ private:
 
     void write_fixed_parameters(Memory::OutputMemoryStream& stream);
 
-    ReAssocReqBody _body;
+    dot11_reassoc_request_body body_;
 };
 
 /**
@@ -513,8 +545,8 @@ public:
      * \param dst_hw_addr The destination hardware address.
      * \param src_hw_addr The source hardware address.
      */
-    Dot11ReAssocResponse(const address_type &dst_hw_addr = address_type(), 
-                        const address_type &src_hw_addr = address_type());
+    Dot11ReAssocResponse(const address_type& dst_hw_addr = address_type(), 
+                         const address_type& src_hw_addr = address_type());
 
     /**
      * \brief Constructs a Dot11ReAssocResponse object from a buffer 
@@ -530,7 +562,7 @@ public:
      * \param buffer The buffer from which this PDU will be constructed.
      * \param total_sz The total size of the buffer.
      */
-    Dot11ReAssocResponse(const uint8_t *buffer, uint32_t total_sz);
+    Dot11ReAssocResponse(const uint8_t* buffer, uint32_t total_sz);
 
     /**
      * \brief Getter for the Capabilities Information.
@@ -538,7 +570,9 @@ public:
      * \return A constant reference to the stored Capabilities 
      * Information field.
      */
-    const capability_information& capabilities() const { return _body.capability;}
+    const capability_information& capabilities() const {
+        return body_.capability;
+    }
 
     /**
      * \brief Getter for the Capabilities Information.
@@ -546,21 +580,27 @@ public:
      * \return A reference to the stored Capabilities Information 
      * field.
      */
-    capability_information& capabilities() { return _body.capability;}
+    capability_information& capabilities() {
+        return body_.capability;
+    }
 
     /**
      * \brief Getter for the status code field.
      *
      * \return The stored status code.
      */
-    uint16_t status_code() const { return Endian::le_to_host(_body.status_code); }
+    uint16_t status_code() const {
+        return Endian::le_to_host(body_.status_code);
+    }
 
     /**
      * \brief Getter for the AID field.
      *
      * \return The stored AID field value.
      */
-    uint16_t aid() const { return Endian::le_to_host(_body.aid); }
+    uint16_t aid() const {
+        return Endian::le_to_host(body_.aid);
+    }
 
     /**
      * \brief Setter for the status code field.
@@ -588,7 +628,9 @@ public:
      * \brief Getter for the PDU's type.
      * \sa PDU::pdu_type
      */
-    PDUType pdu_type() const { return pdu_flag; }
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
 
     /**
      * \brief Check wether this PDU matches the specified flag.
@@ -604,11 +646,11 @@ public:
      *
      * \sa PDU::clone
      */
-    Dot11ReAssocResponse *clone() const {
+    Dot11ReAssocResponse* clone() const {
         return new Dot11ReAssocResponse(*this);
     }
 private:
-    struct ReAssocRespBody {
+    struct dot11_reassoc_response_body {
         capability_information capability;
         uint16_t status_code;
         uint16_t aid;
@@ -616,8 +658,9 @@ private:
 
     void write_fixed_parameters(Memory::OutputMemoryStream& stream);
 
-    ReAssocRespBody _body;
+    dot11_reassoc_response_body body_;
 };
+
 } // namespace Tins
 
 #endif // TINS_DOT11_DOT11_ASSOC_H
diff --git a/include/tins/dot11/dot11_auth.h b/include/tins/dot11/dot11_auth.h
index 8d02a26..e8a5390 100644
--- a/include/tins/dot11/dot11_auth.h
+++ b/include/tins/dot11/dot11_auth.h
@@ -55,8 +55,8 @@ public:
      * \param dst_hw_addr The destination hardware address.
      * \param src_hw_addr The source hardware address.
      */
-    Dot11Authentication(const address_type &dst_hw_addr = address_type(), 
-                        const address_type &src_hw_addr = address_type());
+    Dot11Authentication(const address_type& dst_hw_addr = address_type(), 
+                        const address_type& src_hw_addr = address_type());
 
     /**
      * \brief Constructs a Dot11Authentication object from a buffer 
@@ -72,28 +72,33 @@ public:
      * \param buffer The buffer from which this PDU will be constructed.
      * \param total_sz The total size of the buffer.
      */
-    Dot11Authentication(const uint8_t *buffer, uint32_t total_sz);
+    Dot11Authentication(const uint8_t* buffer, uint32_t total_sz);
 
     /**
      * \brief Getter for the Authetication Algorithm Number field.
      *
      * \return The stored authentication algorithm number.
      */
-    uint16_t auth_algorithm() const {return Endian::le_to_host(_body.auth_algorithm); }
+    uint16_t auth_algorithm() const {
+        return Endian::le_to_host(body_.auth_algorithm); }
 
     /**
      * \brief Getter for the Authetication Sequence Number field.
      *
      * \return The stored authentication sequence number.
      */
-    uint16_t auth_seq_number() const {return Endian::le_to_host(_body.auth_seq_number); }
+    uint16_t auth_seq_number() const {
+        return Endian::le_to_host(body_.auth_seq_number);
+    }
 
     /**
      * \brief Getter for the status code field.
      *
      * \return The stored status code.
      */
-    uint16_t status_code() const { return Endian::le_to_host(_body.status_code); }
+    uint16_t status_code() const {
+        return Endian::le_to_host(body_.status_code);
+    }
 
     /**
      * \brief Setter for the Authetication Algorithm Number field.
@@ -130,7 +135,9 @@ public:
      * \brief Getter for the PDU's type.
      * \sa PDU::pdu_type
      */
-    PDUType pdu_type() const { return pdu_flag; }
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
 
     /**
      * \brief Check wether this PDU matches the specified flag.
@@ -146,11 +153,11 @@ public:
      *
      * \sa PDU::clone
      */
-    Dot11Authentication *clone() const {
+    Dot11Authentication* clone() const {
         return new Dot11Authentication(*this);
     }
 private:
-    struct AuthBody {
+    struct dot11_auth_body {
         uint16_t auth_algorithm;
         uint16_t auth_seq_number;
         uint16_t status_code;
@@ -158,8 +165,7 @@ private:
 
     void write_fixed_parameters(Memory::OutputMemoryStream& stream);
 
-    AuthBody _body;
-
+    dot11_auth_body body_;
 };
 
 /**
@@ -182,8 +188,8 @@ public:
      * \param dst_hw_addr The destination hardware address.
      * \param src_hw_addr The source hardware address.
      */
-    Dot11Deauthentication(const address_type &dst_hw_addr = address_type(), 
-                        const address_type &src_hw_addr = address_type());
+    Dot11Deauthentication(const address_type& dst_hw_addr = address_type(), 
+                          const address_type& src_hw_addr = address_type());
 
     /**
      * \brief Constructs a Dot11Deauthentication object from a buffer 
@@ -199,14 +205,16 @@ public:
      * \param buffer The buffer from which this PDU will be constructed.
      * \param total_sz The total size of the buffer.
      */
-    Dot11Deauthentication(const uint8_t *buffer, uint32_t total_sz);
+    Dot11Deauthentication(const uint8_t* buffer, uint32_t total_sz);
 
     /**
      * \brief Getter for the reason code field.
      *
      * \return The reason code to be set.
      */
-    uint16_t reason_code() const { return Endian::le_to_host(_body.reason_code); }
+    uint16_t reason_code() const {
+        return Endian::le_to_host(body_.reason_code);
+    }
 
     /**
      * \brief Setter for the reason code field.
@@ -227,7 +235,9 @@ public:
      * \brief Getter for the PDU's type.
      * \sa PDU::pdu_type
      */
-    PDUType pdu_type() const { return pdu_flag; }
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
 
     /**
      * \brief Check wether this PDU matches the specified flag.
@@ -243,19 +253,19 @@ public:
      *
      * \sa PDU::clone
      */
-    Dot11Deauthentication *clone() const {
+    Dot11Deauthentication* clone() const {
         return new Dot11Deauthentication(*this);
     }
 private:
-    struct DeauthBody {
+    struct dot11_deauth_body {
         uint16_t reason_code;
     };
 
     void write_fixed_parameters(Memory::OutputMemoryStream& stream);
 
-    DeauthBody _body;
+    dot11_deauth_body body_;
 };
+
 } // namespace Tins
 
-
 #endif // TINS_DOT11_DOT11_AUTH_H
diff --git a/include/tins/dot11/dot11_base.h b/include/tins/dot11/dot11_base.h
index 7e4a970..3fcd71f 100644
--- a/include/tins/dot11/dot11_base.h
+++ b/include/tins/dot11/dot11_base.h
@@ -192,7 +192,7 @@ public:
      *
      * \param dst_hw_addr The destination hardware address.
      */
-    Dot11(const address_type &dst_hw_addr = address_type());
+    Dot11(const address_type& dst_hw_addr = address_type());
 
     /**
      * \brief Constructs 802.11 PDU from a buffer and adds all 
@@ -206,91 +206,115 @@ public:
      * \param buffer The buffer from which this PDU will be constructed.
      * \param total_sz The total size of the buffer.
      */
-    Dot11(const uint8_t *buffer, uint32_t total_sz);
+    Dot11(const uint8_t* buffer, uint32_t total_sz);
 
     /**
      * \brief Getter for the protocol version field.
      *
      * \return The stored protocol version field.
      */
-    small_uint<2> protocol() const { return _header.control.protocol; }
+    small_uint<2> protocol() const {
+        return header_.control.protocol;
+    }
 
     /**
      * \brief Getter for the Type field.
      *
      * \return The stored Type field.
      */
-    small_uint<2> type() const { return _header.control.type; }
+    small_uint<2> type() const {
+        return header_.control.type;
+    }
 
     /**
      * \brief Getter for the Subtype field.
      *
      * \return The stored Subtype field.
      */
-    small_uint<4> subtype() const { return _header.control.subtype; }
+    small_uint<4> subtype() const {
+        return header_.control.subtype;
+    }
 
     /**
      * \brief Getter for the To-DS field.
      *
      * \return The stored To-DS field.
      */
-    small_uint<1> to_ds() const { return _header.control.to_ds; }
+    small_uint<1> to_ds() const {
+        return header_.control.to_ds;
+    }
 
     /**
      * \brief Getter for the From-DS field.
      *
      * \return The stored From-DS field.
      */
-    small_uint<1> from_ds() const { return _header.control.from_ds; }
+    small_uint<1> from_ds() const {
+        return header_.control.from_ds;
+    }
 
     /**
      * \brief Getter for the More-Frag field.
      *
      * \return The stored More-Frag field.
      */
-    small_uint<1> more_frag() const { return _header.control.more_frag; }
+    small_uint<1> more_frag() const {
+        return header_.control.more_frag;
+    }
 
     /**
      * \brief Getter for the Retry field.
      *
      * \return The stored Retry field.
      */
-    small_uint<1> retry() const { return _header.control.retry; }
+    small_uint<1> retry() const {
+        return header_.control.retry;
+    }
 
     /**
      * \brief Getter for the Power-Management field.
      *
      * \return The stored Power-Management field.
      */
-    small_uint<1> power_mgmt() const { return _header.control.power_mgmt; }
+    small_uint<1> power_mgmt() const {
+        return header_.control.power_mgmt;
+    }
 
     /**
      * \brief Getter for the WEP field.
      *
      * \return The stored WEP field.
      */
-    small_uint<1> wep() const { return _header.control.wep; }
+    small_uint<1> wep() const {
+        return header_.control.wep;
+    }
 
     /**
      * \brief Getter for the Order field.
      *
      * \return The stored Order field.
      */
-    small_uint<1> order() const { return _header.control.order; }
+    small_uint<1> order() const {
+        return header_.control.order;
+    }
 
     /**
      * \brief Getter for the Duration-ID field.
      *
      * \return The stored Duration-ID field.
      */
-    uint16_t duration_id() const { return Endian::le_to_host(_header.duration_id); }
+    uint16_t duration_id() const {
+        return Endian::le_to_host(header_.duration_id);
+    }
 
     /**
      * \brief Getter for the first address.
      *
      * \return The stored first address.
      */
-    address_type addr1() const { return _header.addr1; }
+    address_type addr1() const {
+        return header_.addr1;
+    }
 
     // Setters
 
@@ -376,7 +400,7 @@ public:
      *
      * \param new_addr1 The new first address.
      */
-    void addr1(const address_type &new_addr1);
+    void addr1(const address_type& new_addr1);
 
     /* Virtual methods */
     /**
@@ -391,14 +415,14 @@ public:
     /**
      * \sa PDU::send()
      */
-    void send(PacketSender &sender, const NetworkInterface &iface);
+    void send(PacketSender& sender, const NetworkInterface& iface);
     #endif // _WIN32
     
     /**
      * \brief Adds a new option to this Dot11 PDU.
      * \param opt The option to be added.
      */
-    void add_option(const option &opt);
+    void add_option(const option& opt);
     
     #if TINS_IS_CXX11
         /**
@@ -410,7 +434,7 @@ public:
          */
         void add_option(option &&opt) {
             internal_add_option(opt);
-            _options.push_back(std::move(opt));
+            options_.push_back(std::move(opt));
         }
     #endif
 
@@ -433,18 +457,20 @@ public:
      * \param type The option identifier.
      * \return The option found, or 0 if no such option has been set.
      */
-    const option *search_option(OptionTypes type) const;
+    const option* search_option(OptionTypes type) const;
 
     /**
      * \brief Getter for the PDU's type.
      * \sa PDU::pdu_type
      */
-    PDUType pdu_type() const { return pdu_flag; }
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
     
     /**
      * \sa PDU::clone
      */
-    Dot11 *clone() const {
+    Dot11* clone() const {
         return new Dot11(*this);
     }
 
@@ -462,7 +488,9 @@ public:
      * 
      * \return The options list.
      */
-    const options_type &options() const { return _options; }
+    const options_type& options() const {
+        return options_;
+    }
 
     /**
      * \brief Allocates an Dot11 PDU from a buffer.
@@ -478,18 +506,18 @@ public:
      * \param total_sz The total size of the buffer.
      * \return The allocated Dot11 PDU.
      */
-    static Dot11 *from_bytes(const uint8_t *buffer, uint32_t total_sz);
+    static Dot11* from_bytes(const uint8_t* buffer, uint32_t total_sz);
 protected:
     virtual void write_ext_header(Memory::OutputMemoryStream& stream) { }
     virtual void write_fixed_parameters(Memory::OutputMemoryStream& stream) { }
     void parse_tagged_parameters(Memory::InputMemoryStream& stream);
-    void add_tagged_option(OptionTypes opt, uint8_t len, const uint8_t *val);
+    void add_tagged_option(OptionTypes opt, uint8_t len, const uint8_t* val);
 protected:
     /**
      * Struct that represents the 802.11 header
      */
     TINS_BEGIN_PACK
-    struct ieee80211_header {
+    struct dot11_header {
         TINS_BEGIN_PACK
         struct {
         #if TINS_IS_LITTLE_ENDIAN
@@ -523,18 +551,19 @@ protected:
 
     } TINS_END_PACK;
 private:
-    Dot11(const ieee80211_header *header_ptr);
+    Dot11(const dot11_header* header_ptr);
     
-    void internal_add_option(const option &opt);
-    void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
+    void internal_add_option(const option& opt);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
     options_type::const_iterator search_option_iterator(OptionTypes type) const;
     options_type::iterator search_option_iterator(OptionTypes type);
 
 
-    ieee80211_header _header;
-    uint32_t _options_size;
-    options_type _options;
+    dot11_header header_;
+    uint32_t options_size_;
+    options_type options_;
 };
-}
+
+} // Tins
 
 #endif // TINS_DOT11_DOT11_H
diff --git a/include/tins/dot11/dot11_beacon.h b/include/tins/dot11/dot11_beacon.h
index ae72ff6..cdfb010 100644
--- a/include/tins/dot11/dot11_beacon.h
+++ b/include/tins/dot11/dot11_beacon.h
@@ -36,132 +36,144 @@
 #include "../macros.h"
 
 namespace Tins {
+
+/**
+ * \brief Represents an IEEE 802.11 Beacon.
+ *
+ */
+class TINS_API Dot11Beacon : public Dot11ManagementFrame {
+public:
     /**
-     * \brief Class representing an 802.11 Beacon.
-     *
+     * \brief This PDU's flag.
      */
-    class TINS_API Dot11Beacon : public Dot11ManagementFrame {
-    public:
-        /**
-         * \brief This PDU's flag.
-         */
-        static const PDU::PDUType pdu_flag = PDU::DOT11_BEACON;
+    static const PDU::PDUType pdu_flag = PDU::DOT11_BEACON;
 
-        /**
-         * \brief Constructor for creating a 802.11 Beacon.
-         *
-         * Constructs a 802.11 Beacon taking destination and source 
-         * hardware address.
-         *
-         * \param dst_hw_addr The destination hardware address.
-         * \param src_hw_addr The source hardware address.
-         */
-        Dot11Beacon(const address_type &dst_hw_addr = address_type(), 
-                    const address_type &src_hw_addr = address_type());
+    /**
+     * \brief Constructor for creating a 802.11 Beacon.
+     *
+     * Constructs a 802.11 Beacon taking destination and source 
+     * hardware address.
+     *
+     * \param dst_hw_addr The destination hardware address.
+     * \param src_hw_addr The source hardware address.
+     */
+    Dot11Beacon(const address_type& dst_hw_addr = address_type(), 
+                const address_type& src_hw_addr = address_type());
 
-        /**
-         * \brief Constructs a Dot11Beacon object from a buffer and adds
-         * all identifiable PDUs found in the buffer as children of this 
-         * one.
-         *
-         * If the next PDU is not recognized, then a RawPDU is used.
-         * 
-         * If there is not enough size for the header in the buffer
-         * or the input data is malformed, a malformed_packet exception 
-         * is thrown.
-         * 
-         * \param buffer The buffer from which this PDU will be constructed.
-         * \param total_sz The total size of the buffer.
-         */
-        Dot11Beacon(const uint8_t *buffer, uint32_t total_sz);
+    /**
+     * \brief Constructs a Dot11Beacon object from a buffer and adds
+     * all identifiable PDUs found in the buffer as children of this 
+     * one.
+     *
+     * If the next PDU is not recognized, then a RawPDU is used.
+     * 
+     * If there is not enough size for the header in the buffer
+     * or the input data is malformed, a malformed_packet exception 
+     * is thrown.
+     * 
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    Dot11Beacon(const uint8_t* buffer, uint32_t total_sz);
 
-        /**
-         * \brief Getter for the timestamp field.
-         *
-         * \return The stored timestamp value.
-         */
-        uint64_t timestamp() const { return Endian::le_to_host(_body.timestamp); }
+    /**
+     * \brief Getter for the timestamp field.
+     *
+     * \return The stored timestamp value.
+     */
+    uint64_t timestamp() const {
+        return Endian::le_to_host(body_.timestamp);
+    }
 
-        /**
-         * \brief Getter for the interval field.
-         *
-         * \return The stored interval value.
-         */
-        uint16_t interval() const { return Endian::le_to_host(_body.interval); }
+    /**
+     * \brief Getter for the interval field.
+     *
+     * \return The stored interval value.
+     */
+    uint16_t interval() const {
+        return Endian::le_to_host(body_.interval);
+    }
 
-        /**
-         * \brief Getter for the Capabilities Information structure.
-         *
-         * \return A constant refereence to the stored Capabilities 
-         * Information field.
-         */
-        const capability_information& capabilities() const { return _body.capability; }
+    /**
+     * \brief Getter for the Capabilities Information structure.
+     *
+     * \return A constant refereence to the stored Capabilities 
+     * Information field.
+     */
+    const capability_information& capabilities() const {
+        return body_.capability;
+    }
 
-        /**
-         * \brief Getter for the Capabilities Information.
-         *
-         * \return A refereence to the stored Capabilities Information 
-         * field.
-         */
-        capability_information& capabilities() { return _body.capability; }
+    /**
+     * \brief Getter for the Capabilities Information.
+     *
+     * \return A refereence to the stored Capabilities Information 
+     * field.
+     */
+    capability_information& capabilities() {
+        return body_.capability;
+    }
 
-        /**
-         * \brief Setter for the timestamp field.
-         *
-         * \param new_timestamp The timestamp to be set.
-         */
-        void timestamp(uint64_t new_timestamp);
+    /**
+     * \brief Setter for the timestamp field.
+     *
+     * \param new_timestamp The timestamp to be set.
+     */
+    void timestamp(uint64_t new_timestamp);
 
-        /**
-         * \brief Setter for the interval field.
-         *
-         * \param new_interval The interval to be set.
-         */
-        void interval(uint16_t new_interval);
+    /**
+     * \brief Setter for the interval field.
+     *
+     * \param new_interval The interval to be set.
+     */
+    void interval(uint16_t new_interval);
 
-        /**
-         * \brief Returns the frame's header length.
-         *
-         * \return An uint32_t with the header's size.
-         * \sa PDU::header_size()
-         */
-        uint32_t header_size() const;
+    /**
+     * \brief Returns the frame's header length.
+     *
+     * \return An uint32_t with the header's size.
+     * \sa PDU::header_size()
+     */
+    uint32_t header_size() const;
 
-        /**
-         * \brief Check wether this PDU matches the specified flag.
-         * \param flag The flag to match
-         * \sa PDU::matches_flag
-         */
-        bool matches_flag(PDUType flag) const {
-           return flag == pdu_flag || Dot11ManagementFrame::matches_flag(flag);
-        }
+    /**
+     * \brief Check wether this PDU matches the specified flag.
+     * \param flag The flag to match
+     * \sa PDU::matches_flag
+     */
+    bool matches_flag(PDUType flag) const {
+       return flag == pdu_flag || Dot11ManagementFrame::matches_flag(flag);
+    }
 
-        /**
-         * \brief Clones this PDU.
-         *
-         * \sa PDU::clone
-         */
-        Dot11Beacon *clone() const {
-            return new Dot11Beacon(*this);
-        }
+    /**
+     * \brief Clones this PDU.
+     *
+     * \sa PDU::clone
+     */
+    Dot11Beacon* clone() const {
+        return new Dot11Beacon(*this);
+    }
 
-        /**
-         * \brief Getter for the PDU's type.
-         * \sa PDU::pdu_type
-         */
-        PDUType pdu_type() const { return pdu_flag; }
-    private:
-        TINS_BEGIN_PACK
-        struct BeaconBody {
-            uint64_t timestamp;
-            uint16_t interval;
-            capability_information capability;
-        } TINS_END_PACK;
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
+private:
+    TINS_BEGIN_PACK
+    struct dot11_beacon_body {
+        uint64_t timestamp;
+        uint16_t interval;
+        capability_information capability;
+    } TINS_END_PACK;
 
-        void write_fixed_parameters(Memory::OutputMemoryStream& stream);
+    void write_fixed_parameters(Memory::OutputMemoryStream& stream);
+
+    dot11_beacon_body body_;
+};
 
-        BeaconBody _body;
-    };
 } // namespace Tins
 
 #endif // TINS_DOT11_DOT11_BEACON_H
diff --git a/include/tins/dot11/dot11_control.h b/include/tins/dot11/dot11_control.h
index 4c23e03..a83c5a7 100644
--- a/include/tins/dot11/dot11_control.h
+++ b/include/tins/dot11/dot11_control.h
@@ -38,7 +38,7 @@
 
 namespace Tins {
 /**
- * \brief Class that represents an 802.11 control frame.
+ * \brief Represents an IEEE 802.11 control frame.
  */
 class TINS_API Dot11Control : public Dot11 {
 public:
@@ -55,7 +55,7 @@ public:
      *
      * \param dst_addr The destination hardware address.
      */
-    Dot11Control(const address_type &dst_addr = address_type());
+    Dot11Control(const address_type& dst_addr = address_type());
 
     /**
      * \brief Constructs a Dot11Control object from a buffer and
@@ -71,13 +71,15 @@ public:
      * \param buffer The buffer from which this PDU will be constructed.
      * \param total_sz The total size of the buffer.
      */
-    Dot11Control(const uint8_t *buffer, uint32_t total_sz);
+    Dot11Control(const uint8_t* buffer, uint32_t total_sz);
 
     /**
      * \brief Getter for the PDU's type.
      * \sa PDU::pdu_type
      */
-    PDUType pdu_type() const { return PDU::DOT11_CONTROL; }
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
 
     /**
      * \brief Check wether this PDU matches the specified flag.
@@ -85,7 +87,7 @@ public:
      * \sa PDU::matches_flag
      */
     bool matches_flag(PDUType flag) const {
-       return flag == PDU::DOT11_CONTROL || Dot11::matches_flag(flag);
+       return flag == pdu_flag || Dot11::matches_flag(flag);
     }
 };
 
@@ -98,13 +100,15 @@ public:
     /**
      * \brief Getter for the target address field.
      */
-    address_type target_addr() const { return _taddr; }
+    address_type target_addr() const {
+        return taddr_;
+    }
 
     /**
      * \brief Setter for the target address field.
      * \param addr The new target address.
      */
-    void target_addr(const address_type &addr);
+    void target_addr(const address_type& addr);
 protected:
     /**
      * \brief Constructor for creating a 802.11 control frame TA PDU
@@ -115,8 +119,8 @@ protected:
      * \param dst_addr The destination hardware address.
      * \param target_addr The source hardware address.
      */
-    Dot11ControlTA(const address_type &dst_addr = address_type(), 
-                const address_type &target_addr = address_type());
+    Dot11ControlTA(const address_type& dst_addr = address_type(), 
+                const address_type& target_addr = address_type());
 
     /**
      * \brief Constructs a Dot11ControlTA object from a buffer and
@@ -132,7 +136,7 @@ protected:
      * \param buffer The buffer from which this PDU will be constructed.
      * \param total_sz The total size of the buffer.
      */
-    Dot11ControlTA(const uint8_t *buffer, uint32_t total_sz);
+    Dot11ControlTA(const uint8_t* buffer, uint32_t total_sz);
 
     /**
      * \brief Returns the 802.11 frame's header length.
@@ -146,13 +150,13 @@ protected:
      * \brief Getter for the control ta additional fields size.
      */
     uint32_t controlta_size() const { 
-        return static_cast<uint32_t>(_taddr.size() + sizeof(ieee80211_header)); 
+        return static_cast<uint32_t>(taddr_.size() + sizeof(dot11_header)); 
     }
 
     void write_ext_header(Memory::OutputMemoryStream& stream);
 private:
 
-    address_type _taddr;
+    address_type taddr_;
 };
 
 /**
@@ -174,8 +178,8 @@ public:
      * \param dst_addr The destination hardware address.
      * \param target_addr The source hardware address.
      */
-    Dot11RTS(const address_type &dst_addr = address_type(), 
-            const address_type &target_addr = address_type());
+    Dot11RTS(const address_type& dst_addr = address_type(), 
+             const address_type& target_addr = address_type());
                 
     /**
      * \brief Constructs a Dot11RTS object from a buffer and adds all 
@@ -190,14 +194,14 @@ public:
      * \param buffer The buffer from which this PDU will be constructed.
      * \param total_sz The total size of the buffer.
      */
-    Dot11RTS(const uint8_t *buffer, uint32_t total_sz);
+    Dot11RTS(const uint8_t* buffer, uint32_t total_sz);
 
     /**
      * \brief Clones this PDU.
      *
      * \sa PDU::clone
      */
-    Dot11RTS *clone() const {
+    Dot11RTS* clone() const {
         return new Dot11RTS(*this);
     }
 
@@ -205,7 +209,9 @@ public:
      * \brief Getter for the PDU's type.
      * \sa PDU::pdu_type
      */
-    PDUType pdu_type() const { return pdu_flag; }
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
 
     /**
      * \brief Check wether this PDU matches the specified flag.
@@ -233,8 +239,8 @@ public:
      * \param dst_addr The destination hardware address.
      * \param target_addr The source hardware address.
      */
-    Dot11PSPoll(const address_type &dst_addr = address_type(), 
-                const address_type &target_addr = address_type());
+    Dot11PSPoll(const address_type& dst_addr = address_type(), 
+                const address_type& target_addr = address_type());
 
     /**
      * \brief Constructs a Dot11PSPoll object from a buffer and
@@ -250,14 +256,14 @@ public:
      * \param buffer The buffer from which this PDU will be constructed.
      * \param total_sz The total size of the buffer.
      */
-    Dot11PSPoll(const uint8_t *buffer, uint32_t total_sz);
+    Dot11PSPoll(const uint8_t* buffer, uint32_t total_sz);
 
     /**
      * \brief Clones this PDU.
      *
      * \sa PDU::clone
      */
-    Dot11PSPoll *clone() const {
+    Dot11PSPoll* clone() const {
         return new Dot11PSPoll(*this);
     }
 
@@ -265,7 +271,9 @@ public:
      * \brief Getter for the PDU's type.
      * \sa PDU::pdu_type
      */
-    PDUType pdu_type() const { return pdu_flag; }
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
 
     /**
      * \brief Check wether this PDU matches the specified flag.
@@ -293,8 +301,8 @@ public:
      * \param dst_addr The destination hardware address.
      * \param target_addr The source hardware address.
      */
-    Dot11CFEnd(const address_type &dst_addr = address_type(), 
-            const address_type &target_addr = address_type());
+    Dot11CFEnd(const address_type& dst_addr = address_type(), 
+               const address_type& target_addr = address_type());
                 
     /**
      * \brief Constructs a Dot11CFEnd object from a buffer and adds 
@@ -310,14 +318,14 @@ public:
      * \param buffer The buffer from which this PDU will be constructed.
      * \param total_sz The total size of the buffer.
      */
-    Dot11CFEnd(const uint8_t *buffer, uint32_t total_sz);
+    Dot11CFEnd(const uint8_t* buffer, uint32_t total_sz);
 
     /**
      * \brief Clones this PDU.
      *
      * \sa PDU::clone
      */
-    Dot11CFEnd *clone() const {
+    Dot11CFEnd* clone() const {
         return new Dot11CFEnd(*this);
     }
 
@@ -325,7 +333,9 @@ public:
      * \brief Getter for the PDU's type.
      * \sa PDU::pdu_type
      */
-    PDUType pdu_type() const { return pdu_flag; }
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
 
     /**
      * \brief Check wether this PDU matches the specified flag.
@@ -333,7 +343,7 @@ public:
      * \sa PDU::matches_flag
      */
     bool matches_flag(PDUType flag) const {
-       return flag == pdu_flag || Dot11Control::matches_flag(flag);
+        return flag == pdu_flag || Dot11Control::matches_flag(flag);
     }
 };
 
@@ -353,8 +363,8 @@ public:
      * \param dst_addr The destination hardware address.
      * \param target_addr The source hardware address.
      */
-    Dot11EndCFAck(const address_type &dst_addr = address_type(), 
-                const address_type &target_addr = address_type());
+    Dot11EndCFAck(const address_type& dst_addr = address_type(), 
+                  const address_type& target_addr = address_type());
 
     /**
      * \brief Constructs a Dot11EndCFAck frame object from a buffer 
@@ -370,14 +380,14 @@ public:
      * \param buffer The buffer from which this PDU will be constructed.
      * \param total_sz The total size of the buffer.
      */
-    Dot11EndCFAck(const uint8_t *buffer, uint32_t total_sz);
+    Dot11EndCFAck(const uint8_t* buffer, uint32_t total_sz);
 
     /**
      * \brief Clones this PDU.
      *
      * \sa PDU::clone
      */
-    Dot11EndCFAck *clone() const {
+    Dot11EndCFAck* clone() const {
         return new Dot11EndCFAck(*this);
     }
 
@@ -385,7 +395,9 @@ public:
      * \brief Getter for the PDU's type.
      * \sa PDU::pdu_type
      */
-    PDUType pdu_type() const { return pdu_flag; }
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
 
     /**
      * \brief Check wether this PDU matches the specified flag.
@@ -393,7 +405,7 @@ public:
      * \sa PDU::matches_flag
      */
     bool matches_flag(PDUType flag) const {
-       return flag == pdu_flag || Dot11Control::matches_flag(flag);
+        return flag == pdu_flag || Dot11Control::matches_flag(flag);
     }
 };
 
@@ -412,7 +424,7 @@ public:
      *
      * \param dst_addr The destination hardware address.
      */
-    Dot11Ack(const address_type &dst_addr = address_type());
+    Dot11Ack(const address_type& dst_addr = address_type());
 
     /**
      * \brief Constructs a Dot11Ack frame object from a buffer and
@@ -428,14 +440,14 @@ public:
      * \param buffer The buffer from which this PDU will be constructed.
      * \param total_sz The total size of the buffer.
      */
-    Dot11Ack(const uint8_t *buffer, uint32_t total_sz);
+    Dot11Ack(const uint8_t* buffer, uint32_t total_sz);
 
     /**
      * \brief Clones this PDU.
      *
      * \sa PDU::clone
      */
-    Dot11Ack *clone() const {
+    Dot11Ack* clone() const {
         return new Dot11Ack(*this);
     }
 
@@ -443,7 +455,9 @@ public:
      * \brief Getter for the PDU's type.
      * \sa PDU::pdu_type
      */
-    PDUType pdu_type() const { return pdu_flag; }
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
 
     /**
      * \brief Check wether this PDU matches the specified flag.
@@ -451,7 +465,7 @@ public:
      * \sa PDU::matches_flag
      */
     bool matches_flag(PDUType flag) const {
-       return flag == pdu_flag || Dot11Control::matches_flag(flag);
+        return flag == pdu_flag || Dot11Control::matches_flag(flag);
     }
 };
 
@@ -474,8 +488,8 @@ public:
      * \param dst_addr The destination hardware address.
      * \param target_addr The source hardware address.
      */
-    Dot11BlockAckRequest(const address_type &dst_addr = address_type(), 
-                        const address_type &target_addr = address_type());
+    Dot11BlockAckRequest(const address_type& dst_addr = address_type(), 
+                         const address_type& target_addr = address_type());
 
     /**
      * \brief Constructs a Dot11BlockAckRequest object from a buffer 
@@ -491,7 +505,7 @@ public:
      * \param buffer The buffer from which this PDU will be constructed.
      * \param total_sz The total size of the buffer.
      */
-    Dot11BlockAckRequest(const uint8_t *buffer, uint32_t total_sz);
+    Dot11BlockAckRequest(const uint8_t* buffer, uint32_t total_sz);
 
     /* Getter */
 
@@ -501,9 +515,9 @@ public:
      */
     small_uint<4> bar_control() const { 
         #if TINS_IS_LITTLE_ENDIAN
-        return _bar_control & 0xf; 
+        return bar_control_ & 0xf; 
         #else
-        return (_bar_control >> 8) & 0xf; 
+        return (bar_control_ >> 8) & 0xf; 
         #endif
     }
 
@@ -513,9 +527,9 @@ public:
      */
     small_uint<12> start_sequence() const { 
         #if TINS_IS_LITTLE_ENDIAN
-        return (_start_sequence >> 4) & 0xfff; 
+        return (start_sequence_ >> 4) & 0xfff; 
         #else
-        return (Endian::le_to_host<uint16_t>(_start_sequence) >> 4) & 0xfff; 
+        return (Endian::le_to_host<uint16_t>(start_sequence_) >> 4) & 0xfff; 
         #endif
     }
     
@@ -525,9 +539,9 @@ public:
      */
     small_uint<4> fragment_number() const { 
         #if TINS_IS_LITTLE_ENDIAN
-        return _start_sequence & 0xf; 
+        return start_sequence_ & 0xf; 
         #else
-        return (_start_sequence >> 8) & 0xf; 
+        return (start_sequence_ >> 8) & 0xf; 
         #endif
     }
     
@@ -564,7 +578,7 @@ public:
      *
      * \sa PDU::clone
      */
-    Dot11BlockAckRequest *clone() const {
+    Dot11BlockAckRequest* clone() const {
         return new Dot11BlockAckRequest(*this);
     }
 
@@ -572,7 +586,9 @@ public:
      * \brief Getter for the PDU's type.
      * \sa PDU::pdu_type
      */
-    PDUType pdu_type() const { return pdu_flag; }
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
 
     /**
      * \brief Check wether this PDU matches the specified flag.
@@ -580,15 +596,13 @@ public:
      * \sa PDU::matches_flag
      */
     bool matches_flag(PDUType flag) const {
-       return flag == pdu_flag || Dot11Control::matches_flag(flag);
+        return flag == pdu_flag || Dot11Control::matches_flag(flag);
     }
 protected:
     void write_ext_header(Memory::OutputMemoryStream& stream);
 private:
-    void init_block_ack();
-
-    uint16_t _bar_control;
-    uint16_t _start_sequence;
+    uint16_t bar_control_;
+    uint16_t start_sequence_;
 };
 
 /**
@@ -615,8 +629,8 @@ public:
      * \param dst_addr The destination hardware address.
      * \param target_addr The source hardware address.
      */
-    Dot11BlockAck(const address_type &dst_addr = address_type(), 
-                const address_type &target_addr = address_type());
+    Dot11BlockAck(const address_type& dst_addr = address_type(), 
+                  const address_type& target_addr = address_type());
 
     /**
      * \brief Constructs a Dot11BlockAck frame object from a buffer 
@@ -632,7 +646,7 @@ public:
      * \param buffer The buffer from which this PDU will be constructed.
      * \param total_sz The total size of the buffer.
      */
-    Dot11BlockAck(const uint8_t *buffer, uint32_t total_sz);
+    Dot11BlockAck(const uint8_t* buffer, uint32_t total_sz);
 
     /* Getters */
 
@@ -642,9 +656,9 @@ public:
      */
     small_uint<4> bar_control() const { 
         #if TINS_IS_LITTLE_ENDIAN
-        return _bar_control & 0xf; 
+        return bar_control_ & 0xf; 
         #else
-        return (_bar_control >> 8) & 0xf; 
+        return (bar_control_ >> 8) & 0xf; 
         #endif
     }
 
@@ -654,9 +668,9 @@ public:
      */
     small_uint<12> start_sequence() const { 
         #if TINS_IS_LITTLE_ENDIAN
-        return (_start_sequence >> 4) & 0xfff; 
+        return (start_sequence_ >> 4) & 0xfff; 
         #else
-        return (Endian::le_to_host<uint16_t>(_start_sequence) >> 4) & 0xfff; 
+        return (Endian::le_to_host<uint16_t>(start_sequence_) >> 4) & 0xfff; 
         #endif
     }
     
@@ -666,9 +680,9 @@ public:
      */
     small_uint<4> fragment_number() const { 
         #if TINS_IS_LITTLE_ENDIAN
-        return _start_sequence & 0xf; 
+        return start_sequence_ & 0xf; 
         #else
-        return (_start_sequence >> 8) & 0xf; 
+        return (start_sequence_ >> 8) & 0xf; 
         #endif
     }
     
@@ -707,19 +721,23 @@ public:
      * 
      * \return The bitmap field.
      */
-    const uint8_t *bitmap() const { return _bitmap; }
+    const uint8_t* bitmap() const {
+        return bitmap_;
+    }
 
     /**
      * \brief Setter for the bitmap field.
      * \param bit The new bitmap field to be set.
      */
-    void bitmap(const uint8_t *bit);
+    void bitmap(const uint8_t* bit);
 
     /**
      * \brief Getter for the PDU's type.
      * \sa PDU::pdu_type
      */
-    PDUType pdu_type() const { return pdu_flag; }
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
 
     /**
      * \brief Check wether this PDU matches the specified flag.
@@ -727,7 +745,7 @@ public:
      * \sa PDU::matches_flag
      */
     bool matches_flag(PDUType flag) const {
-       return flag == pdu_flag || Dot11Control::matches_flag(flag);
+        return flag == pdu_flag || Dot11Control::matches_flag(flag);
     }
 
     /**
@@ -735,15 +753,16 @@ public:
      *
      * \sa PDU::clone
      */
-    Dot11BlockAck *clone() const {
+    Dot11BlockAck* clone() const {
         return new Dot11BlockAck(*this);
     }
 private:
-    void init_block_ack();
     void write_ext_header(Memory::OutputMemoryStream& stream);
 
-    uint16_t _bar_control, _start_sequence;
-    uint8_t _bitmap[bitmap_size];
+    uint16_t bar_control_, start_sequence_;
+    uint8_t bitmap_[bitmap_size];
 };
+
 } // namespace Tins
+
 #endif // TINS_DOT11_DOT11_CONTROL_H
diff --git a/include/tins/dot11/dot11_data.h b/include/tins/dot11/dot11_data.h
index 2680b00..a6d5eef 100644
--- a/include/tins/dot11/dot11_data.h
+++ b/include/tins/dot11/dot11_data.h
@@ -37,6 +37,9 @@
 
 namespace Tins {
 
+/**
+ * \brief Represents an IEEE 802.11 data frame
+ */
 class TINS_API Dot11Data : public Dot11 {
 public:
     /**
@@ -53,8 +56,8 @@ public:
      * \param dst_hw_addr The destination hardware address.
      * \param src_hw_addr The source hardware address.
      */
-    Dot11Data(const address_type &dst_hw_addr = address_type(), 
-            const address_type &src_hw_addr = address_type());
+    Dot11Data(const address_type& dst_hw_addr = address_type(), 
+              const address_type& src_hw_addr = address_type());
                 
     /**
      * \brief Constructs a Dot11Data object from a buffer and adds 
@@ -70,21 +73,25 @@ public:
      * \param buffer The buffer from which this PDU will be constructed.
      * \param total_sz The total size of the buffer.
      */
-    Dot11Data(const uint8_t *buffer, uint32_t total_sz);
+    Dot11Data(const uint8_t* buffer, uint32_t total_sz);
     
     /**
      * \brief Getter for the second address.
      *
      * \return The stored second address.
      */
-    address_type addr2() const { return _ext_header.addr2; }
+    address_type addr2() const {
+        return ext_header_.addr2;
+    }
 
     /**
      * \brief Getter for the third address.
      *
      * \return The stored third address.
      */
-    address_type addr3() const { return _ext_header.addr3; }
+    address_type addr3() const {
+        return ext_header_.addr3;
+    }
 
     /**
      * \brief Getter for the fragment number field.
@@ -93,9 +100,9 @@ public:
      */
     small_uint<4> frag_num() const { 
         #if TINS_IS_LITTLE_ENDIAN
-        return _ext_header.frag_seq & 0xf; 
+        return ext_header_.frag_seq & 0xf; 
         #else
-        return (_ext_header.frag_seq >> 8) & 0xf; 
+        return (ext_header_.frag_seq >> 8) & 0xf; 
         #endif
     }
 
@@ -106,9 +113,9 @@ public:
      */
     small_uint<12> seq_num() const { 
         #if TINS_IS_LITTLE_ENDIAN
-        return (_ext_header.frag_seq >> 4) & 0xfff; 
+        return (ext_header_.frag_seq >> 4) & 0xfff; 
         #else
-        return (Endian::le_to_host<uint16_t>(_ext_header.frag_seq) >> 4) & 0xfff; 
+        return (Endian::le_to_host<uint16_t>(ext_header_.frag_seq) >> 4) & 0xfff; 
         #endif
     }
 
@@ -117,21 +124,23 @@ public:
      *
      * \return The fourth address.
      */
-    address_type addr4() const { return _addr4; }
+    address_type addr4() const {
+        return addr4_;
+    }
 
     /**
      * \brief Setter for the second address.
      *
      * \param new_addr2 The second address to be set.
      */
-    void addr2(const address_type &new_addr2);
+    void addr2(const address_type& new_addr2);
 
     /**
      * \brief Setter for the third address.
      *
      * \param new_addr3 The third address to be set.
      */
-    void addr3(const address_type &new_addr3);
+    void addr3(const address_type& new_addr3);
 
     /**
      * \brief Setter for the fragment number field.
@@ -152,7 +161,7 @@ public:
      *
      * \param new_addr4 The fourth address to be set.
      */
-    void addr4(const address_type &new_addr4);
+    void addr4(const address_type& new_addr4);
 
     /**
      * \brief Retrieves the frame's source address.
@@ -163,10 +172,12 @@ public:
      * If FromDS == ToDS == 1, the return value is not defined.
      */
     address_type src_addr() const {
-        if(!from_ds() && !to_ds())
+        if (!from_ds() && !to_ds()) {
             return addr2();
-        if(!from_ds() && to_ds())
+        }
+        if (!from_ds() && to_ds()) {
             return addr2();
+        }
         return addr3();
     }
 
@@ -179,10 +190,12 @@ public:
      * If FromDS == ToDS == 1, the return value is not defined.
      */
     address_type dst_addr() const {
-        if(!from_ds() && !to_ds())
+        if (!from_ds() && !to_ds()) {
             return addr1();
-        if(!from_ds() && to_ds())
+        }
+        if (!from_ds() && to_ds()) {
             return addr3();
+        }
         return addr1();
     }
 
@@ -195,10 +208,12 @@ public:
      * If FromDS == ToDS == 1, the return value is not defined.
      */
     address_type bssid_addr() const {
-        if(!from_ds() && !to_ds())
+        if (!from_ds() && !to_ds()) {
             return addr3();
-        if(!from_ds() && to_ds())
+        }
+        if (!from_ds() && to_ds()) {
             return addr1();
+        }
         return addr2();
     }
 
@@ -214,7 +229,9 @@ public:
      * \brief Getter for the PDU's type.
      * \sa PDU::pdu_type
      */
-    PDUType pdu_type() const { return pdu_flag; }
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
 
     /**
      * \brief Check wether this PDU matches the specified flag.
@@ -230,32 +247,25 @@ public:
      *
      * \sa PDU::clone
      */
-    Dot11Data *clone() const {
+    Dot11Data* clone() const {
         return new Dot11Data(*this);
     }
 protected:
     TINS_BEGIN_PACK
-    struct ExtendedHeader {
+    struct dot11_extended_header {
         uint8_t addr2[address_type::address_size];
         uint8_t addr3[address_type::address_size];
         uint16_t frag_seq;
     } TINS_END_PACK;
     
     struct no_inner_pdu { };
-    Dot11Data(const uint8_t *buffer, uint32_t total_sz, no_inner_pdu);
+    Dot11Data(const uint8_t* buffer, uint32_t total_sz, no_inner_pdu);
 
-    uint32_t init(const uint8_t *buffer, uint32_t total_sz);
+    uint32_t init(const uint8_t* buffer, uint32_t total_sz);
     void write_ext_header(Memory::OutputMemoryStream& stream);
-
-    uint32_t data_frame_size() { 
-        return static_cast<uint32_t>(
-            Dot11::header_size() + sizeof(_ext_header) + 
-                ((from_ds() && to_ds()) ? _addr4.size() : 0)
-        ); 
-    }
 private:
-    ExtendedHeader _ext_header;
-    address_type _addr4;
+    dot11_extended_header ext_header_;
+    address_type addr4_;
 };
 
 class TINS_API Dot11QoSData : public Dot11Data {
@@ -274,8 +284,8 @@ public:
      * \param dst_hw_addr The destination hardware address.
      * \param src_hw_addr The source hardware address.
      */
-    Dot11QoSData(const address_type &dst_hw_addr = address_type(), 
-                const address_type &src_hw_addr = address_type());
+    Dot11QoSData(const address_type& dst_hw_addr = address_type(), 
+                 const address_type& src_hw_addr = address_type());
 
     /**
      * \brief Constructors Dot11QoSData object from a buffer and adds
@@ -291,14 +301,16 @@ public:
      * \param buffer The buffer from which this PDU will be constructed.
      * \param total_sz The total size of the buffer.
      */
-    Dot11QoSData(const uint8_t *buffer, uint32_t total_sz);
+    Dot11QoSData(const uint8_t* buffer, uint32_t total_sz);
     
     /**
      * \brief Getter for the QOS Control field.
      *
      * \return The stored QOS Control field value.
      */
-    uint16_t qos_control() const { return Endian::le_to_host(_qos_control); }
+    uint16_t qos_control() const {
+        return Endian::le_to_host(qos_control_);
+    }
 
     /**
      * \brief Setter for the QOS Control field.
@@ -320,7 +332,7 @@ public:
      *
      * \sa PDU::clone
      */
-    Dot11QoSData *clone() const {
+    Dot11QoSData* clone() const {
         return new Dot11QoSData(*this);
     }
 
@@ -328,7 +340,9 @@ public:
      * \brief Getter for the PDU's type.
      * \sa PDU::pdu_type
      */
-    PDUType pdu_type() const { return PDU::DOT11_QOS_DATA; }
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
 
     /**
      * \brief Check wether this PDU matches the specified flag.
@@ -336,12 +350,12 @@ public:
      * \sa PDU::matches_flag
      */
     bool matches_flag(PDUType flag) const {
-       return flag == PDU::DOT11_QOS_DATA || Dot11Data::matches_flag(flag);
+       return flag == pdu_flag || Dot11Data::matches_flag(flag);
     }
 private:
     void write_fixed_parameters(Memory::OutputMemoryStream& stream);
 
-    uint16_t _qos_control;
+    uint16_t qos_control_;
 };
 }
 
diff --git a/include/tins/dot11/dot11_mgmt.h b/include/tins/dot11/dot11_mgmt.h
index f2b86d0..7ebd336 100644
--- a/include/tins/dot11/dot11_mgmt.h
+++ b/include/tins/dot11/dot11_mgmt.h
@@ -40,7 +40,7 @@
 
 namespace Tins {
 /**
- * \brief Abstract class that englobes all Management frames in the 802.11 protocol.
+ * \brief Base class for all management frames in the IEEE 802.11 protocol.
  */
 class TINS_API Dot11ManagementFrame : public Dot11 {
 public:
@@ -132,39 +132,39 @@ public:
     class capability_information {
     private:
         #if TINS_IS_LITTLE_ENDIAN
-            uint16_t _ess:1,
-                     _ibss:1,
-                     _cf_poll:1,
-                     _cf_poll_req:1,
-                     _privacy:1,
-                     _short_preamble:1,
-                     _pbcc:1,
-                     _channel_agility:1,
-                     _spectrum_mgmt:1,
-                     _qos:1,
-                     _sst:1,
-                     _apsd:1,
-                     _radio_measurement:1,
-                     _dsss_ofdm:1,
-                     _delayed_block_ack:1,
-                     _immediate_block_ack:1;
+            uint16_t ess_:1,
+                     ibss_:1,
+                     cf_poll_:1,
+                     cf_poll_req_:1,
+                     privacy_:1,
+                     short_preamble_:1,
+                     pbcc_:1,
+                     channel_agility_:1,
+                     spectrum_mgmt_:1,
+                     qos_:1,
+                     sst_:1,
+                     apsd_:1,
+                     radio_measurement_:1,
+                     dsss_ofdm_:1,
+                     delayed_block_ack_:1,
+                     immediate_block_ack_:1;
         #elif TINS_IS_BIG_ENDIAN
-            uint16_t _channel_agility:1,
-                     _pbcc:1,
-                     _short_preamble:1,
-                     _privacy:1,
-                     _cf_poll_req:1,
-                     _cf_poll:1,
-                     _ibss:1,
-                     _ess:1,
-                     _immediate_block_ack:1,
-                     _delayed_block_ack:1,
-                     _dsss_ofdm:1,
-                     _radio_measurement:1,
-                     _apsd:1,
-                     _sst:1,
-                     _qos:1,
-                     _spectrum_mgmt:1;
+            uint16_t channel_agility_:1,
+                     pbcc_:1,
+                     short_preamble_:1,
+                     privacy_:1,
+                     cf_poll_req_:1,
+                     cf_poll_:1,
+                     ibss_:1,
+                     ess_:1,
+                     immediate_block_ack_:1,
+                     delayed_block_ack_:1,
+                     dsss_ofdm_:1,
+                     radio_measurement_:1,
+                     apsd_:1,
+                     sst_:1,
+                     qos_:1,
+                     spectrum_mgmt_:1;
         #endif
     public:
         /**
@@ -172,225 +172,288 @@ public:
          *
          * \return Bool indicating the flag's value.
          */
-        bool ess() const { return _ess; }
+        bool ess() const {
+            return ess_;
+        }
 
         /**
          * \brief Getter for the ibss flag.
          *
          * \return Bool indicating the flag's value.
          */
-        bool ibss() const { return _ibss; }
+        bool ibss() const {
+            return ibss_;
+        }
 
         /**
          * \brief Getter for the cf_poll flag.
          *
          * \return Bool indicating the flag's value.
          */
-        bool cf_poll() const { return _cf_poll; }
+        bool cf_poll() const {
+            return cf_poll_;
+        }
 
         /**
          * \brief Getter for the cf_poll_req flag.
          *
          * \return Bool indicating the flag's value.
          */
-        bool cf_poll_req() const { return _cf_poll_req; }
+        bool cf_poll_req() const {
+            return cf_poll_req_;
+        }
 
         /**
          * \brief Getter for the privacy flag.
          *
          * \return Bool indicating the flag's value.
          */
-        bool privacy() const { return _privacy; }
+        bool privacy() const {
+            return privacy_;
+        }
 
         /**
          * \brief Getter for the short_preamble flag.
          *
          * \return Bool indicating the flag's value.
          */
-        bool short_preamble() const { return _short_preamble; }
+        bool short_preamble() const {
+            return short_preamble_;
+        }
 
         /**
          * \brief Getter for the pbcc flag.
          *
          * \return Bool indicating the flag's value.
          */
-        bool pbcc() const { return _pbcc; }
+        bool pbcc() const {
+            return pbcc_;
+        }
 
         /**
          * \brief Getter for the channel_agility flag.
          *
          * \return Bool indicating the flag's value.
          */
-        bool channel_agility() const { return _channel_agility; }
+        bool channel_agility() const {
+            return channel_agility_;
+        }
 
         /**
          * \brief Getter for the spectrum_mgmt flag.
          *
          * \return Bool indicating the flag's value.
          */
-        bool spectrum_mgmt() const { return _spectrum_mgmt; }
+        bool spectrum_mgmt() const {
+            return spectrum_mgmt_;
+        }
 
         /**
          * \brief Getter for the qos flag.
          *
          * \return Bool indicating the flag's value.
          */
-        bool qos() const { return _qos; }
+        bool qos() const {
+            return qos_;
+        }
 
         /**
          * \brief Getter for the sst flag.
          *
          * \return Bool indicating the flag's value.
          */
-        bool sst() const { return _sst; }
+        bool sst() const {
+            return sst_;
+        }
 
         /**
          * \brief Getter for the apsd flag.
          *
          * \return Bool indicating the flag's value.
          */
-        bool apsd() const { return _apsd; }
+        bool apsd() const {
+            return apsd_;
+        }
 
         /**
          * \brief Getter for the radio measurement flag.
          *
          * \return Bool indicating the flag's value.
          */
-        bool radio_measurement() const { return _radio_measurement; }
+        bool radio_measurement() const {
+            return radio_measurement_;
+        }
 
         /**
          * \brief Getter for the dsss_ofdm flag.
          *
          * \return Bool indicating the flag's value.
          */
-        bool dsss_ofdm() const { return _dsss_ofdm; }
+        bool dsss_ofdm() const {
+            return dsss_ofdm_;
+        }
 
         /**
          * \brief Getter for the delayed_block_ack flag.
          *
          * \return Bool indicating the flag's value.
          */
-        bool delayed_block_ack() const { return _delayed_block_ack; }
+        bool delayed_block_ack() const {
+            return delayed_block_ack_;
+        }
 
         /**
          * \brief Getter for the immediate_block_ack flag.
          *
          * \return Bool indicating the flag's value.
          */
-        bool immediate_block_ack() const { return _immediate_block_ack; }
+        bool immediate_block_ack() const {
+            return immediate_block_ack_;
+        }
 
         /**
          * \brief Setter for the ess flag.
          *
          * \param new_value bool indicating the flag's new value.
          */
-        void ess(bool new_value) { _ess = new_value; }
+        void ess(bool new_value) {
+            ess_ = new_value;
+        }
 
         /**
          * \brief Setter for the ibss flag.
          *
          * \param new_value bool indicating the flag's new value.
          */
-        void ibss(bool new_value) { _ibss = new_value; }
+        void ibss(bool new_value) {
+            ibss_ = new_value;
+        }
 
         /**
          * \brief Setter for the cf_poll flag.
          *
          * \param new_value bool indicating the flag's new value.
          */
-        void cf_poll(bool new_value) { _cf_poll = new_value; }
+        void cf_poll(bool new_value) {
+            cf_poll_ = new_value;
+        }
 
         /**
          * \brief Setter for the cf_poll_req flag.
          *
          * \param new_value bool indicating the flag's new value.
          */
-        void cf_poll_req(bool new_value) { _cf_poll_req = new_value; }
+        void cf_poll_req(bool new_value) {
+            cf_poll_req_ = new_value;
+        }
 
         /**
          * \brief Setter for the privacy flag.
          *
          * \param new_value bool indicating the flag's new value.
          */
-        void privacy(bool new_value) { _privacy = new_value; }
+        void privacy(bool new_value) {
+            privacy_ = new_value;
+        }
 
         /**
          * \brief Setter for the short_preamble flag.
          *
          * \param new_value bool indicating the flag's new value.
          */
-        void short_preamble(bool new_value) { _short_preamble = new_value; }
+        void short_preamble(bool new_value) {
+            short_preamble_ = new_value;
+        }
 
         /**
          * \brief Setter for the pbcc flag.
          *
          * \param new_value bool indicating the flag's new value.
          */
-        void pbcc(bool new_value) { _pbcc = new_value; }
+        void pbcc(bool new_value) {
+            pbcc_ = new_value;
+        }
 
         /**
          * \brief Setter for the channel_agility flag.
          *
          * \param new_value bool indicating the flag's new value.
          */
-        void channel_agility(bool new_value) { _channel_agility = new_value; }
+        void channel_agility(bool new_value) {
+            channel_agility_ = new_value;
+        }
 
         /**
          * \brief Setter for the spectrum_mgmt flag.
          *
          * \param new_value bool indicating the flag's new value.
          */
-        void spectrum_mgmt(bool new_value) { _spectrum_mgmt = new_value; }
+        void spectrum_mgmt(bool new_value) {
+            spectrum_mgmt_ = new_value;
+        }
 
         /**
          * \brief Setter for the qos flag.
          *
          * \param new_value bool indicating the flag's new value.
          */
-        void qos(bool new_value) { _qos = new_value; }
+        void qos(bool new_value) {
+            qos_ = new_value;
+        }
 
         /**
          * \brief Setter for the sst flag.
          *
          * \param new_value bool indicating the flag's new value.
          */
-        void sst(bool new_value) { _sst = new_value; }
+        void sst(bool new_value) {
+            sst_ = new_value;
+        }
 
         /**
          * \brief Setter for the apsd flag.
          *
          * \param new_value bool indicating the flag's new value.
          */
-        void apsd(bool new_value) { _apsd = new_value; }
+        void apsd(bool new_value) {
+            apsd_ = new_value;
+        }
 
         /**
          * \brief Setter for the radio measurement flag.
          *
          * \param new_value bool indicating the flag's new value.
          */
-        void radio_measurement(bool new_value) { _radio_measurement = new_value; }
+        void radio_measurement(bool new_value) {
+            radio_measurement_ = new_value;
+        }
 
         /**
          * \brief Setter for the dsss_ofdm flag.
          *
          * \param new_value bool indicating the flag's new value.
          */
-        void dsss_ofdm(bool new_value) { _dsss_ofdm = new_value; }
+        void dsss_ofdm(bool new_value) {
+            dsss_ofdm_ = new_value;
+        }
 
         /**
          * \brief Setter for the delayed_block_ack flag.
          *
          * \param new_value bool indicating the flag's new value.
          */
-        void delayed_block_ack(bool new_value) { _delayed_block_ack = new_value; }
+        void delayed_block_ack(bool new_value) {
+            delayed_block_ack_ = new_value;
+        }
 
         /**
          * \brief Setter for the immediate_block_ack flag.
          *
          * \param new_value bool indicating the flag's new value.
          */
-        void immediate_block_ack(bool new_value) { _immediate_block_ack = new_value; }
-
+        void immediate_block_ack(bool new_value) {
+            immediate_block_ack_ = new_value;
+        }
     } TINS_END_PACK;
     
     /**
@@ -402,12 +465,14 @@ public:
         
         fh_params_set() {}
         
-        fh_params_set(uint16_t dwell_time, uint8_t hop_set, 
-          uint8_t hop_pattern, uint8_t hop_index) 
+        fh_params_set(uint16_t dwell_time, 
+                      uint8_t hop_set, 
+                      uint8_t hop_pattern,
+                      uint8_t hop_index) 
         : dwell_time(dwell_time), hop_set(hop_set), 
           hop_pattern(hop_pattern), hop_index(hop_index) {}
 
-        static fh_params_set from_option(const option &opt);
+        static fh_params_set from_option(const option& opt);
     };
     
     /**
@@ -419,13 +484,15 @@ public:
         
         cf_params_set() {}
         
-        cf_params_set(uint8_t cfp_count, uint8_t cfp_period,
-          uint16_t cfp_max_duration, uint16_t cfp_dur_remaining) 
+        cf_params_set(uint8_t cfp_count, 
+                      uint8_t cfp_period,
+                      uint16_t cfp_max_duration,
+                      uint16_t cfp_dur_remaining) 
         : cfp_count(cfp_count), cfp_period(cfp_period), 
           cfp_max_duration(cfp_max_duration), 
           cfp_dur_remaining(cfp_dur_remaining) {}
 
-        static cf_params_set from_option(const option &opt);
+        static cf_params_set from_option(const option& opt);
     };
     
     /**
@@ -440,12 +507,13 @@ public:
        
         ibss_dfs_params() {}
        
-        ibss_dfs_params(const address_type &addr, 
-          uint8_t recovery_interval, const channel_map_type &channel_map)
+        ibss_dfs_params(const address_type& addr, 
+                        uint8_t recovery_interval,
+                        const channel_map_type& channel_map)
         : dfs_owner(addr), recovery_interval(recovery_interval),
           channel_map(channel_map) {}
 
-        static ibss_dfs_params from_option(const option &opt);
+        static ibss_dfs_params from_option(const option& opt);
     };
     
     /**
@@ -460,12 +528,14 @@ public:
         
         country_params() {}
         
-        country_params(const std::string &country, const byte_array &first,
-          const byte_array &number, const byte_array &max) 
+        country_params(const std::string& country, 
+                       const byte_array& first,
+                       const byte_array& number,
+                       const byte_array& max) 
         : country(country), first_channel(first), number_channels(number),
           max_transmit_power(max) {}
 
-        static country_params from_option(const option &opt);
+        static country_params from_option(const option& opt);
     };
     
     /**
@@ -479,12 +549,15 @@ public:
         
         fh_pattern_type() {}
         
-        fh_pattern_type(uint8_t flag, uint8_t sets, uint8_t modulus,
-          uint8_t offset, const byte_array& table) 
+        fh_pattern_type(uint8_t flag, 
+                        uint8_t sets,
+                        uint8_t modulus,
+                        uint8_t offset,
+                        const byte_array& table) 
         : flag(flag), number_of_sets(sets), modulus(modulus), 
           offset(offset), random_table(table) {}
 
-        static fh_pattern_type from_option(const option &opt);
+        static fh_pattern_type from_option(const option& opt);
     };
     
     /**
@@ -495,10 +568,12 @@ public:
         
         channel_switch_type() {}
         
-        channel_switch_type(uint8_t mode, uint8_t channel, uint8_t count)
+        channel_switch_type(uint8_t mode, 
+                            uint8_t channel,
+                            uint8_t count)
         : switch_mode(mode), new_channel(channel), switch_count(count) { }
 
-        static channel_switch_type from_option(const option &opt);
+        static channel_switch_type from_option(const option& opt);
     };
     
     /**
@@ -510,12 +585,14 @@ public:
         
         quiet_type() {}
         
-        quiet_type(uint8_t count, uint8_t period, uint16_t duration,
-          uint16_t offset)
+        quiet_type(uint8_t count, 
+                   uint8_t period,
+                   uint16_t duration,
+                   uint16_t offset)
         : quiet_count(count), quiet_period(period), 
         quiet_duration(duration), quiet_offset(offset) {}
 
-        static quiet_type from_option(const option &opt);
+        static quiet_type from_option(const option& opt);
     };
 
     /**
@@ -528,12 +605,11 @@ public:
         
         bss_load_type() {}
         
-        bss_load_type(uint16_t count, uint8_t utilization, 
-          uint16_t capacity) 
+        bss_load_type(uint16_t count, uint8_t utilization, uint16_t capacity) 
         : station_count(count), available_capacity(capacity),
         channel_utilization(utilization) {}
 
-        static bss_load_type from_option(const option &opt);
+        static bss_load_type from_option(const option& opt);
     };
     
     /**
@@ -545,12 +621,14 @@ public:
         
         tim_type() {}
         
-        tim_type(uint8_t count, uint8_t period, uint8_t control,
-          const byte_array &bitmap) 
+        tim_type(uint8_t count, 
+                 uint8_t period,
+                 uint8_t control,
+                 const byte_array& bitmap) 
         : dtim_count(count), dtim_period(period), bitmap_control(control),
         partial_virtual_bitmap(bitmap) {}
 
-        static tim_type from_option(const option &opt);
+        static tim_type from_option(const option& opt);
     };
 
     /**
@@ -562,11 +640,11 @@ public:
         oui_type oui;
         byte_array data;
 
-        vendor_specific_type(const oui_type &oui = oui_type(),
-            const byte_array &data = byte_array())
+        vendor_specific_type(const oui_type& oui = oui_type(),
+                             const byte_array& data = byte_array())
         : oui(oui), data(data) { }
 
-        static vendor_specific_type from_bytes(const uint8_t *buffer, uint32_t sz);
+        static vendor_specific_type from_bytes(const uint8_t* buffer, uint32_t sz);
     };
     
     /**
@@ -579,14 +657,18 @@ public:
      *
      * \return address_type containing the second address.
      */
-    address_type addr2() const { return _ext_header.addr2; }
+    address_type addr2() const {
+        return ext_header_.addr2;
+    }
 
     /**
      * \brief Getter for the third address.
      *
      * \return address_type containing the third address.
      */
-    address_type addr3() const { return _ext_header.addr3; }
+    address_type addr3() const {
+        return ext_header_.addr3;
+    }
 
     /**
      * \brief Getter for the fragment number.
@@ -595,9 +677,9 @@ public:
      */
     small_uint<4> frag_num() const { 
         #if TINS_IS_LITTLE_ENDIAN
-        return _ext_header.frag_seq & 0xf; 
+        return ext_header_.frag_seq & 0xf; 
         #else
-        return (_ext_header.frag_seq >> 8) & 0xf; 
+        return (ext_header_.frag_seq >> 8) & 0xf; 
         #endif
     }
 
@@ -608,9 +690,9 @@ public:
      */
     small_uint<12> seq_num() const { 
         #if TINS_IS_LITTLE_ENDIAN
-        return (_ext_header.frag_seq >> 4) & 0xfff; 
+        return (ext_header_.frag_seq >> 4) & 0xfff; 
         #else
-        return (Endian::le_to_host<uint16_t>(_ext_header.frag_seq) >> 4) & 0xfff; 
+        return (Endian::le_to_host<uint16_t>(ext_header_.frag_seq) >> 4) & 0xfff; 
         #endif
     }
 
@@ -619,21 +701,23 @@ public:
      *
      * \return The stored fourth address.
      */
-    const address_type &addr4() const { return _addr4; }
+    const address_type& addr4() const {
+        return addr4_;
+    }
 
     /**
      * \brief Setter for the second address.
      *
      * \param new_addr2 The new second address to be set.
      */
-    void addr2(const address_type &new_addr2);
+    void addr2(const address_type& new_addr2);
 
     /**
      * \brief Setter for the third address.
      *
      * \param new_addr3 The new third address to be set.
      */
-    void addr3(const address_type &new_addr3);
+    void addr3(const address_type& new_addr3);
 
     /**
      * \brief Setter for the fragment number.
@@ -654,7 +738,7 @@ public:
      *
      * \param new_addr4 The new fourth address to be set.
      */
-    void addr4(const address_type &new_addr4);
+    void addr4(const address_type& new_addr4);
 
     // Option setter helpers
 
@@ -663,7 +747,7 @@ public:
      *
      * \param new_ssid The SSID to be set.
      */
-    void ssid(const std::string &new_ssid);
+    void ssid(const std::string& new_ssid);
 
     /**
      * \brief Helper method to set the RSN information option.
@@ -677,14 +761,14 @@ public:
      *
      * \param new_rates The new rates to be set.
      */
-    void supported_rates(const rates_type &new_rates);
+    void supported_rates(const rates_type& new_rates);
 
     /**
      * \brief Helper method to set the extended supported rates option.
      *
      * \param new_rates The new rates to be set.
      */
-    void extended_supported_rates(const rates_type &new_rates);
+    void extended_supported_rates(const rates_type& new_rates);
 
     /**
      * \brief Helper method to set the QoS capabilities option.
@@ -710,7 +794,7 @@ public:
      *
      * \param new_channels A list of channels to be set.
      */
-    void supported_channels(const channels_type &new_channels);
+    void supported_channels(const channels_type& new_channels);
 
     /**
      * \brief Helper method to set the EDCA Parameter Set.
@@ -734,7 +818,7 @@ public:
      *
      * \param fh_params The new FH parameter set value.
      */
-    void fh_parameter_set(const fh_params_set &fh_params);
+    void fh_parameter_set(const fh_params_set& fh_params);
 
     /**
      * \brief Helper method to set the DS parameter tagged option.
@@ -748,7 +832,7 @@ public:
      *
      * \param params The new CF parameter set value.
      */
-    void cf_parameter_set(const cf_params_set &params);
+    void cf_parameter_set(const cf_params_set& params);
 
     /**
      * \brief Helper method to set the IBSS parameter set tagged option.
@@ -762,14 +846,14 @@ public:
      *
      * \param params The IBSS DFS data to be set.
      */
-    void ibss_dfs(const ibss_dfs_params &params);
+    void ibss_dfs(const ibss_dfs_params& params);
 
     /**
      * \brief Helper method to set the country tagged option.
      *
      * \param params The data to be used for this country option.
      */
-    void country(const country_params &params);
+    void country(const country_params& params);
 
     /**
      * \brief Helper method to set the FH parameters set tagged option.
@@ -784,7 +868,7 @@ public:
      *
      * \param params The data to be used for this FH pattern table option.
      */
-    void fh_pattern_table(const fh_pattern_type &params);
+    void fh_pattern_table(const fh_pattern_type& params);
 
     /**
      * \brief Helper method to set the Power Constraint tagged option.
@@ -798,14 +882,14 @@ public:
      *
      * \param data The value of the Channel Switch option.
      */
-    void channel_switch(const channel_switch_type &data);
+    void channel_switch(const channel_switch_type& data);
 
     /**
      * \brief Helper method to set the Quiet tagged option.
      *
      * \param data The value of the quiet count field.
      */
-    void quiet(const quiet_type &data);
+    void quiet(const quiet_type& data);
 
     /**
      * \brief Helper method to set the TPC Report tagged option.
@@ -827,28 +911,28 @@ public:
      *
      * \param data The value to set in this bss load option.
      */
-    void bss_load(const bss_load_type &data);
+    void bss_load(const bss_load_type& data);
 
     /**
      * \brief Helper method to set the TIM tagged option.
      *
      * \brief data The value to set in this tim option.
      */
-    void tim(const tim_type &data);
+    void tim(const tim_type& data);
 
     /**
      * \brief Helper method to set the Challenge Text tagged option.
      *
      * \brief text The challenge text to be added.
      */
-    void challenge_text(const std::string &text);
+    void challenge_text(const std::string& text);
 
     /**
      * \brief Helper method to add a Vendor Specific tagged option.
      *
      * \brief text The option to be added.
      */
-    void vendor_specific(const vendor_specific_type &data);
+    void vendor_specific(const vendor_specific_type& data);
     
     // Option searching helpers
     
@@ -1123,7 +1207,9 @@ public:
      *
      * \sa PDU::pdu_type
      */
-    PDUType pdu_type() const { return pdu_flag; }
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
 
     /**
      * \brief Check wether this PDU matches the specified flag.
@@ -1135,15 +1221,15 @@ public:
     }
 protected:
     TINS_BEGIN_PACK
-    struct ExtendedHeader {
+    struct dot11_extended_header {
         uint8_t addr2[address_type::address_size];
         uint8_t addr3[address_type::address_size];
         uint16_t frag_seq;
     } TINS_END_PACK;
 
     
-    Dot11ManagementFrame(const address_type &dst_hw_addr = address_type(), 
-                        const address_type &src_hw_addr = address_type());
+    Dot11ManagementFrame(const address_type& dst_hw_addr = address_type(), 
+                         const address_type& src_hw_addr = address_type());
     
     /**
      * \brief Constructs a Dot11ManagementFrame object from a buffer 
@@ -1159,29 +1245,30 @@ protected:
      * \param buffer The buffer from which this PDU will be constructed.
      * \param total_sz The total size of the buffer.
      */
-    Dot11ManagementFrame(const uint8_t *buffer, uint32_t total_sz);
+    Dot11ManagementFrame(const uint8_t* buffer, uint32_t total_sz);
 
     void write_ext_header(Memory::OutputMemoryStream& stream);
 
     uint32_t management_frame_size() { 
-        return sizeof(ieee80211_header) + sizeof(_ext_header) + 
-                ((from_ds() && to_ds()) ? address_type::address_size : 0); 
+        return Dot11ManagementFrame::header_size();
     }
 private:
-    static uint8_t *serialize_rates(const rates_type &rates);
-    static rates_type deserialize_rates(const option *option);
+    static std::vector<uint8_t> serialize_rates(const rates_type& rates);
+    static rates_type deserialize_rates(const option* option);
     
     template<typename T>
     T search_and_convert(OptionTypes opt_type) const {
-        const option *opt = search_option(opt_type);
-        if(!opt)
+        const option* opt = search_option(opt_type);
+        if (!opt) {
             throw option_not_found();
+        }
         return opt->to<T>();
     }
 
-    ExtendedHeader _ext_header;
-    address_type _addr4;
+    dot11_extended_header ext_header_;
+    address_type addr4_;
 };
+
 } // namespace Tins
 
 #endif // TINS_DOT11_DOT11_MGMT_H
diff --git a/include/tins/dot11/dot11_probe.h b/include/tins/dot11/dot11_probe.h
index 1337551..b899c35 100644
--- a/include/tins/dot11/dot11_probe.h
+++ b/include/tins/dot11/dot11_probe.h
@@ -57,8 +57,8 @@ public:
      * \param dst_hw_addr The destination hardware address.
      * \param src_hw_addr The source hardware address.
      */
-    Dot11ProbeRequest(const address_type &dst_hw_addr = address_type(), 
-                    const address_type &src_hw_addr = address_type());
+    Dot11ProbeRequest(const address_type& dst_hw_addr = address_type(), 
+                      const address_type& src_hw_addr = address_type());
 
     /**
      * \brief Constructs a Dot11ProbeRequest object from a buffer 
@@ -74,13 +74,15 @@ public:
      * \param buffer The buffer from which this PDU will be constructed.
      * \param total_sz The total size of the buffer.
      */
-    Dot11ProbeRequest(const uint8_t *buffer, uint32_t total_sz);
+    Dot11ProbeRequest(const uint8_t* buffer, uint32_t total_sz);
 
     /**
      * \brief Getter for the PDU's type.
      * \sa PDU::pdu_type
      */
-    PDUType pdu_type() const { return PDU::DOT11_PROBE_REQ; }
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
 
     /**
      * \brief Check wether this PDU matches the specified flag.
@@ -122,8 +124,8 @@ public:
      * \param dst_hw_addr The destination hardware address.
      * \param src_hw_addr The source hardware address.
      */
-    Dot11ProbeResponse(const address_type &dst_hw_addr = address_type(), 
-                    const address_type &src_hw_addr = address_type());
+    Dot11ProbeResponse(const address_type& dst_hw_addr = address_type(), 
+                       const address_type& src_hw_addr = address_type());
 
     /**
      * \brief Constructs a Dot11ProbeResponse object from a buffer 
@@ -139,21 +141,25 @@ public:
      * \param buffer The buffer from which this PDU will be constructed.
      * \param total_sz The total size of the buffer.
      */
-    Dot11ProbeResponse(const uint8_t *buffer, uint32_t total_sz);
+    Dot11ProbeResponse(const uint8_t* buffer, uint32_t total_sz);
 
     /**
      * \brief Getter for the timestamp field.
      *
      * \return The stored timestamp value.
      */
-    uint64_t timestamp() const { return Endian::le_to_host(_body.timestamp); }
+    uint64_t timestamp() const {
+        return Endian::le_to_host(body_.timestamp);
+    }
 
     /**
      * \brief Getter for the interval field.
      *
      * \return The stored interval value.
      */
-    uint16_t interval() const { return Endian::le_to_host(_body.interval); }
+    uint16_t interval() const {
+        return Endian::le_to_host(body_.interval);
+    }
 
     /**
      * \brief Getter for the Capabilities Information.
@@ -161,7 +167,9 @@ public:
      * \return A constant reference to the stored Capabilities 
      * Information field.
      */
-    const capability_information& capabilities() const { return _body.capability;}
+    const capability_information& capabilities() const {
+        return body_.capability;
+    }
 
     /**
      * \brief Getter for the Capabilities Information.
@@ -169,7 +177,9 @@ public:
      * \return A reference to the stored Capabilities Information 
      * field.
      */
-    capability_information& capabilities() { return _body.capability;}
+    capability_information& capabilities() {
+        return body_.capability;
+    }
 
     /**
      * \brief Setter for the timestamp field.
@@ -214,21 +224,21 @@ public:
      * \sa PDU::matches_flag
      */
     bool matches_flag(PDUType flag) const {
-       return flag == pdu_flag || Dot11ManagementFrame::matches_flag(flag);
+        return flag == pdu_flag || Dot11ManagementFrame::matches_flag(flag);
     }
-protected:
-
 private:
+    void write_fixed_parameters(Memory::OutputMemoryStream& stream);
+
     TINS_BEGIN_PACK
-    struct ProbeResp {
+    struct dot11_probe_response_header {
         uint64_t timestamp;
         uint16_t interval;
         capability_information capability;
     } TINS_END_PACK;
 
-    ProbeResp _body;
-
-    void write_fixed_parameters(Memory::OutputMemoryStream& stream);
+    dot11_probe_response_header body_;
 };
+
 } // namespace Tins
+
 #endif // TINS_DOT11_DOT11_PROBE_H
diff --git a/include/tins/dot1q.h b/include/tins/dot1q.h
index c56b6be..c6f4c11 100644
--- a/include/tins/dot1q.h
+++ b/include/tins/dot1q.h
@@ -36,6 +36,7 @@
 #include "small_uint.h"
 
 namespace Tins {
+
 /**
  * \class Dot1Q
  * Represents an IEEE 802.1q PDU.
@@ -65,7 +66,7 @@ public:
      * \param buffer The buffer from which this PDU will be constructed.
      * \param total_sz The total size of the buffer.
      */
-    Dot1Q(const uint8_t *buffer, uint32_t total_sz);
+    Dot1Q(const uint8_t* buffer, uint32_t total_sz);
 
     // Getters
 
@@ -87,7 +88,7 @@ public:
      * \return The stored priority field value.
      */
     small_uint<3> priority() const {
-        return _header.priority;
+        return header_.priority;
     }
 
     /**
@@ -95,7 +96,7 @@ public:
      * \return The stored CFI field value.
      */
     small_uint<1> cfi() const {
-        return _header.cfi;
+        return header_.cfi;
     }
 
     /**
@@ -104,9 +105,9 @@ public:
      */
     small_uint<12> id() const {
         #if TINS_IS_LITTLE_ENDIAN
-            return _header.idL | (_header.idH << 8);
+            return header_.idL | (header_.idH << 8);
         #else
-            return _header.id;
+            return header_.id;
         #endif
     }
 
@@ -115,19 +116,21 @@ public:
      * \return The stored type field value.
      */
     uint16_t payload_type() const {
-        return Endian::be_to_host(_header.type);
+        return Endian::be_to_host(header_.type);
     }
 
     /**
      * \brief Getter for the PDU's type.
      * \sa PDU::pdu_type
      */
-    PDUType pdu_type() const { return pdu_flag; }
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
     
     /**
      * \sa PDU::clone
      */
-    Dot1Q *clone() const {
+    Dot1Q* clone() const {
         return new Dot1Q(*this);
     }
 
@@ -136,7 +139,7 @@ public:
      * appended at the end of this packet.
      */
     bool append_padding() const {
-        return _append_padding;
+        return append_padding_;
     }
 
     // Setters
@@ -184,9 +187,9 @@ public:
      * \param ptr The pointer to the buffer.
      * \param total_sz The size of the buffer.
      */
-    bool matches_response(const uint8_t *ptr, uint32_t total_sz) const;
+    bool matches_response(const uint8_t* ptr, uint32_t total_sz) const;
 private:
-    void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
 
     TINS_BEGIN_PACK
     struct dot1q_hdr {
@@ -204,10 +207,10 @@ private:
         #endif
     } TINS_END_PACK;
     
-    static uint16_t get_id(const dot1q_hdr *hdr);
+    static uint16_t get_id(const dot1q_hdr* hdr);
     
-    dot1q_hdr _header;
-    bool _append_padding;
+    dot1q_hdr header_;
+    bool append_padding_;
 };
 }
 
diff --git a/include/tins/dot3.h b/include/tins/dot3.h
index 96e62b1..f4756f2 100644
--- a/include/tins/dot3.h
+++ b/include/tins/dot3.h
@@ -39,157 +39,163 @@
 
 namespace Tins {
 
-    /** 
-     * \class Dot3
-     * \brief Class representing an IEEE 802.3 PDU.
+/** 
+ * \class Dot3
+ * \brief Class representing an IEEE 802.3 PDU.
+ */
+class TINS_API Dot3 : public PDU {
+public:
+    /**
+     * \brief The address type.
      */
-    class TINS_API Dot3 : public PDU {
-    public:
-        /**
-         * \brief The address type.
-         */
-        typedef HWAddress<6> address_type; 
-        
-        /**
-         * \brief This PDU's flag.
-         */
-        static const PDU::PDUType pdu_flag = PDU::IEEE802_3;
+    typedef HWAddress<6> address_type; 
+    
+    /**
+     * \brief This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::IEEE802_3;
 
-        /**
-         * \brief Represents the Dot3 broadcast address.
-         */
-        static const address_type BROADCAST;
+    /**
+     * \brief Represents the Dot3 broadcast address.
+     */
+    static const address_type BROADCAST;
 
-        /**
-         * \brief Constructor for creating an Dot3 PDU
-         *
-         * Constructor that builds an Dot3 PDU taking the interface name,
-         * destination's and source's MAC.
-         *
-         * \param dst_hw_addr The destination hardware address.
-         * \param src_hw_addr The source hardware address.
-         * \param child The PDU which will be set as the inner PDU.
-         */
-        Dot3(const address_type &dst_hw_addr = address_type(), 
-            const address_type &src_hw_addr = address_type());
+    /**
+     * \brief Constructor for creating an Dot3 PDU
+     *
+     * Constructor that builds an Dot3 PDU taking the interface name,
+     * destination's and source's MAC.
+     *
+     * \param dst_hw_addr The destination hardware address.
+     * \param src_hw_addr The source hardware address.
+     * \param child The PDU which will be set as the inner PDU.
+     */
+    Dot3(const address_type& dst_hw_addr = address_type(), 
+        const address_type& src_hw_addr = address_type());
 
-        /**
-         * \brief Constructs a Dot3 object from a buffer and adds a
-         * LLC object with the remaining data as the inner PDU.
-         * 
-         * If there is not enough size for a Dot3 header, a 
-         * malformed_packet exception is thrown.
-         * 
-         * \param buffer The buffer from which this PDU will be constructed.
-         * \param total_sz The total size of the buffer.
-         */
-        Dot3(const uint8_t *buffer, uint32_t total_sz);
+    /**
+     * \brief Constructs a Dot3 object from a buffer and adds a
+     * LLC object with the remaining data as the inner PDU.
+     * 
+     * If there is not enough size for a Dot3 header, a 
+     * malformed_packet exception is thrown.
+     * 
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    Dot3(const uint8_t* buffer, uint32_t total_sz);
 
-        /* Getters */
-        /**
-         * \brief Getter for the destination hardware address.
-         *
-         * \return The destination hardware address.
-         */
-        address_type dst_addr() const { return _eth.dst_mac; }
+    /* Getters */
+    /**
+     * \brief Getter for the destination hardware address.
+     *
+     * \return The destination hardware address.
+     */
+    address_type dst_addr() const {
+        return header_.dst_mac;
+    }
 
-        /**
-         * \brief Getter for the source hardware address.
-         *
-         * \return The source hardware address.
-         */
-        address_type src_addr() const { return _eth.src_mac; }
+    /**
+     * \brief Getter for the source hardware address.
+     *
+     * \return The source hardware address.
+     */
+    address_type src_addr() const {
+        return header_.src_mac;
+    }
 
-        /**
-         * \brief Getter for the length field.
-         * \return The length field value.
-         */
-        uint16_t length() const { return Endian::be_to_host(_eth.length); };
+    /**
+     * \brief Getter for the length field.
+     * \return The length field value.
+     */
+    uint16_t length() const {
+        return Endian::be_to_host(header_.length);
+    }
 
-        /* Setters */
+    /* Setters */
 
-        /**
-         * \brief Setter for the destination hardware address.
-         *
-         * \param new_dst_mac The new destination hardware address.
-         */
-        void dst_addr(const address_type &new_dst_mac);
+    /**
+     * \brief Setter for the destination hardware address.
+     *
+     * \param address The new destination hardware address.
+     */
+    void dst_addr(const address_type& address);
 
-        /**
-         * \brief Setter for the source hardware address.
-         *
-         * \param new_src_mac The new source hardware address.
-         */
-        void src_addr(const address_type &new_src_mac);
+    /**
+     * \brief Setter for the source hardware address.
+     *
+     * \param address The new source hardware address.
+     */
+    void src_addr(const address_type& address);
 
-        /**
-         * \brief Setter for the length field.
-         *
-         * \param new_length uint16_t with the new value of the length field.
-         */
-        void length(uint16_t new_length);
+    /**
+     * \brief Setter for the length field.
+     *
+     * \param value The new value for the length field
+     */
+    void length(uint16_t value);
 
-        /* Virtual methods */
-        /**
-         * \brief Returns the Dot3 frame's header length.
-         *
-         * \return An uint32_t with the header's size.
-         * \sa PDU::header_size()
-         */
-        uint32_t header_size() const;
-        
-        #if !defined(_WIN32) || defined(HAVE_PACKET_SENDER_PCAP_SENDPACKET)
-        /**
-         * \sa PDU::send()
-         */
-        void send(PacketSender &sender, const NetworkInterface &iface);
-        #endif // !_WIN32 || HAVE_PACKET_SENDER_PCAP_SENDPACKET
+    // Virtual methods
 
-        /** 
-         * \brief Check wether ptr points to a valid response for this PDU.
-         *
-         * \sa PDU::matches_response
-         * \param ptr The pointer to the buffer.
-         * \param total_sz The size of the buffer.
-         */
-        bool matches_response(const uint8_t *ptr, uint32_t total_sz) const;
+    /**
+     * \brief Returns the Dot3 frame's header length.
+     *
+     * \return An uint32_t with the header's size.
+     * \sa PDU::header_size()
+     */
+    uint32_t header_size() const;
+    
+    #if !defined(_WIN32) || defined(HAVE_PACKET_SENDER_PCAP_SENDPACKET)
+    /**
+     * \sa PDU::send()
+     */
+    void send(PacketSender& sender, const NetworkInterface& iface);
+    #endif // !_WIN32 || HAVE_PACKET_SENDER_PCAP_SENDPACKET
 
-        #ifndef _WIN32
-        /** 
-         * \sa PDU::recv_response
-         */
-        PDU *recv_response(PacketSender &sender, const NetworkInterface &iface);
-        #endif // _WIN32
+    /** 
+     * \brief Check wether ptr points to a valid response for this PDU.
+     *
+     * \sa PDU::matches_response
+     * \param ptr The pointer to the buffer.
+     * \param total_sz The size of the buffer.
+     */
+    bool matches_response(const uint8_t* ptr, uint32_t total_sz) const;
 
-        /**
-         * \brief Getter for the PDU's type.
-         * \sa PDU::pdu_type
-         */
-        PDUType pdu_type() const { return pdu_flag; }
+    #ifndef _WIN32
+    /** 
+     * \sa PDU::recv_response
+     */
+    PDU* recv_response(PacketSender& sender, const NetworkInterface& iface);
+    #endif // _WIN32
 
-        /**
-         * \sa PDU::clone
-         */
-        Dot3 *clone() const {
-            return new Dot3(*this);
-        }
-    private:
-        /**
-         * Struct that represents the Ethernet II header
-         */
-        TINS_BEGIN_PACK
-        struct ethhdr {
-            uint8_t dst_mac[address_type::address_size];
-            uint8_t src_mac[address_type::address_size];
-            uint16_t length;
-        } TINS_END_PACK;
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const { return pdu_flag; }
 
-        void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
+    /**
+     * \sa PDU::clone
+     */
+    Dot3* clone() const {
+        return new Dot3(*this);
+    }
+private:
+    /**
+     * Struct that represents the Ethernet II header
+     */
+    TINS_BEGIN_PACK
+    struct dot3_header {
+        uint8_t dst_mac[address_type::address_size];
+        uint8_t src_mac[address_type::address_size];
+        uint16_t length;
+    } TINS_END_PACK;
 
+    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
 
-        ethhdr _eth;
-    };
-}
+    dot3_header header_;
+};
 
+} // Tins
 
 #endif // TINS_DOT3_H
diff --git a/include/tins/eapol.h b/include/tins/eapol.h
index b6af617..5ddf95e 100644
--- a/include/tins/eapol.h
+++ b/include/tins/eapol.h
@@ -38,707 +38,788 @@
 
 namespace Tins {
 namespace Memory {
+
 class OutputMemoryStream;
+
 } // Memory
 
-    /** \cond 
-     * Forward declaration. Avoid header inclusion.
-     */
-    class RSNInformation;
-    /** \endcond */
-    
+/** \cond 
+ * Forward declaration. Avoid header inclusion.
+ */
+class RSNInformation;
+/** \endcond */
+
+/**
+ * \class EAPOL
+ * \brief Represents the EAP encapsulation over LAN.
+ */
+class TINS_API EAPOL : public PDU {
+public:
     /**
-     * \class EAPOL
-     * \brief Represents the EAP encapsulation over LAN.
+     * \brief This PDU's flag.
      */
-    class TINS_API EAPOL : public PDU {
-    public:
-        /**
-         * \brief This PDU's flag.
-         */
-        static const PDU::PDUType pdu_flag = PDU::EAPOL;
-    
-        /**
-         * The EAPOL type enum.
-         */
-        enum EAPOLTYPE {
-            RC4 = 1,
-            RSN,
-            EAPOL_WPA = 254
-        };
-        
-        /**
-         * \brief Static method to instantiate the correct EAPOL subclass 
-         * based on a raw buffer.
-         * 
-         * If no valid EAPOL type is detected, a null pointer is returned.
-         * 
-         * \sa RC4EAPOL
-         * \sa RSNEAPOL
-         * 
-         * \param buffer The buffer from which the data will be taken.
-         * \param total_sz The total size of the buffer.
-         */
-        static EAPOL *from_bytes(const uint8_t *buffer, uint32_t total_sz);
-        
-        /* Getters */
-        
-        /**
-         * \brief Getter for the version field.
-         * \return The version field.
-         */
-        uint8_t version() const { return _header.version; }
-        
-        /**
-         * \brief Getter for the packet type field.
-         * \return The packet type field.
-         */
-        uint8_t packet_type() const { return _header.packet_type; }
-        
-        /**
-         * \brief Getter for the length field.
-         * \return The length field.
-         */
-        uint16_t length() const { return Endian::be_to_host(_header.length); }
-        
-        /**
-         * \brief Getter for the type field.
-         * \return The type field.
-         */
-        uint8_t type() const { return _header.type; }
-        
-        /* Setters */
-        
-        /**
-         * \brief Sets the version field.
-         * \param new_version The new version to be set.
-         */
-        void version(uint8_t new_version);
-        
-        /**
-         * \brief Sets the packet type field.
-         * \param new_ptype The new packet type to be set.
-         */
-        void packet_type(uint8_t new_ptype);
-        
-        /**
-         * \brief Sets the length field.
-         * \param new_length The new length to be set.
-         */
-        void length(uint16_t new_length);
-        
-        /**
-         * \brief Sets the type field.
-         * \param new_type The new type to be set.
-         */
-        void type(uint8_t new_type);
-        
-        /**
-         * \brief Getter for the PDU's type.
-         * \return Returns the PDUType corresponding to the PDU.
-         */
-        PDUType pdu_type() const { return PDU::EAPOL; }
-    protected:
-        /**
-         * \brief Protected constructor that sets the packet_type and type fields.
-         */
-        EAPOL(uint8_t packet_type, EAPOLTYPE type);
-        
-        /**
-         * \brief Constructor which creates an EAPOL object from a buffer.
-         * \param buffer The buffer from which this PDU will be constructed.
-         * \param total_sz The total size of the buffer.
-         */
-        EAPOL(const uint8_t *buffer, uint32_t total_sz);
-        
-        TINS_BEGIN_PACK
-        struct eapolhdr {
-            uint8_t version, packet_type;
-            uint16_t length;
-            uint8_t type;
-        } TINS_END_PACK;
-        
-        /**
-         * \brief Virtual method which should serialize the subclass specific
-         * body and save it in a byte array.
-         * 
-         * \param buffer The pointer in which to save the serialization.
-         * \param total_sz The total size of the buffer.
-         */
-        virtual void write_body(Memory::OutputMemoryStream& stream) = 0;
-    private:
-        /** 
-         * \brief Serialices this EAPOL PDU.
-         * \param buffer The buffer in which the PDU will be serialized.
-         * \param total_sz The size available in the buffer.
-         * \param parent The PDU that's one level below this one on the stack.
-         */
-        void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
-    
-        eapolhdr _header;
+    static const PDU::PDUType pdu_flag = PDU::EAPOL;
+
+    /**
+     * The EAPOL type enum.
+     */
+    enum EAPOLTYPE {
+        RC4 = 1,
+        RSN,
+        EAPOL_WPA = 254
     };
     
+    /**
+     * \brief Static method to instantiate the correct EAPOL subclass 
+     * based on a raw buffer.
+     * 
+     * If no valid EAPOL type is detected, a null pointer is returned.
+     * 
+     * \sa RC4EAPOL
+     * \sa RSNEAPOL
+     * 
+     * \param buffer The buffer from which the data will be taken.
+     * \param total_sz The total size of the buffer.
+     */
+    static EAPOL* from_bytes(const uint8_t* buffer, uint32_t total_sz);
     
+    /* Getters */
     
     /**
-     * \brief Class that represents the RC4 EAPOL PDU.
+     * \brief Getter for the version field.
+     * \return The version field.
      */
-    class TINS_API RC4EAPOL : public EAPOL {
-    public:
-        /**
-         * The type used to store the key.
-         */
-        typedef std::vector<uint8_t> key_type;
-    
-        /**
-         * This PDU's flag.
-         */
-        static const PDU::PDUType pdu_flag = PDU::RC4EAPOL;
-        
-        /**
-         * The length of the key IV field
-         */
-        static const size_t key_iv_size = 16;
-        
-        /**
-         * The length of the key sign field
-         */
-        static const size_t key_sign_size = 16;
-    
-        /**
-         * \brief Default constructor.
-         */
-        RC4EAPOL();
-        
-        /**
-         * \brief Constructs a RC4EAPOL object from a buffer.
-         * 
-         * If there is not enough size for a RC4EAPOL header in the 
-         * buffer, a malformed_packet exception is thrown.
-         * 
-         * \param buffer The buffer from which this PDU will be constructed.
-         * \param total_sz The total size of the buffer.
-         */
-        RC4EAPOL(const uint8_t *buffer, uint32_t total_sz);
-        
-        /* Getters */
-        
-        /**
-         * \brief Getter for the key length field.
-         * \return The key length field.
-         */
-        uint16_t key_length() const { return Endian::be_to_host(_header.key_length); }
-        
-        /**
-         * \brief Getter for the replay counter field.
-         * \return The replay counter field.
-         */
-        uint64_t replay_counter() const { return Endian::be_to_host(_header.replay_counter); }
-        
-        /**
-         * \brief Getter for the key IV field.
-         * \return The key IV field.
-         */
-        const uint8_t *key_iv() const { return _header.key_iv; }
-        
-        /**
-         * \brief Getter for the key flag field.
-         * \return The key flag field.
-         */
-        small_uint<1> key_flag() const { return _header.key_flag; }
-        
-        /**
-         * \brief Getter for the key index field.
-         * \return The key index field.
-         */
-        small_uint<7> key_index() const { return _header.key_index; }
-        
-        /**
-         * \brief Getter for the key signature field.
-         * \return The key signature field.
-         */
-        const uint8_t *key_sign() const { return _header.key_sign; }
-        
-        /**
-         * \brief Getter for the key field.
-         * \return The key field.
-         */
-        const key_type &key() const { return _key; }
-        
-        /* Setters */
-        
-        /**
-         * \brief Sets the key length field.
-         * \param new_key_length The new key length to be set.
-         */
-        void key_length(uint16_t new_key_length);
-        
-        /**
-         * \brief Sets the replay counter field.
-         * \param new_replay_counter The new replay counter to be set.
-         */
-        void replay_counter(uint64_t new_replay_counter);
-        
-        /**
-         * \brief Sets the key IV field.
-         * \param new_key_iv The new key IV to be set.
-         */
-        void key_iv(const uint8_t *new_key_iv);
-        
-        /**
-         * \brief Sets the key flag field.
-         * \param new_key_flag The new key flag to be set.
-         */
-        void key_flag(small_uint<1> new_key_flag);
-        
-        /**
-         * \brief Sets the key index field.
-         * \param new_key_index The new key index to be set.
-         */
-        void key_index(small_uint<7> new_key_index);
-        
-        /**
-         * \brief Sets the key signature field.
-         * \param new_key_sign The new key signature to be set.
-         */
-        void key_sign(const uint8_t *new_key_sign);
-        
-        /**
-         * \brief Sets the key field.
-         * \param new_key The new key to be set.
-         */
-        void key(const key_type &new_key);
-        
-        /* Virtual method override. */
-        
-        /**
-         * \brief Returns the header size.
-         *
-         * This metod overrides PDU::header_size. This size includes the
-         * payload and options size.
-         *
-         * \sa PDU::header_size
-         */
-        uint32_t header_size() const;
-        
-        /**
-         * \brief Getter for the PDU's type.
-         * \return Returns the PDUType corresponding to the PDU.
-         */
-        PDUType pdu_type() const { return PDU::RC4EAPOL; }
-        
-        /**
-         * \brief Check wether this PDU matches the specified flag.
-         * \param flag The flag to match
-         * \sa PDU::matches_flag
-         */
-        bool matches_flag(PDUType flag) const {
-           return flag == PDU::RC4EAPOL || EAPOL::matches_flag(flag);
-        }
-        
-        /**
-         * \brief Clones this PDU.
-         * 
-         * \sa PDU::clone
-         */
-        RC4EAPOL *clone() const {
-            return new RC4EAPOL(*this);
-        }
-    private:
-        TINS_BEGIN_PACK
-        struct rc4hdr {
-            uint16_t key_length;
-            uint64_t replay_counter;
-            uint8_t key_iv[key_iv_size];
-            uint8_t key_index:7,
-                    key_flag:1;
-            uint8_t key_sign[16];
-        } TINS_END_PACK;
-        
-        void write_body(Memory::OutputMemoryStream& stream);
-        
-        
-        key_type _key;
-        rc4hdr _header;
-    };
-    
+    uint8_t version() const {
+        return header_.version;
+    }
     
     /**
-     * \brief Class that represents the RSN EAPOL PDU.
+     * \brief Getter for the packet type field.
+     * \return The packet type field.
      */
-    class TINS_API RSNEAPOL : public EAPOL {
-    public:
-        /**
-         * The type used to store the key.
-         */
-        typedef std::vector<uint8_t> key_type;
+    uint8_t packet_type() const {
+        return header_.packet_type;
+    }
     
-        /**
-         * \brief This PDU's flag.
-         */
-        static const PDU::PDUType pdu_flag = PDU::RSNEAPOL;
-        
-        /**
-         * The length of the key IV field
-         */
-        static const size_t key_iv_size = 16;
-        
-        /**
-         * The length of the nonce field
-         */
-        static const size_t nonce_size = 32;
+    /**
+     * \brief Getter for the length field.
+     * \return The length field.
+     */
+    uint16_t length() const {
+        return Endian::be_to_host(header_.length);
+    }
     
-        /**
-         * The length of the mic field
-         */
-        static const size_t mic_size = 16;
-        
-        /**
-         * The length of the rsc field
-         */
-        static const size_t rsc_size = 8;
-        
-        /**
-         * The length of the id field
-         */
-        static const size_t id_size = 8;
-        
-        /**
-         * \brief Creates an instance of RSNEAPOL.
-         */
-        RSNEAPOL();
-        
-        /**
-         * \brief Constructs a RSNEAPOL object from a buffer.
-         * 
-         * If there is not enough size for the RSNEAPOL header, a
-         * malformed_packet exception is thrown.
-         * 
-         * \param buffer The buffer from which this PDU will be constructed.
-         * \param total_sz The total size of the buffer.
-         */
-        RSNEAPOL(const uint8_t *buffer, uint32_t total_sz);
-        
-        /* Getters */
-        
-        /**
-         * \brief Getter for the key length field.
-         * \return The key length field.
-         */
-        uint16_t key_length() const { return Endian::be_to_host(_header.key_length); }
-        
-        /**
-         * \brief Getter for the replay counter field.
-         * \return The replay counter field.
-         */
-        uint64_t replay_counter() const { return Endian::be_to_host(_header.replay_counter); }
-        
-        /**
-         * \brief Getter for the key IV field.
-         * \return The key IV field.
-         */
-        const uint8_t *key_iv() const { return _header.key_iv; }
-        
-        /**
-         * \brief Getter for the nonce field.
-         * \return The nonce field.
-         */
-        const uint8_t *nonce() const { return _header.nonce; }
-        
-        /**
-         * \brief Getter for the rsc field.
-         * \return The rsc field.
-         */
-        const uint8_t *rsc() const { return _header.rsc; }
-        
-        /**
-         * \brief Getter for the id field.
-         * \return The id field.
-         */
-        const uint8_t *id() const { return _header.id; }
-        
-        /**
-         * \brief Getter for the mic field.
-         * \return The mic field.
-         */
-        const uint8_t *mic() const { return _header.mic; }
-        
-        /**
-         * \brief Getter for the wpa length field.
-         * \return The wpa length field.
-         */
-        uint16_t wpa_length() const { return Endian::be_to_host(_header.wpa_length); }
-        
-        /**
-         * \brief Getter for the key field.
-         * \return The key field.
-         */
-        const key_type &key() const { return _key; }
-        
-        /**
-         * \brief Getter for the key mic field.
-         * \return 1 if this EAPOL PDU contains a valid MIC, 0 otherwise.
-         */
-        small_uint<1> key_mic() const { return _header.key_mic; };
+    /**
+     * \brief Getter for the type field.
+     * \return The type field.
+     */
+    uint8_t type() const {
+        return header_.type;
+    }
+    
+    /* Setters */
+    
+    /**
+     * \brief Sets the version field.
+     * \param value The new version to be set.
+     */
+    void version(uint8_t value);
+    
+    /**
+     * \brief Sets the packet type field.
+     * \param value The new packet type to be set.
+     */
+    void packet_type(uint8_t value);
+    
+    /**
+     * \brief Sets the length field.
+     * \param value The new length to be set.
+     */
+    void length(uint16_t value);
+    
+    /**
+     * \brief Sets the type field.
+     * \param value The new type to be set.
+     */
+    void type(uint8_t value);
+    
+    /**
+     * \brief Getter for the PDU's type.
+     * \return Returns the PDUType corresponding to the PDU.
+     */
+    PDUType pdu_type() const { return PDU::EAPOL; }
+protected:
+    /**
+     * \brief Protected constructor that sets the packet_type and type fields.
+     */
+    EAPOL(uint8_t packet_type, EAPOLTYPE type);
+    
+    /**
+     * \brief Constructor which creates an EAPOL object from a buffer.
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    EAPOL(const uint8_t* buffer, uint32_t total_sz);
+    
+    TINS_BEGIN_PACK
+    struct eapol_header {
+        uint8_t version, packet_type;
+        uint16_t length;
+        uint8_t type;
+    } TINS_END_PACK;
+    
+    /**
+     * \brief Virtual method which should serialize the subclass specific
+     * body and save it in a byte array.
+     * 
+     * \param buffer The pointer in which to save the serialization.
+     * \param total_sz The total size of the buffer.
+     */
+    virtual void write_body(Memory::OutputMemoryStream& stream) = 0;
+private:
+    /** 
+     * \brief Serialices this EAPOL PDU.
+     * \param buffer The buffer in which the PDU will be serialized.
+     * \param total_sz The size available in the buffer.
+     * \param parent The PDU that's one level below this one on the stack.
+     */
+    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
 
-        /**
-         * \brief Getter for the secure field.
-         * \return The secure field.
-         */
-        small_uint<1> secure() const { return _header.secure; };
+    eapol_header header_;
+};
 
-        /**
-         * \brief Getter for the error field.
-         * \return The error field.
-         */
-        small_uint<1> error() const { return _header.error; };
 
-        /**
-         * \brief Getter for the request field.
-         * \return The request field.
-         */
-        small_uint<1> request() const { return _header.request; };
 
-        /**
-         * \brief Getter for the encrypted field.
-         * \return The encrypted field.
-         */
-        small_uint<1> encrypted() const { return _header.encrypted; };
+/**
+ * \brief Class that represents the RC4 EAPOL PDU.
+ */
+class TINS_API RC4EAPOL : public EAPOL {
+public:
+    /**
+     * The type used to store the key.
+     */
+    typedef std::vector<uint8_t> key_type;
 
-        /**
-         * \brief Getter for the key descriptor field.
-         * \return The key descriptor field.
-         */
-        small_uint<3> key_descriptor() const { return _header.key_descriptor; };
+    /**
+     * This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::RC4EAPOL;
+    
+    /**
+     * The length of the key IV field
+     */
+    static const size_t key_iv_size = 16;
+    
+    /**
+     * The length of the key sign field
+     */
+    static const size_t key_sign_size = 16;
 
-        /**
-         * \brief Getter for the key type field.
-         * 
-         * \return 1 if this is a pairwise key, 0 otherwise.
-         */
-        small_uint<1> key_t() const { return _header.key_t; };
+    /**
+     * \brief Default constructor.
+     */
+    RC4EAPOL();
+    
+    /**
+     * \brief Constructs a RC4EAPOL object from a buffer.
+     * 
+     * If there is not enough size for a RC4EAPOL header in the 
+     * buffer, a malformed_packet exception is thrown.
+     * 
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    RC4EAPOL(const uint8_t* buffer, uint32_t total_sz);
+    
+    /* Getters */
+    
+    /**
+     * \brief Getter for the key length field.
+     * \return The key length field.
+     */
+    uint16_t key_length() const {
+        return Endian::be_to_host(header_.key_length);
+    }
+    
+    /**
+     * \brief Getter for the replay counter field.
+     * \return The replay counter field.
+     */
+    uint64_t replay_counter() const {
+        return Endian::be_to_host(header_.replay_counter);
+    }
+    
+    /**
+     * \brief Getter for the key IV field.
+     * \return The key IV field.
+     */
+    const uint8_t* key_iv() const {
+        return header_.key_iv;
+    }
+    
+    /**
+     * \brief Getter for the key flag field.
+     * \return The key flag field.
+     */
+    small_uint<1> key_flag() const {
+        return header_.key_flag;
+    }
+    
+    /**
+     * \brief Getter for the key index field.
+     * \return The key index field.
+     */
+    small_uint<7> key_index() const {
+        return header_.key_index;
+    }
+    
+    /**
+     * \brief Getter for the key signature field.
+     * \return The key signature field.
+     */
+    const uint8_t* key_sign() const {
+        return header_.key_sign;
+    }
+    
+    /**
+     * \brief Getter for the key field.
+     * \return The key field.
+     */
+    const key_type& key() const {
+        return key_;
+    }
+    
+    /* Setters */
+    
+    /**
+     * \brief Sets the key length field.
+     * \param value The new key length to be set.
+     */
+    void key_length(uint16_t value);
+    
+    /**
+     * \brief Sets the replay counter field.
+     * \param value The new replay counter to be set.
+     */
+    void replay_counter(uint64_t value);
+    
+    /**
+     * \brief Sets the key IV field.
+     * \param value The new key IV to be set.
+     */
+    void key_iv(const uint8_t* value);
+    
+    /**
+     * \brief Sets the key flag field.
+     * \param value The new key flag to be set.
+     */
+    void key_flag(small_uint<1> value);
+    
+    /**
+     * \brief Sets the key index field.
+     * \param value The new key index to be set.
+     */
+    void key_index(small_uint<7> value);
+    
+    /**
+     * \brief Sets the key signature field.
+     * \param value The new key signature to be set.
+     */
+    void key_sign(const uint8_t* value);
+    
+    /**
+     * \brief Sets the key field.
+     * \param value The new key to be set.
+     */
+    void key(const key_type& value);
+    
+    /* Virtual method override. */
+    
+    /**
+     * \brief Returns the header size.
+     *
+     * This metod overrides PDU::header_size. This size includes the
+     * payload and options size.
+     *
+     * \sa PDU::header_size
+     */
+    uint32_t header_size() const;
+    
+    /**
+     * \brief Getter for the PDU's type.
+     * \return Returns the PDUType corresponding to the PDU.
+     */
+    PDUType pdu_type() const {
+        return pdu_flag; 
+    }
+    
+    /**
+     * \brief Check wether this PDU matches the specified flag.
+     * \param flag The flag to match
+     * \sa PDU::matches_flag
+     */
+    bool matches_flag(PDUType flag) const {
+       return flag == pdu_flag || EAPOL::matches_flag(flag);
+    }
+    
+    /**
+     * \brief Clones this PDU.
+     * 
+     * \sa PDU::clone
+     */
+    RC4EAPOL* clone() const {
+        return new RC4EAPOL(*this);
+    }
+private:
+    TINS_BEGIN_PACK
+    struct rc4_eapol_header {
+        uint16_t key_length;
+        uint64_t replay_counter;
+        uint8_t key_iv[key_iv_size];
+        uint8_t key_index:7,
+                key_flag:1;
+        uint8_t key_sign[16];
+    } TINS_END_PACK;
+    
+    void write_body(Memory::OutputMemoryStream& stream);
+    
+    
+    key_type key_;
+    rc4_eapol_header header_;
+};
 
-        /**
-         * \brief Getter for the key_index field.
-         * \return The key_index field.
-         */
-        small_uint<2> key_index() const { return _header.key_index; };
 
-        /**
-         * \brief Getter for the install field.
-         * \return The install field.
-         */
-        small_uint<1> install() const { return _header.install; };
+/**
+ * \brief Class that represents the RSN EAPOL PDU.
+ */
+class TINS_API RSNEAPOL : public EAPOL {
+public:
+    /**
+     * The type used to store the key.
+     */
+    typedef std::vector<uint8_t> key_type;
 
-        /**
-         * \brief Getter for the key_ack field.
-         * \return The key_ack field.
-         */
-        small_uint<1> key_ack() const { return _header.key_ack; };
-        
-        /**
-         * \brief Returns the header size.
-         *
-         * This metod overrides PDU::header_size. This size includes the
-         * payload and options size.
-         *
-         * \sa PDU::header_size
-         */
-        uint32_t header_size() const;
-        
-        /* Setters */
-        
-        /**
-         * \brief Sets the key length field.
-         * \param new_key_length The new key length to be set.
-         */
-        void key_length(uint16_t new_key_length);
-        
-        /**
-         * \brief Sets the replay counter field.
-         * \param new_replay_counter The new replay counter to be set.
-         */
-        void replay_counter(uint64_t new_replay_counter);
-        
-        /**
-         * \brief Sets the key IV field.
-         * \param new_key_iv The new key IV to be set.
-         */
-        void key_iv(const uint8_t *new_key_iv);
-        
-        /**
-         * \brief Sets the nonce field.
-         * 
-         * This method sets the nonce field. This field is 32 bytes long,
-         * therefore the input buffer should be at least that length.
-         * \param new_nonce The new nonce to be set.
-         */
-        void nonce(const uint8_t *new_nonce);
-        
-        /**
-         * \brief Sets the rsc field.
-         * \param new_rsc The new rsc to be set.
-         */
-        void rsc(const uint8_t *new_rsc);
-        
-        /**
-         * \brief Sets the id field.
-         * \param new_id The new id to be set.
-         */
-        void id(const uint8_t *new_id);
-        
-        /**
-         * \brief Sets the mic field.
-         * 
-         * This method sets the mic field. This field is 16 bytes long,
-         * therefore the input buffer should be at least that length.
-         * \param new_mic The new mic to be set.
-         */
-        void mic(const uint8_t *new_mic);
-        
-        /**
-         * \brief Sets the wpa length field.
-         * \param new_wpa_length The new wpa length to be set.
-         */
-        void wpa_length(uint16_t new_wpa_length);
-        
-        /**
-         * \brief Sets the key field.
-         * \param new_key The new key to be set.
-         */
-        void key(const key_type &new_key);
-        
-        /**
-         * \brief Setter for the key_mic field.
-         * \param new_key_mic The new to be set.
-         */
-        void key_mic(small_uint<1> new_key_mic);
+    /**
+     * \brief This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::RSNEAPOL;
+    
+    /**
+     * The length of the key IV field
+     */
+    static const size_t key_iv_size = 16;
+    
+    /**
+     * The length of the nonce field
+     */
+    static const size_t nonce_size = 32;
 
-        /**
-         * \brief Setter for the secure field.
-         * \param new_secure The new to be set.
-         */
-        void secure(small_uint<1> new_secure);
+    /**
+     * The length of the mic field
+     */
+    static const size_t mic_size = 16;
+    
+    /**
+     * The length of the rsc field
+     */
+    static const size_t rsc_size = 8;
+    
+    /**
+     * The length of the id field
+     */
+    static const size_t id_size = 8;
+    
+    /**
+     * \brief Creates an instance of RSNEAPOL.
+     */
+    RSNEAPOL();
+    
+    /**
+     * \brief Constructs a RSNEAPOL object from a buffer.
+     * 
+     * If there is not enough size for the RSNEAPOL header, a
+     * malformed_packet exception is thrown.
+     * 
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    RSNEAPOL(const uint8_t* buffer, uint32_t total_sz);
+    
+    /* Getters */
+    
+    /**
+     * \brief Getter for the key length field.
+     * \return The key length field.
+     */
+    uint16_t key_length() const {
+        return Endian::be_to_host(header_.key_length);
+    }
+    
+    /**
+     * \brief Getter for the replay counter field.
+     * \return The replay counter field.
+     */
+    uint64_t replay_counter() const {
+        return Endian::be_to_host(header_.replay_counter);
+    }
+    
+    /**
+     * \brief Getter for the key IV field.
+     * \return The key IV field.
+     */
+    const uint8_t* key_iv() const {
+        return header_.key_iv;
+    }
+    
+    /**
+     * \brief Getter for the nonce field.
+     * \return The nonce field.
+     */
+    const uint8_t* nonce() const {
+        return header_.nonce;
+    }
+    
+    /**
+     * \brief Getter for the rsc field.
+     * \return The rsc field.
+     */
+    const uint8_t* rsc() const {
+        return header_.rsc;
+    }
+    
+    /**
+     * \brief Getter for the id field.
+     * \return The id field.
+     */
+    const uint8_t* id() const {
+        return header_.id;
+    }
+    
+    /**
+     * \brief Getter for the mic field.
+     * \return The mic field.
+     */
+    const uint8_t* mic() const {
+        return header_.mic;
+    }
+    
+    /**
+     * \brief Getter for the wpa length field.
+     * \return The wpa length field.
+     */
+    uint16_t wpa_length() const {
+        return Endian::be_to_host(header_.wpa_length);
+    }
+    
+    /**
+     * \brief Getter for the key field.
+     * \return The key field.
+     */
+    const key_type& key() const {
+        return key_;
+    }
+    
+    /**
+     * \brief Getter for the key mic field.
+     * \return 1 if this EAPOL PDU contains a valid MIC, 0 otherwise.
+     */
+    small_uint<1> key_mic() const {
+        return header_.key_mic;
+    }
 
-        /**
-         * \brief Setter for the error field.
-         * \param new_error The new to be set.
-         */
-        void error(small_uint<1> new_error);
+    /**
+     * \brief Getter for the secure field.
+     * \return The secure field.
+     */
+    small_uint<1> secure() const {
+        return header_.secure;
+    }
 
-        /**
-         * \brief Setter for the request field.
-         * \param new_request The new to be set.
-         */
-        void request(small_uint<1> new_request);
+    /**
+     * \brief Getter for the error field.
+     * \return The error field.
+     */
+    small_uint<1> error() const {
+        return header_.error;
+    }
 
-        /**
-         * \brief Setter for the encrypted field.
-         * \param new_encrypted The new to be set.
-         */
-        void encrypted(small_uint<1 > new_encrypted);
+    /**
+     * \brief Getter for the request field.
+     * \return The request field.
+     */
+    small_uint<1> request() const {
+        return header_.request;
+    }
 
-        /**
-         * \brief Setter for the key_descriptor field.
-         * \param new_key_descriptor The new to be set.
-         */
-        void key_descriptor(small_uint<3> new_key_descriptor);
+    /**
+     * \brief Getter for the encrypted field.
+     * \return The encrypted field.
+     */
+    small_uint<1> encrypted() const {
+        return header_.encrypted;
+    }
 
-        /**
-         * \brief Setter for the key_t field.
-         * \param new_key_t The new to be set.
-         */
-        void key_t(small_uint<1> new_key_t);
+    /**
+     * \brief Getter for the key descriptor field.
+     * \return The key descriptor field.
+     */
+    small_uint<3> key_descriptor() const {
+        return header_.key_descriptor;
+    }
 
-        /**
-         * \brief Setter for the key_index field.
-         * \param new_key_index The new to be set.
-         */
-        void key_index(small_uint<2> new_key_index);
+    /**
+     * \brief Getter for the key type field.
+     * 
+     * \return 1 if this is a pairwise key, 0 otherwise.
+     */
+    small_uint<1> key_t() const {
+        return header_.key_t;
+    }
 
-        /**
-         * \brief Setter for the install field.
-         * \param new_install The new to be set.
-         */
-        void install(small_uint<1> new_install);
+    /**
+     * \brief Getter for the key_index field.
+     * \return The key_index field.
+     */
+    small_uint<2> key_index() const {
+        return header_.key_index;
+    }
 
-        /**
-         * \brief Setter for the key_ack field.
-         * \param new_key_ack The new to be set.
-         */
-        void key_ack(small_uint<1> new_key_ack);
-        
-        /**
-         * \brief Getter for the PDU's type.
-         * \return Returns the PDUType corresponding to the PDU.
-         */
-        PDUType pdu_type() const { return PDU::RSNEAPOL; }
-        
-        /**
-         * \brief Check wether this PDU matches the specified flag.
-         * \param flag The flag to match
-         * \sa PDU::matches_flag
-         */
-        bool matches_flag(PDUType flag) const {
-           return flag == PDU::RSNEAPOL || EAPOL::matches_flag(flag);
-        }
-        
-        /**
-         * \brief Clones this PDU.
-         * 
-         * \sa PDU::clone
-         */
-        RSNEAPOL *clone() const {
-            return new RSNEAPOL(*this);
-        }
-    private:
-        TINS_BEGIN_PACK
-        struct rsnhdr {
-        #if TINS_IS_LITTLE_ENDIAN
-            uint16_t key_mic:1,
-                secure:1,
-                error:1,
-                request:1,
-                encrypted:1,
-                reserved:3, 
-                key_descriptor:3,
-                key_t:1,
-                key_index:2,
-                install:1,
-                key_ack:1;       
-            uint16_t key_length;
-            uint64_t replay_counter;
-            uint8_t nonce[nonce_size], key_iv[key_iv_size];
-            uint8_t rsc[rsc_size], id[id_size];
-            uint8_t mic[mic_size];
-            uint16_t wpa_length;
-        #else
-            uint16_t reserved:3,
-                encrypted:1,
-                request:1,
-                error:1,
-                secure:1,
-                key_mic:1,
-                key_ack:1,
-                install:1,
-                key_index:2,
-                key_t:1,
-                key_descriptor:3;
-            uint16_t key_length;
-            uint64_t replay_counter;
-            uint8_t nonce[nonce_size], key_iv[key_iv_size];
-            uint8_t rsc[rsc_size], id[id_size];
-            uint8_t mic[mic_size];
-            uint16_t wpa_length;
-        #endif
-        } TINS_END_PACK;
-        
-        void write_body(Memory::OutputMemoryStream& stream);
-        
-        
-        rsnhdr _header;
-        key_type _key;
-    };
-}
+    /**
+     * \brief Getter for the install field.
+     * \return The install field.
+     */
+    small_uint<1> install() const {
+        return header_.install;
+    }
+
+    /**
+     * \brief Getter for the key_ack field.
+     * \return The key_ack field.
+     */
+    small_uint<1> key_ack() const {
+        return header_.key_ack;
+    }
+    
+    /**
+     * \brief Returns the header size.
+     *
+     * This metod overrides PDU::header_size. This size includes the
+     * payload and options size.
+     *
+     * \sa PDU::header_size
+     */
+    uint32_t header_size() const;
+    
+    /* Setters */
+    
+    /**
+     * \brief Sets the key length field.
+     * \param value The new key length to be set.
+     */
+    void key_length(uint16_t value);
+    
+    /**
+     * \brief Sets the replay counter field.
+     * \param value The new replay counter to be set.
+     */
+    void replay_counter(uint64_t value);
+    
+    /**
+     * \brief Sets the key IV field.
+     *
+     * The input pointer has to contain at least key_iv_size bytes. The IV
+     * will be copied into this PDU.
+     *
+     * \param ptr The new key IV to be set.
+     */
+    void key_iv(const uint8_t* ptr);
+    
+    /**
+     * \brief Sets the nonce field.
+     * 
+     * The pointer has to contain at least nonce_size bytes. The pointer's contents
+     * will be copied.
+     *
+     * \param ptr The new nonce to be set.
+     */
+    void nonce(const uint8_t* ptr);
+    
+    /**
+     * \brief Sets the rsc field.
+     *
+     * The pointer has to contain at least rsc_size bytes. The pointer's contents
+     * will be copied.
+     *
+     * \param ptr The new rsc to be set.
+     */
+    void rsc(const uint8_t* ptr);
+    
+    /**
+     * \brief Sets the id field.
+     *
+     * The pointer has to contain at least id_size bytes. The pointer's contents
+     * will be copied.
+     *
+     * \param ptr The new id to be set.
+     */
+    void id(const uint8_t* ptr);
+    
+    /**
+     * \brief Sets the mic field.
+     * 
+     * The pointer has to contain at least mic_size bytes. The pointer's contents
+     * will be copied.
+     *
+     * \param ptr The new mic to be set.
+     */
+    void mic(const uint8_t* ptr);
+    
+    /**
+     * \brief Sets the wpa length field.
+     * \param length The new wpa length to be set.
+     */
+    void wpa_length(uint16_t length);
+    
+    /**
+     * \brief Sets the key field.
+     * \param value The new key to be set.
+     */
+    void key(const key_type& value);
+    
+    /**
+     * \brief Setter for the key_mic field.
+     * \param value The new to be set.
+     */
+    void key_mic(small_uint<1> value);
+
+    /**
+     * \brief Setter for the secure field.
+     * \param value The new to be set.
+     */
+    void secure(small_uint<1> value);
+
+    /**
+     * \brief Setter for the error field.
+     * \param flag The new to be set.
+     */
+    void error(small_uint<1> flag);
+
+    /**
+     * \brief Setter for the request field.
+     * \param flag The new to be set.
+     */
+    void request(small_uint<1> flag);
+
+    /**
+     * \brief Setter for the encrypted field.
+     * \param flag The new to be set.
+     */
+    void encrypted(small_uint<1 > flag);
+
+    /**
+     * \brief Setter for the key_descriptor field.
+     * \param value The new to be set.
+     */
+    void key_descriptor(small_uint<3> value);
+
+    /**
+     * \brief Setter for the key_t field.
+     * \param flag The new to be set.
+     */
+    void key_t(small_uint<1> flag);
+
+    /**
+     * \brief Setter for the key_index field.
+     * \param value The new to be set.
+     */
+    void key_index(small_uint<2> value);
+
+    /**
+     * \brief Setter for the install field.
+     * \param flag The new to be set.
+     */
+    void install(small_uint<1> flag);
+
+    /**
+     * \brief Setter for the key_ack field.
+     * \param flag The new to be set.
+     */
+    void key_ack(small_uint<1> flag);
+    
+    /**
+     * \brief Getter for the PDU's type.
+     * \return Returns the PDUType corresponding to the PDU.
+     */
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
+    
+    /**
+     * \brief Check wether this PDU matches the specified flag.
+     * \param flag The flag to match
+     * \sa PDU::matches_flag
+     */
+    bool matches_flag(PDUType flag) const {
+       return flag == pdu_flag || EAPOL::matches_flag(flag);
+    }
+    
+    /**
+     * \brief Clones this PDU.
+     * 
+     * \sa PDU::clone
+     */
+    RSNEAPOL* clone() const {
+        return new RSNEAPOL(*this);
+    }
+private:
+    TINS_BEGIN_PACK
+    struct rsn_eapol_header {
+    #if TINS_IS_LITTLE_ENDIAN
+        uint16_t key_mic:1,
+            secure:1,
+            error:1,
+            request:1,
+            encrypted:1,
+            reserved:3, 
+            key_descriptor:3,
+            key_t:1,
+            key_index:2,
+            install:1,
+            key_ack:1;       
+        uint16_t key_length;
+        uint64_t replay_counter;
+        uint8_t nonce[nonce_size], key_iv[key_iv_size];
+        uint8_t rsc[rsc_size], id[id_size];
+        uint8_t mic[mic_size];
+        uint16_t wpa_length;
+    #else
+        uint16_t reserved:3,
+            encrypted:1,
+            request:1,
+            error:1,
+            secure:1,
+            key_mic:1,
+            key_ack:1,
+            install:1,
+            key_index:2,
+            key_t:1,
+            key_descriptor:3;
+        uint16_t key_length;
+        uint64_t replay_counter;
+        uint8_t nonce[nonce_size], key_iv[key_iv_size];
+        uint8_t rsc[rsc_size], id[id_size];
+        uint8_t mic[mic_size];
+        uint16_t wpa_length;
+    #endif
+    } TINS_END_PACK;
+    
+    void write_body(Memory::OutputMemoryStream& stream);
+    
+    
+    rsn_eapol_header header_;
+    key_type key_;
+};
+
+} // Tins
 
 #endif // TINS_EAPOL_H
diff --git a/include/tins/endianness.h b/include/tins/endianness.h
index 16f6359..951f1f6 100644
--- a/include/tins/endianness.h
+++ b/include/tins/endianness.h
@@ -51,187 +51,183 @@
     #define TINS_IS_BIG_ENDIAN (__BYTE_ORDER == __BIG_ENDIAN)
 #endif
 
-
-
 namespace Tins {
 namespace Endian {
+
+/** 
+ * \brief "Changes" a 8-bit integral value's endianess. This is an
+ * identity function.
+ *
+ * \param data The data to convert.
+ */
+inline uint8_t do_change_endian(uint8_t data) {
+    return data;
+}
+
+/** 
+ * \brief Changes a 16-bit integral value's endianess.
+ *
+ * \param data The data to convert.
+ */
+inline uint16_t do_change_endian(uint16_t data) {
+    return ((data & 0xff00) >> 8)  | ((data & 0x00ff) << 8);
+}
+
+/**
+ * \brief Changes a 32-bit integral value's endianess.
+ *
+ * \param data The data to convert.
+ */
+inline uint32_t do_change_endian(uint32_t data) {
+    return (((data & 0xff000000) >> 24) | ((data & 0x00ff0000) >> 8)  |
+            ((data & 0x0000ff00) << 8)  | ((data & 0x000000ff) << 24));
+}
+
+/**
+ * \brief Changes a 64-bit integral value's endianess.
+ *
+ * \param data The data to convert.
+ */
+ inline uint64_t do_change_endian(uint64_t data) {
+    return (((uint64_t)(do_change_endian((uint32_t)(data & 0xffffffff))) << 32) |
+            (do_change_endian(((uint32_t)(data >> 32)))));
+ }
+ 
+/**
+ * \cond
+ */
+
+// Helpers to convert
+template<typename T>
+struct conversion_dispatch_helper {
+    static T dispatch(T data) {
+        return do_change_endian(data);
+    }
+};
+
+
+template<size_t>
+struct conversion_dispatcher;
+
+template<>
+struct conversion_dispatcher<sizeof(uint8_t)> 
+: public conversion_dispatch_helper<uint8_t> { };
+
+template<>
+struct conversion_dispatcher<sizeof(uint16_t)> 
+: public conversion_dispatch_helper<uint16_t> { };
+
+template<>
+struct conversion_dispatcher<sizeof(uint32_t)> 
+: public conversion_dispatch_helper<uint32_t> { };
+
+template<>
+struct conversion_dispatcher<sizeof(uint64_t)> 
+: public conversion_dispatch_helper<uint64_t> { };
+
+/**
+ * \endcond
+ */
+
+/**
+ * \brief Changes an integral value's endianess.
+ * 
+ * This dispatchs to the corresponding function.
+ *
+ * \param data The data to convert.
+ */ 
+ template<typename T>
+ inline T change_endian(T data) {
+     return conversion_dispatcher<sizeof(T)>::dispatch(data);
+ }
+
+#if TINS_IS_LITTLE_ENDIAN
     /** 
-     * \brief "Changes" a 8-bit integral value's endianess. This is an
-     * identity function.
+     * \brief Convert any integral type to big endian.
      *
      * \param data The data to convert.
      */
-    inline uint8_t do_change_endian(uint8_t data) {
-        return data;
+    template<typename T>
+    inline T host_to_be(T data) {
+        return change_endian(data);
     }
-    
-    /** 
-     * \brief Changes a 16-bit integral value's endianess.
-     *
-     * \param data The data to convert.
-     */
-    inline uint16_t do_change_endian(uint16_t data) {
-        return ((data & 0xff00) >> 8)  | ((data & 0x00ff) << 8);
-    }
-    
+     
     /**
-     * \brief Changes a 32-bit integral value's endianess.
+     * \brief Convert any integral type to little endian.
      *
+     * On little endian platforms, the parameter is simply returned.
+     * 
      * \param data The data to convert.
      */
-    inline uint32_t do_change_endian(uint32_t data) {
-        return (((data & 0xff000000) >> 24) | ((data & 0x00ff0000) >> 8)  |
-                ((data & 0x0000ff00) << 8)  | ((data & 0x000000ff) << 24));
-    }
-    
-    /**
-     * \brief Changes a 64-bit integral value's endianess.
-     *
-     * \param data The data to convert.
-     */
-     inline uint64_t do_change_endian(uint64_t data) {
-        return (((uint64_t)(do_change_endian((uint32_t)(data & 0xffffffff))) << 32) |
-                (do_change_endian(((uint32_t)(data >> 32)))));
+     template<typename T>
+     inline T host_to_le(T data) {
+         return data;
      }
      
     /**
-     * \cond
-     */
-    
-    // Helpers to convert
-    template<typename T>
-    struct conversion_dispatch_helper {
-        static T dispatch(T data) {
-            return do_change_endian(data);
-        }
-    };
-    
-    
-    template<size_t>
-    struct conversion_dispatcher;
-    
-    template<>
-    struct conversion_dispatcher<sizeof(uint8_t)> 
-    : public conversion_dispatch_helper<uint8_t> 
-    { };
-    
-    template<>
-    struct conversion_dispatcher<sizeof(uint16_t)> 
-    : public conversion_dispatch_helper<uint16_t> 
-    { };
-    
-    template<>
-    struct conversion_dispatcher<sizeof(uint32_t)> 
-    : public conversion_dispatch_helper<uint32_t> 
-    { };
-    
-    template<>
-    struct conversion_dispatcher<sizeof(uint64_t)> 
-    : public conversion_dispatch_helper<uint64_t> 
-    { };
-    
-    /**
-     * \endcond
-     */
-    
-    /**
-     * \brief Changes an integral value's endianess.
+     * \brief Convert any big endian value to the host's endianess.
      * 
-     * This dispatchs to the corresponding function.
+     * \param data The data to convert.
+     */
+     template<typename T>
+     inline T be_to_host(T data) {
+         return change_endian(data);
+     }
+     
+    /**
+     * \brief Convert any little endian value to the host's endianess.
+     * 
+     * \param data The data to convert.
+     */
+     template<typename T>
+     inline T le_to_host(T data) {
+         return data;
+     }
+#elif TINS_IS_BIG_ENDIAN
+    /** 
+     * \brief Convert any integral type to big endian.
      *
      * \param data The data to convert.
-     */ 
+     */
+    template<typename T>
+    inline T host_to_be(T data) {
+        return data;
+    }
+     
+    /**
+     * \brief Convert any integral type to little endian.
+     *
+     * On little endian platforms, the parameter is simply returned.
+     * 
+     * \param data The data to convert.
+     */
      template<typename T>
-     inline T change_endian(T data) {
-         return conversion_dispatcher<sizeof(T)>::dispatch(data);
+     inline T host_to_le(T data) {
+         return change_endian(data);
      }
-    
-    #if TINS_IS_LITTLE_ENDIAN
-        /** 
-         * \brief Convert any integral type to big endian.
-         *
-         * \param data The data to convert.
-         */
-        template<typename T>
-        inline T host_to_be(T data) {
-            return change_endian(data);
-        }
-         
-        /**
-         * \brief Convert any integral type to little endian.
-         *
-         * On little endian platforms, the parameter is simply returned.
-         * 
-         * \param data The data to convert.
-         */
-         template<typename T>
-         inline T host_to_le(T data) {
-             return data;
-         }
-         
-        /**
-         * \brief Convert any big endian value to the host's endianess.
-         * 
-         * \param data The data to convert.
-         */
-         template<typename T>
-         inline T be_to_host(T data) {
-             return change_endian(data);
-         }
-         
-        /**
-         * \brief Convert any little endian value to the host's endianess.
-         * 
-         * \param data The data to convert.
-         */
-         template<typename T>
-         inline T le_to_host(T data) {
-             return data;
-         }
-    #elif TINS_IS_BIG_ENDIAN
-        /** 
-         * \brief Convert any integral type to big endian.
-         *
-         * \param data The data to convert.
-         */
-        template<typename T>
-        inline T host_to_be(T data) {
-            return data;
-        }
-         
-        /**
-         * \brief Convert any integral type to little endian.
-         *
-         * On little endian platforms, the parameter is simply returned.
-         * 
-         * \param data The data to convert.
-         */
-         template<typename T>
-         inline T host_to_le(T data) {
-             return change_endian(data);
-         }
-         
-        /**
-         * \brief Convert any big endian value to the host's endianess.
-         * 
-         * \param data The data to convert.
-         */
-         template<typename T>
-         inline T be_to_host(T data) {
-             return data;
-         }
-         
-        /**
-         * \brief Convert any little endian value to the host's endianess.
-         * 
-         * \param data The data to convert.
-         */
-         template<typename T>
-         inline T le_to_host(T data) {
-             return change_endian(data);
-         }
-    #endif
-}
-}
+     
+    /**
+     * \brief Convert any big endian value to the host's endianess.
+     * 
+     * \param data The data to convert.
+     */
+     template<typename T>
+     inline T be_to_host(T data) {
+         return data;
+     }
+     
+    /**
+     * \brief Convert any little endian value to the host's endianess.
+     * 
+     * \param data The data to convert.
+     */
+     template<typename T>
+     inline T le_to_host(T data) {
+         return change_endian(data);
+     }
+#endif
+     
+} // Endian
+} // Tins
 
 #endif // TINS_ENDIANNESS_H
diff --git a/include/tins/ethernetII.h b/include/tins/ethernetII.h
index 63025fc..55836b1 100644
--- a/include/tins/ethernetII.h
+++ b/include/tins/ethernetII.h
@@ -39,165 +39,172 @@
 
 namespace Tins {
 
+/**
+ * \class EthernetII
+ * \brief Represents an Ethernet II PDU.
+ */
+class TINS_API EthernetII : public PDU {
+public:
     /**
-     * \class EthernetII
-     * \brief Represents an Ethernet II PDU.
+     * \brief The hardware address type.
      */
-    class TINS_API EthernetII : public PDU {
-    public:
-        /**
-         * \brief The hardware address type.
-         */
-        typedef HWAddress<6> address_type;
-        
-        /**
-         * \brief This PDU's flag.
-         */
-        static const PDU::PDUType pdu_flag = PDU::ETHERNET_II;
+    typedef HWAddress<6> address_type;
+    
+    /**
+     * \brief This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::ETHERNET_II;
 
-        /**
-         * \brief Represents the ethernetII broadcast address.
-         */
-        static const address_type BROADCAST;
+    /**
+     * \brief Represents the ethernetII broadcast address.
+     */
+    static const address_type BROADCAST;
 
-        /**
-         * \brief Constructs an ethernet II PDU.
-         *
-         * \param dst_hw_addr address_type containing the destination's MAC.
-         * \param src_hw_addr address_type containing the source's MAC.
-         */
-        EthernetII(const address_type &dst_hw_addr = address_type(), 
-                    const address_type &src_hw_addr = address_type());
+    /**
+     * \brief Constructs an ethernet II PDU.
+     *
+     * \param dst_hw_addr address_type containing the destination's MAC.
+     * \param src_hw_addr address_type containing the source's MAC.
+     */
+    EthernetII(const address_type& dst_hw_addr = address_type(), 
+               const address_type& src_hw_addr = address_type());
 
-        /**
-         * \brief Constructs a EthernetII object from a buffer and adds 
-         * all identifiable PDUs found in the buffer as children of 
-         * this one.
-         * 
-         * If the next PDU is not recognized, then a RawPDU is used.
-         * 
-         * If there is not enough size for a EthernetII header in the 
-         * buffer, a malformed_packet exception is thrown.
-         * 
-         * \param buffer The buffer from which this PDU will be constructed.
-         * \param total_sz The total size of the buffer.
-         */
-        EthernetII(const uint8_t *buffer, uint32_t total_sz);
+    /**
+     * \brief Constructs a EthernetII object from a buffer and adds 
+     * all identifiable PDUs found in the buffer as children of 
+     * this one.
+     * 
+     * If the next PDU is not recognized, then a RawPDU is used.
+     * 
+     * If there is not enough size for a EthernetII header in the 
+     * buffer, a malformed_packet exception is thrown.
+     * 
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    EthernetII(const uint8_t* buffer, uint32_t total_sz);
 
-        /* Getters */
-        /**
-         * \brief Getter for the destination's hardware address.
-         *
-         * \return address_type containing the destination hardware 
-         * address.
-         */
-        address_type dst_addr() const { return _eth.dst_mac; }
+    /* Getters */
+    /**
+     * \brief Getter for the destination's hardware address.
+     *
+     * \return address_type containing the destination hardware 
+     * address.
+     */
+    address_type dst_addr() const {
+        return header_.dst_mac;
+    }
 
-        /**
-         * \brief Getter for the source's hardware address.
-         *
-         * \return address_type containing the source hardware address.
-         */
-        address_type src_addr() const { return _eth.src_mac; }
+    /**
+     * \brief Getter for the source's hardware address.
+     *
+     * \return address_type containing the source hardware address.
+     */
+    address_type src_addr() const {
+        return header_.src_mac;
+    }
 
-        /**
-         * \brief Getter for the payload_type
-         * \return The payload type.
-         */
-        uint16_t payload_type() const { return Endian::be_to_host(_eth.payload_type); };
+    /**
+     * \brief Getter for the payload_type
+     * \return The payload type.
+     */
+    uint16_t payload_type() const {
+        return Endian::be_to_host(header_.payload_type);
+    }
 
-        /* Setters */
+    /* Setters */
 
-        /**
-         * \brief Setter for the destination hardware address.
-         *
-         * \param new_dst_addr the destination hardware address to be set.
-         */
-        void dst_addr(const address_type &new_dst_addr);
+    /**
+     * \brief Setter for the destination hardware address.
+     *
+     * \param new_dst_addr the destination hardware address to be set.
+     */
+    void dst_addr(const address_type& new_dst_addr);
 
-        /**
-         * \brief Setter for the source hardware address.
-         *
-         * \param new_src_addr the source hardware address to be set.
-         */
-        void src_addr(const address_type &new_src_addr);
+    /**
+     * \brief Setter for the source hardware address.
+     *
+     * \param new_src_addr the source hardware address to be set.
+     */
+    void src_addr(const address_type& new_src_addr);
 
-        /**
-         * \brief Setter for the payload type.
-         *
-         * \param new_payload_type the new value of the payload type field.
-         */
-        void payload_type(uint16_t new_payload_type);
+    /**
+     * \brief Setter for the payload type.
+     *
+     * \param new_payload_type the new value of the payload type field.
+     */
+    void payload_type(uint16_t new_payload_type);
 
-        /* Virtual methods */
-        /**
-         * \brief Returns the ethernet frame's header length.
-         *
-         * \return An uint32_t with the header's size.
-         * \sa PDU::header_size()
-         */
-        uint32_t header_size() const;
-        
-        /**
-         * \brief Returns the ethernet II frame's padding.
-         *
-         * \return An uint32_t with the padding size.
-         * \sa PDU::trailer_size()
-         */
-        uint32_t trailer_size() const;
+    /* Virtual methods */
+    /**
+     * \brief Returns the ethernet frame's header length.
+     *
+     * \return An uint32_t with the header's size.
+     * \sa PDU::header_size()
+     */
+    uint32_t header_size() const;
+    
+    /**
+     * \brief Returns the ethernet II frame's padding.
+     *
+     * \return An uint32_t with the padding size.
+     * \sa PDU::trailer_size()
+     */
+    uint32_t trailer_size() const;
 
-        /**
-         * \sa PDU::send()
-         */
-        void send(PacketSender &sender, const NetworkInterface &iface);
+    /**
+     * \sa PDU::send()
+     */
+    void send(PacketSender& sender, const NetworkInterface& iface);
 
-        /** 
-         * \brief Check wether ptr points to a valid response for this PDU.
-         *
-         * \sa PDU::matches_response
-         * \param ptr The pointer to the buffer.
-         * \param total_sz The size of the buffer.
-         */
-        bool matches_response(const uint8_t *ptr, uint32_t total_sz) const;
+    /** 
+     * \brief Check wether ptr points to a valid response for this PDU.
+     *
+     * \sa PDU::matches_response
+     * \param ptr The pointer to the buffer.
+     * \param total_sz The size of the buffer.
+     */
+    bool matches_response(const uint8_t* ptr, uint32_t total_sz) const;
 
-        #ifndef _WIN32
-        /** 
-         * \brief Receives a matching response for this packet.
-         *
-         * \sa PDU::recv_response
-         */
-        PDU *recv_response(PacketSender &sender, const NetworkInterface &iface);
-        #endif // _WIN32
+    #ifndef _WIN32
+    /** 
+     * \brief Receives a matching response for this packet.
+     *
+     * \sa PDU::recv_response
+     */
+    PDU* recv_response(PacketSender& sender, const NetworkInterface& iface);
+    #endif // _WIN32
 
-        /**
-         * \brief Getter for the PDU's type.
-         * \sa PDU::pdu_type
-         */
-        PDUType pdu_type() const { return PDU::ETHERNET_II; }
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
 
-        /**
-         * \sa PDU::clone
-         */
-        EthernetII *clone() const {
-            return new EthernetII(*this);
-        }
-    private:
-        /**
-         * Struct that represents the Ethernet II header
-         */
-        TINS_BEGIN_PACK
-        struct ethhdr {
-            uint8_t dst_mac[address_type::address_size];
-            uint8_t src_mac[address_type::address_size];
-            uint16_t payload_type;
-        } TINS_END_PACK;
-        
-        void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
+    /**
+     * \sa PDU::clone
+     */
+    EthernetII* clone() const {
+        return new EthernetII(*this);
+    }
+private:
+    /**
+     * Struct that represents the Ethernet II header
+     */
+    TINS_BEGIN_PACK
+    struct ethernet_header {
+        uint8_t dst_mac[address_type::address_size];
+        uint8_t src_mac[address_type::address_size];
+        uint16_t payload_type;
+    } TINS_END_PACK;
+    
+    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
 
-        ethhdr _eth;
-    };
-
-}
+    ethernet_header header_;
+};
 
+} // Tins
 
 #endif // TINS_ETHERNET_II_H
diff --git a/include/tins/exceptions.h b/include/tins/exceptions.h
index 413423a..318fe8f 100644
--- a/include/tins/exceptions.h
+++ b/include/tins/exceptions.h
@@ -34,6 +34,7 @@
 #include <stdexcept>
 
 namespace Tins {
+
 /**
  * \brief Base class for all libtins exceptions.
  */
@@ -98,6 +99,17 @@ public:
     }
 };
 
+/**
+ * \brief Exception thrown when an invalid string representation of an address
+ * is provided
+ */
+class invalid_address : public exception_base {
+public:
+    const char* what() const throw() {
+        return "Invalid address";
+    }
+};
+
 /**
  * \brief Exception thrown when a field is not present in frame.
  */
@@ -113,7 +125,7 @@ public:
  */
 class socket_open_error : public exception_base {
 public:
-    socket_open_error(const std::string &msg)
+    socket_open_error(const std::string& msg)
     : exception_base(msg) { }
 };
 
@@ -122,7 +134,7 @@ public:
  */
 class socket_close_error : exception_base {
 public:
-    socket_close_error(const std::string &msg)
+    socket_close_error(const std::string& msg)
     : exception_base(msg) { }
 };
 
@@ -131,7 +143,7 @@ public:
  */
 class socket_write_error : public exception_base {
 public:
-    socket_write_error(const std::string &msg)
+    socket_write_error(const std::string& msg)
     : exception_base(msg) { }
 };
 
@@ -141,7 +153,7 @@ public:
  */
 class invalid_socket_type : public exception_base {
 public:
-    const char *what() const throw() {
+    const char* what() const throw() {
         return "The provided socket type is invalid";
     }
 };
@@ -152,7 +164,7 @@ public:
  */
 class unknown_link_type : public exception_base {
 public:
-    const char *what() const throw() {
+    const char* what() const throw() {
         return "The sniffed link layer PDU type is unknown";
     }
 };
@@ -162,7 +174,7 @@ public:
  */
 class malformed_option : public exception_base {
 public:
-    const char *what() const throw() {
+    const char* what() const throw() {
         return "Malformed option";
     }
 };
@@ -172,7 +184,7 @@ public:
  */
 class bad_tins_cast : public exception_base {
 public:
-    const char *what() const throw() {
+    const char* what() const throw() {
         return "Bad Tins cast";
     }
 };
@@ -183,7 +195,7 @@ public:
  */
 class protocol_disabled : public exception_base {
 public:
-    const char *what() const throw() {
+    const char* what() const throw() {
         return "Protocol disabled";
     }
 };
@@ -194,11 +206,63 @@ public:
  */
 class option_payload_too_large : public exception_base {
 public:
-    const char *what() const throw() {
+    const char* what() const throw() {
         return "Option payload too large";
     }
 };
 
+/**
+ * \brief Generic pcap error
+ */
+class pcap_error : public exception_base {
+public:
+    pcap_error(const char* message) : exception_base(message) {
+
+    }
+};
+
+/**
+ * \brief Exception thrown when an invalid pcap filter is compiled
+ */
+class invalid_pcap_filter : public exception_base {
+public:
+    invalid_pcap_filter(const char* message) : exception_base(message) {
+
+    }
+};
+
+/**
+ * \brief Exception thrown when serialiation of a non-serializable PDU
+ * is attempted
+ */
+class pdu_not_serializable : public exception_base {
+public:
+    const char* what() const throw() {
+        return "PDU not serializable";
+    }
+};
+
+/**
+ * \brief Exception thrown when opening a pcap handle fails
+ */
+class pcap_open_failed : public exception_base {
+public:
+    const char* what() const throw() {
+        return "Failed to create pcap handle";
+    }
+};
+
+/**
+ * \brief Exception thrown when a function not supported on the current OS
+ * is called
+ */
+class unsupported_function : public exception_base {
+public:
+    const char* what() const throw() {
+        return "Function is not supported on this OS";
+    }
+};
+
 namespace Crypto {
 namespace WPA2 {
     /**
@@ -206,7 +270,7 @@ namespace WPA2 {
      */
     class invalid_handshake : public exception_base {
     public:
-        const char *what() const throw() {
+        const char* what() const throw() {
             return "Invalid WPA2 handshake";
         }
     };
diff --git a/include/tins/handshake_capturer.h b/include/tins/handshake_capturer.h
index 767acd9..eb51e58 100644
--- a/include/tins/handshake_capturer.h
+++ b/include/tins/handshake_capturer.h
@@ -39,132 +39,132 @@
 #include "macros.h"
 #include "eapol.h"
 
-// .h
 namespace Tins {
+
+/**
+ * \brief Generic EAPOL handshake.
+ *
+ * Stores both the client and supplicant addresses, as well as 
+ * all of the EAPOL packets used during the handshake.
+ */
+template<typename T>
+class EAPOLHandshake {
+public:
+    typedef std::vector<T> container_type;
+    typedef HWAddress<6> address_type;
+    
     /**
-     * \brief Generic EAPOL handshake.
+     * \brief Default constructor.
+     */
+    EAPOLHandshake() { }
+
+    /**
+     * Constructs an EAPOLHandshake object.
+     * 
+     * \param client_address The client address.
+     * \param supplicant_address The supplicant address.
+     * \param cont The container that holds the EAPOL packets used
+     * in the handshake.
+     */
+    EAPOLHandshake(const address_type& client_address, 
+                   const address_type& supplicant_address, 
+                   const container_type& cont) 
+    : cl_address_(client_address), suppl_address_(supplicant_address), 
+      handshake_(cont) {
+    }
+    
+    /**
+     * \return const address_type&
+     */
+    const address_type& client_address() const {
+        return cl_address_;
+    }
+    
+    /**
+     * \return const address_type&
+     */
+    const address_type& supplicant_address() const {
+        return suppl_address_;
+    }
+    
+    /**
+     * \return const container_type&
+     */
+    const container_type& handshake() const {
+        return handshake_;
+    }
+private:
+    address_type cl_address_, suppl_address_;
+    container_type handshake_;
+};
+
+/**
+ * The type used to store RSN handshakes.
+ */
+typedef EAPOLHandshake<RSNEAPOL> RSNHandshake;
+
+/**
+ * Captures 802.1X RSN handshakes.
+ */
+class TINS_API RSNHandshakeCapturer {
+public:
+    /**
+     * The type of handshakes that will be captured.
+     */
+    typedef RSNHandshake handshake_type;
+
+    /**
+     * The type in which all of the captured handshakes
+     * will be stored.
+     */
+    typedef std::vector<handshake_type> handshakes_type;
+    
+    /**
+     * \brief Processes a packet.
+     * 
+     * This will fetch the RSNEAPOL layer, if any, and store
+     * it in an intermediate storage. When a handshake is 
+     * completed, it will be stored separately. 
      *
-     * Stores both the client and supplicant addresses, as well as 
-     * all of the EAPOL packets used during the handshake.
+     * \sa RSNHandshakeCapturer::handshakes
      */
-    template<typename T>
-    class EAPOLHandshake {
-    public:
-        typedef std::vector<T> container_type;
-        typedef HWAddress<6> address_type;
-        
-        /**
-         * \brief Default constructor.
-         */
-        EAPOLHandshake() { }
+    bool process_packet(const PDU& pdu);
 
-        /**
-         * Constructs an EAPOLHandshake object.
-         * 
-         * \param client_address The client address.
-         * \param supplicant_address The supplicant address.
-         * \param cont The container that holds the EAPOL packets used
-         * in the handshake.
-         */
-        EAPOLHandshake(const address_type &client_address, 
-          const address_type &supplicant_address, const container_type &cont) 
-        : cl_address_(client_address), suppl_address_(supplicant_address), 
-        handshake_(cont) 
-        {
-            
-        }
-        
-        /**
-         * \return const address_type&
-         */
-        const address_type &client_address() const {
-            return cl_address_;
-        }
-        
-        /**
-         * \return const address_type&
-         */
-        const address_type &supplicant_address() const {
-            return suppl_address_;
-        }
-        
-        /**
-         * \return const container_type&
-         */
-        const container_type &handshake() const {
-            return handshake_;
-        }
-    private:
-        address_type cl_address_, suppl_address_;
-        container_type handshake_;
-    };
-    
     /**
-     * The type used to store RSN handshakes.
+     * \brief Retrieves the completed handshakes.
+     *
+     * This will return the handshakes that have been completed 
+     * so far. A handshake is completed when the 4-way handshake
+     * is captured.
+     *
+     * \sa RSNHandshakeCapturer::clear_handshakes
      */
-    typedef EAPOLHandshake<RSNEAPOL> RSNHandshake;
-    
+    const handshakes_type& handshakes() const {
+        return completed_handshakes_;
+    }
+
     /**
-     * Captures 802.1X RSN handshakes.
+     * \brief Clears the completed handshakes.
+     *
+     * Since completed handshakes are stored in a std::vector,
+     * it is advisable to remove all of them once they have been 
+     * processed.
      */
-    class TINS_API RSNHandshakeCapturer {
-    public:
-        /**
-         * The type of handshakes that will be captured.
-         */
-        typedef RSNHandshake handshake_type;
+    void clear_handshakes() {
+        completed_handshakes_.clear();
+    }
+private:
+    typedef handshake_type::address_type address_type;
+    typedef handshake_type::container_type eapol_list;
+    typedef std::map<std::pair<address_type, address_type>, eapol_list> handshake_map;
 
-        /**
-         * The type in which all of the captured handshakes
-         * will be stored.
-         */
-        typedef std::vector<handshake_type> handshakes_type;
-        
-        /**
-         * \brief Processes a packet.
-         * 
-         * This will fetch the RSNEAPOL layer, if any, and store
-         * it in an intermediate storage. When a handshake is 
-         * completed, it will be stored separately. 
-         *
-         * \sa RSNHandshakeCapturer::handshakes
-         */
-        bool process_packet(const PDU &pdu);
+    bool do_insert(const handshake_map::key_type& key, const RSNEAPOL* eapol, 
+      size_t expected);
 
-        /**
-         * \brief Retrieves the completed handshakes.
-         *
-         * This will return the handshakes that have been completed 
-         * so far. A handshake is completed when the 4-way handshake
-         * is captured.
-         *
-         * \sa RSNHandshakeCapturer::clear_handshakes
-         */
-        const handshakes_type &handshakes() const {
-            return completed_handshakes_;
-        }
+    handshake_map handshakes_;
+    handshakes_type completed_handshakes_;
+};
 
-        /**
-         * \brief Clears the completed handshakes.
-         *
-         * Since completed handshakes are stored in a std::vector,
-         * it is advisable to remove all of them once they have been 
-         * processed.
-         */
-        void clear_handshakes() {
-            completed_handshakes_.clear();
-        }
-    private:
-        typedef handshake_type::address_type address_type;
-        typedef handshake_type::container_type eapol_list;
-        typedef std::map<std::pair<address_type, address_type>, eapol_list> handshake_map;
-    
-        bool do_insert(const handshake_map::key_type &key, const RSNEAPOL *eapol, 
-          size_t expected);
-    
-        handshake_map handshakes_;
-        handshakes_type completed_handshakes_;
-    };
-}
+} // Tins
 
 #endif // TINS_HANDSHAKE_CAPTURER_H
diff --git a/include/tins/hw_address.h b/include/tins/hw_address.h
index d385f00..53aa811 100644
--- a/include/tins/hw_address.h
+++ b/include/tins/hw_address.h
@@ -40,6 +40,7 @@
 #include "cxxstd.h"
 
 namespace Tins {
+
 /**
  * \class HWAddress
  * \brief Represents a hardware address.
@@ -107,10 +108,12 @@ public:
      * \param ptr The pointer from which to construct this address.
      */
     HWAddress(const storage_type* ptr = 0) {
-        if(ptr)
-            std::copy(ptr, ptr + address_size, buffer);
-        else
+        if (ptr) {
+            std::copy(ptr, ptr + address_size, buffer_);
+        }
+        else {
             std::fill(begin(), end(), storage_type());
+        }
     }
     
     /**
@@ -124,15 +127,15 @@ public:
      * 
      * \param address The hex-notation address to be parsed.
      */
-    HWAddress(const std::string &address) {
-        convert(address, buffer);
+    HWAddress(const std::string& address) {
+        convert(address, buffer_);
     }
     
     /**
      * \brief Overload provided basically for string literals.
      * 
      * This constructor takes a const char array of i elements in
-     * hex-notation. \sa HWAddress::HWAddress(const std::string &address)
+     * hex-notation. \sa HWAddress::HWAddress(const std::string& address)
      * 
      * This is mostly used when providing string literals. If this where 
      * a const char*, then there would be an ambiguity when providing 
@@ -143,7 +146,7 @@ public:
      */
     template<size_t i>
     HWAddress(const char (&address)[i]) {
-        convert(address, buffer);
+        convert(address, buffer_);
     }
     
     /**
@@ -159,7 +162,7 @@ public:
      * \param rhs The HWAddress to be constructed from.
      */
     template<size_t i>
-    HWAddress(const HWAddress<i> &rhs) {
+    HWAddress(const HWAddress<i>& rhs) {
         // Fill extra bytes
         std::fill(
             // Copy as most as we can
@@ -181,7 +184,7 @@ public:
      * \return iterator.
      */
     iterator begin() {
-        return buffer;
+        return buffer_;
     }
     
     /**
@@ -191,7 +194,7 @@ public:
      * \return const_iterator.
      */
     const_iterator begin() const {
-        return buffer;
+        return buffer_;
     }
     
     /**
@@ -201,7 +204,7 @@ public:
      * \return iterator.
      */
     iterator end() {
-        return buffer + address_size;
+        return buffer_ + address_size;
     }
 
     /**
@@ -211,7 +214,7 @@ public:
      * \return const_iterator.
      */
     const_iterator end() const {
-        return buffer + address_size;
+        return buffer_ + address_size;
     }
     
     /**
@@ -221,8 +224,8 @@ public:
      * 
      * \return bool indicating whether addresses are equal.
      */
-    bool operator==(const HWAddress &rhs) const {
-        return std::equal(begin(), end(), rhs.buffer);
+    bool operator==(const HWAddress& rhs) const {
+        return std::equal(begin(), end(), rhs.begin());
     }
     
     /**
@@ -232,7 +235,7 @@ public:
      * 
      * \return bool indicating whether addresses are distinct.
      */
-    bool operator!=(const HWAddress &rhs) const {
+    bool operator!=(const HWAddress& rhs) const {
         return !(*this == rhs);
     }
     
@@ -243,7 +246,7 @@ public:
      * 
      * \return bool indicating whether this address is less-than rhs.
      */
-    bool operator<(const HWAddress &rhs) const {
+    bool operator<(const HWAddress& rhs) const {
         return std::lexicographical_compare(begin(), end(), rhs.begin(), rhs.end());
     }
     
@@ -260,14 +263,14 @@ public:
      * \brief Indicates whether this is a broadcast address.
      */
     bool is_broadcast() const {
-        return *this == broadcast;
+        return* this == broadcast;
     }
     
     /**
      * \brief Indicates whether this is a multicast address.
      */
     bool is_multicast() const {
-        return (buffer[0] & 0x01);
+        return (*begin() & 0x01);
     }
 
     /**
@@ -284,7 +287,7 @@ public:
      */
     std::string to_string() const {
         std::ostringstream oss;
-        oss << *this;
+        oss <<* this;
         return oss.str();
     }
 
@@ -294,7 +297,7 @@ public:
      * \param i The element to retrieve.
      */
     storage_type operator[](size_t i) const {
-        return buffer[i];
+        return begin()[i];
     }
     
     /**
@@ -304,14 +307,14 @@ public:
      * \param addr The parameter to be written.
      * \return std::ostream& pointing to the os parameter.
      */
-    friend std::ostream &operator<<(std::ostream &os, const HWAddress &addr) {
+    friend std::ostream& operator<<(std::ostream& os, const HWAddress& addr) {
         std::transform(
             addr.begin(), 
             addr.end() - 1,
             std::ostream_iterator<std::string>(os, ":"),
             &HWAddress::storage_to_string
         );
-        return os << storage_to_string(addr.buffer[HWAddress::address_size-1]);
+        return os << storage_to_string(addr.begin()[HWAddress::address_size - 1]);
     }
     
     /**
@@ -338,70 +341,91 @@ public:
     }
 private:
     template<typename OutputIterator>
-    static void convert(const std::string &hw_addr, OutputIterator output);
+    static void convert(const std::string& hw_addr, OutputIterator output);
     
+    static HWAddress<n> make_broadcast_address() {
+        // Build a buffer made of n 0xff bytes
+        uint8_t buffer[n];
+        for (size_t i = 0; i < n; ++i) {
+            buffer[i] = 0xff;
+        }
+        return HWAddress<n>(buffer);
+    }
+
     static std::string storage_to_string(storage_type element) {
         std::ostringstream oss;
         oss << std::hex;
-        if(element < 0x10)
+        if (element < 0x10) {
             oss << '0';
+        }
         oss << (unsigned)element;
         return oss.str();
     }
 
-    storage_type buffer[n];
+    storage_type buffer_[n];
 };
 
 template<size_t n, typename Storage>
 template<typename OutputIterator>
-void HWAddress<n, Storage>::convert(const std::string &hw_addr, 
-  OutputIterator output) 
-{
+void HWAddress<n, Storage>::convert(const std::string& hw_addr, 
+                                    OutputIterator output)  {
     unsigned i(0);
     size_t count(0);
     storage_type tmp;
-    while(i < hw_addr.size() && count < n) {
+    while (i < hw_addr.size() && count < n) {
         const unsigned end = i+2;
         tmp = storage_type();
-        while(i < end) {
-            if(hw_addr[i] >= 'a' && hw_addr[i] <= 'f')
+        while (i < end) {
+            if (hw_addr[i] >= 'a' && hw_addr[i] <= 'f') {
                 tmp = (tmp << 4) | (hw_addr[i] - 'a' + 10);
-            else if(hw_addr[i] >= 'A' && hw_addr[i] <= 'F')
+            }
+            else if (hw_addr[i] >= 'A' && hw_addr[i] <= 'F') {
                 tmp = (tmp << 4) | (hw_addr[i] - 'A' + 10);
-            else if(hw_addr[i] >= '0' && hw_addr[i] <= '9')
+            }
+            else if (hw_addr[i] >= '0' && hw_addr[i] <= '9') {
                 tmp = (tmp << 4) | (hw_addr[i] - '0');
-            else if(hw_addr[i] == ':')
+            }
+            else if (hw_addr[i] == ':') {
                 break;
-            else
+            }
+            else {
                 throw std::runtime_error("Invalid byte found");
+            }
             i++;
         }
         *(output++) = tmp;
         count++;
-        if(i < hw_addr.size()) {
-            if(hw_addr[i] == ':')
+        if (i < hw_addr.size()) {
+            if (hw_addr[i] == ':') {
                 i++;
-            else
+            }
+            else {
                 throw std::runtime_error("Invalid separator");
+            }
         }
     }
-    while(count++ < n) {
+    while (count++ < n) {
         *(output++) = storage_type();
     }
 }
 
 template<size_t n, typename Storage>
-const HWAddress<n, Storage> HWAddress<n, Storage>::broadcast("ff:ff:ff:ff:ff:ff");
+const HWAddress<n, Storage> HWAddress<n, Storage>::broadcast = make_broadcast_address();
+
 } // namespace Tins
+
 #if TINS_IS_CXX11
-namespace std
-{
+namespace std {
+
+// Specialization of std::hash for HWAddress
 template<size_t n>
 struct hash<Tins::HWAddress<n>> {
-    size_t operator()(const Tins::HWAddress<n> &addr) const {
+    size_t operator()(const Tins::HWAddress<n>& addr) const {
         return std::hash<std::string>()(addr.to_string());
     }
 };
+
 } // namespace std
-#endif
+#endif // TINS_IS_CXX11
+
 #endif // TINS_HWADDRESS_H
diff --git a/include/tins/icmp.h b/include/tins/icmp.h
index 2e70758..b643498 100644
--- a/include/tins/icmp.h
+++ b/include/tins/icmp.h
@@ -50,7 +50,9 @@
 
 namespace Tins {
 namespace Memory {
+
 class InputMemoryStream;
+
 } // Memory
 
 /** 
@@ -109,7 +111,7 @@ public:
      * \param buffer The buffer from which this PDU will be constructed.
      * \param total_sz The total size of the buffer.
      */
-    ICMP(const uint8_t *buffer, uint32_t total_sz);
+    ICMP(const uint8_t* buffer, uint32_t total_sz);
     
     /**
      * \brief Sets the code field.
@@ -262,43 +264,53 @@ public:
      *
      * \return The type flag for this ICMP PDU.
      */
-    Flags type() const { return (Flags)_icmp.type; }
+    Flags type() const {
+        return (Flags)header_.type;
+    }
 
     /**
      * \brief Getter for the ICMP code flag.
      *
      * \return The code flag for this ICMP PDU.
      */
-    uint8_t code() const { return _icmp.code; }
+    uint8_t code() const {
+        return header_.code;
+    }
 
     /**
      * \brief Getter for the checksum field.
      *
      * \return Returns the checksum as an unit16_t.
      */
-    uint16_t checksum() const { return Endian::be_to_host(_icmp.check); }
+    uint16_t checksum() const {
+        return Endian::be_to_host(header_.check);
+    }
 
     /**
      * \brief Getter for the echo id.
      *
      * \return Returns the echo id.
      */
-    uint16_t id() const { return Endian::be_to_host(_icmp.un.echo.id); }
+    uint16_t id() const {
+        return Endian::be_to_host(header_.un.echo.id);
+    }
 
     /**
      * \brief Getter for the echo sequence number.
      *
      * \return Returns the echo sequence number.
      */
-    uint16_t sequence() const { return Endian::be_to_host(_icmp.un.echo.sequence); }
+    uint16_t sequence() const {
+        return Endian::be_to_host(header_.un.echo.sequence);
+    }
 
     /**
      * \brief Getter for the gateway field.
      *
      * \return Returns the gateway field value.
      */
-    address_type gateway() const { 
-        return address_type(Endian::be_to_host(_icmp.un.gateway)); 
+    address_type gateway() const {
+        return address_type(Endian::be_to_host(header_.un.gateway));
     }
 
     /**
@@ -306,50 +318,62 @@ public:
      *
      * \return Returns the pointer field value.
      */
-    uint8_t pointer() const { return _icmp.un.rfc4884.pointer; }
+    uint8_t pointer() const {
+        return header_.un.rfc4884.pointer;
+    }
 
     /**
      * \brief Getter for the length field.
      *
      * \return Returns the length field value.
      */
-    uint8_t length() const { return _icmp.un.rfc4884.length; }
+    uint8_t length() const {
+        return header_.un.rfc4884.length;
+    }
     
     /**
       * \brief Getter for the mtu field.
       *
       * \return Returns the mtu field value.
       */
-    uint16_t mtu() const { return Endian::be_to_host(_icmp.un.frag.mtu); }
+    uint16_t mtu() const {
+        return Endian::be_to_host(header_.un.frag.mtu);
+    }
 
     /**
       * \brief Getter for the original timestamp field.
       *
       * \return Returns the original timestamp value.
       */
-    uint32_t original_timestamp() const { return Endian::be_to_host(_orig_timestamp_or_address_mask); }
+    uint32_t original_timestamp() const {
+        return Endian::be_to_host(orig_timestamp_or_address_mask_);
+    }
 
     /**
       * \brief Getter for the receive timestamp field.
       *
       * \return Returns the receive timestamp value.
       */
-    uint32_t receive_timestamp() const { return Endian::be_to_host(_recv_timestamp); }
+    uint32_t receive_timestamp() const {
+        return Endian::be_to_host(recv_timestamp_);
+    }
 
     /**
       * \brief Getter for the transmit timestamp field.
       *
       * \return Returns the transmit timestamp value.
       */
-    uint32_t transmit_timestamp() const { return Endian::be_to_host(_trans_timestamp); }
+    uint32_t transmit_timestamp() const {
+        return Endian::be_to_host(trans_timestamp_);
+    }
 
     /**
       * \brief Getter for the address mask field.
       *
       * \return Returns the address mask value.
       */
-    address_type address_mask() const { 
-        return address_type(Endian::be_to_host(_orig_timestamp_or_address_mask)); 
+    address_type address_mask() const {
+        return address_type(Endian::be_to_host(orig_timestamp_or_address_mask_));
     }
 
     /**
@@ -378,26 +402,32 @@ public:
      * \param ptr The pointer to the buffer.
      * \param total_sz The size of the buffer.
      */
-    bool matches_response(const uint8_t *ptr, uint32_t total_sz) const;
+    bool matches_response(const uint8_t* ptr, uint32_t total_sz) const;
 
     /** 
      * \brief Getter for the extensions field.
      *
      * \return The extensions field
      */
-    const ICMPExtensionsStructure& extensions() const { return extensions_; }
+    const ICMPExtensionsStructure& extensions() const {
+        return extensions_;
+    }
 
     /** 
      * \brief Getter for the extensions field.
      *
      * \return The extensions field
      */
-    ICMPExtensionsStructure& extensions() { return extensions_; }
+    ICMPExtensionsStructure& extensions() {
+        return extensions_;
+    }
 
     /**
      * \brief Indicates whether this object contains ICMP extensions
      */
-    bool has_extensions() const { return !extensions_.extensions().empty(); }
+    bool has_extensions() const {
+        return !extensions_.extensions().empty();
+    }
 
     /**
      * \brief Sets whether the length field will be set for packets that use it
@@ -421,17 +451,19 @@ public:
      *
      * \sa PDU::pdu_type
      */
-    PDUType pdu_type() const { return PDU::ICMP; }
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
 
     /**
      * \sa PDU::clone
      */
-    ICMP *clone() const {
+    ICMP* clone() const {
         return new ICMP(*this);
     }
 private:
     TINS_BEGIN_PACK
-    struct icmphdr {
+    struct icmp_header {
         uint8_t	type;
         uint8_t	code;
         uint16_t check;
@@ -460,14 +492,14 @@ private:
      * \param total_sz The size available in the buffer.
      * \param parent The PDU that's one level below this one on the stack.
      */
-    void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
     
     uint32_t get_adjusted_inner_pdu_size() const;
     void try_parse_extensions(Memory::InputMemoryStream& stream);
     bool are_extensions_allowed() const;
 
-    icmphdr _icmp;
-    uint32_t _orig_timestamp_or_address_mask, _recv_timestamp, _trans_timestamp;
+    icmp_header header_;
+    uint32_t orig_timestamp_or_address_mask_, recv_timestamp_, trans_timestamp_;
     ICMPExtensionsStructure extensions_;
 };
 
diff --git a/include/tins/icmp_extension.h b/include/tins/icmp_extension.h
index 959d211..be71b87 100644
--- a/include/tins/icmp_extension.h
+++ b/include/tins/icmp_extension.h
@@ -104,21 +104,27 @@ public:
      *
      * \return The extension class field value
      */
-    uint8_t extension_class() const { return extension_class_; }
+    uint8_t extension_class() const {
+        return extension_class_;
+    }
 
     /**
      * \brief Getter for the extension sub-type field
      *
      * \return The extension sub-type field value
      */
-    uint8_t extension_type() const { return extension_type_; }
+    uint8_t extension_type() const {
+        return extension_type_;
+    }
 
     /**
      * \brief Getter for the extension payload field
      *
      * \return The extension payload field value
      */
-    const payload_type& payload() const { return payload_; }
+    const payload_type& payload() const {
+        return payload_;
+    }
 
     /**
      * \brief Gets the size of this ICMP extension
@@ -206,9 +212,9 @@ public:
      *
      * \return The version field value
      */
-    small_uint<4> version() const { 
+    small_uint<4> version() const {
         uint16_t value = Endian::be_to_host(version_and_reserved_);
-        return (value >> 12) & 0xf; 
+        return (value >> 12) & 0xf;
     }
 
     /**
@@ -216,7 +222,7 @@ public:
      *
      * \return The reserved field value
      */
-    small_uint<12> reserved() const { 
+    small_uint<12> reserved() const {
         uint16_t value = Endian::be_to_host(version_and_reserved_);
         return value & 0xfff;
     }
@@ -226,14 +232,18 @@ public:
      *
      * \return The checksum field value
      */
-    uint16_t checksum() const { return Endian::be_to_host(checksum_); }
+    uint16_t checksum() const {
+        return Endian::be_to_host(checksum_);
+    }
 
     /**
      * \brief Getter for the extensions stored by this structure
      *
      * \return The extensions stored in this structure
      */
-    const extensions_type& extensions() const { return extensions_; }
+    const extensions_type& extensions() const {
+        return extensions_;
+    }
 
     /**
      * \brief Adds an extension to this structure
diff --git a/include/tins/icmpv6.h b/include/tins/icmpv6.h
index 395e280..90021ff 100644
--- a/include/tins/icmpv6.h
+++ b/include/tins/icmpv6.h
@@ -45,8 +45,10 @@
 
 namespace Tins {
 namespace Memory {
+
 class InputMemoryStream;
 class OutputMemoryStream;
+
 } // memory
 
 /**
@@ -164,13 +166,12 @@ public:
         uint8_t reserved[6];
         addresses_type addresses;
         
-        addr_list_type(const addresses_type &addresses = addresses_type())
-        : addresses(addresses) 
-        {
+        addr_list_type(const addresses_type& addresses = addresses_type())
+        : addresses(addresses) {
             std::fill(reserved, reserved + sizeof(reserved), 0);
         }
         
-        static addr_list_type from_option(const option &opt);
+        static addr_list_type from_option(const option& opt);
     };
     
     /**
@@ -192,12 +193,11 @@ public:
         uint8_t reserved[4];
         
         naack_type(uint8_t code = 0, uint8_t status = 0)
-        : code(code), status(status)
-        {
+        : code(code), status(status) {
             std::fill(reserved, reserved + 4, 0);
         }
         
-        static naack_type from_option(const option &opt);
+        static naack_type from_option(const option& opt);
     };
     
     /**
@@ -216,9 +216,8 @@ public:
          * \param address The address to be stored.
          */
         lladdr_type(uint8_t option_code = 0, 
-          const address_type &address = address_type())
-        : option_code(option_code), address(address) 
-        {
+                    const address_type& address = address_type())
+        : option_code(option_code), address(address) {
             
         }
         
@@ -231,14 +230,12 @@ public:
          * \param option_code The option code.
          * \param address The address to be stored.
          */
-        lladdr_type(uint8_t option_code, 
-          const hwaddress_type &address)
-        : option_code(option_code), address(address.begin(), address.end()) 
-        {
+        lladdr_type(uint8_t option_code, const hwaddress_type& address)
+        : option_code(option_code), address(address.begin(), address.end()) {
             
         }
         
-        static lladdr_type from_option(const option &opt);
+        static lladdr_type from_option(const option& opt);
     };
     
     /**
@@ -252,14 +249,16 @@ public:
                 reserved2;
         ipaddress_type prefix;
         
-        prefix_info_type(uint8_t prefix_len=0, small_uint<1> A=0, small_uint<1> L=0,
-          uint32_t valid_lifetime=0, uint32_t preferred_lifetime=0,
-          const ipaddress_type &prefix = ipaddress_type())
-        : prefix_len(prefix_len), A(A), L(L), 
-          valid_lifetime(valid_lifetime), preferred_lifetime(preferred_lifetime),
-          prefix(prefix) { }
+        prefix_info_type(uint8_t prefix_len = 0, 
+                         small_uint<1> A = 0,
+                         small_uint<1> L = 0,
+                         uint32_t valid_lifetime = 0, 
+                         uint32_t preferred_lifetime = 0,
+                         const ipaddress_type& prefix = ipaddress_type())
+        : prefix_len(prefix_len), A(A), L(L), valid_lifetime(valid_lifetime),
+          preferred_lifetime(preferred_lifetime), prefix(prefix) { }
           
-        static prefix_info_type from_option(const option &opt);
+        static prefix_info_type from_option(const option& opt);
     };
     
     /**
@@ -291,8 +290,7 @@ public:
          */
         template<typename RAIterator, typename ForwardIterator>
         rsa_sign_type(RAIterator hash, ForwardIterator start, ForwardIterator end)
-        : signature(start, end)
-        {
+        : signature(start, end) {
             std::copy(hash, hash + sizeof(key_hash), key_hash);
         }
         
@@ -309,9 +307,8 @@ public:
          * \param sign The signature to be set.
          */
         template<typename RAIterator>
-        rsa_sign_type(RAIterator hash, const signature_type &sign)
-        : signature(sign)
-        {
+        rsa_sign_type(RAIterator hash, const signature_type& sign)
+        : signature(sign) {
             std::copy(hash, hash + sizeof(key_hash), key_hash);
         }
         
@@ -320,12 +317,11 @@ public:
          * 
          * The key_hash member will be 0-initialized.
          */
-        rsa_sign_type()
-        {
+        rsa_sign_type() {
             std::fill(key_hash, key_hash + sizeof(key_hash), 0);
         }
 
-        static rsa_sign_type from_option(const option &opt);
+        static rsa_sign_type from_option(const option& opt);
     };
     
     /**
@@ -335,12 +331,13 @@ public:
         uint8_t option_code, prefix_len;
         ipaddress_type address;
         
-        ip_prefix_type(uint8_t option_code = 0, uint8_t prefix_len = 0,
-          const ipaddress_type &address = ipaddress_type())
+        ip_prefix_type(uint8_t option_code = 0,
+                       uint8_t prefix_len = 0,
+                       const ipaddress_type& address = ipaddress_type())
         : option_code(option_code), prefix_len(prefix_len), address(address)
         {}
 
-        static ip_prefix_type from_option(const option &opt);
+        static ip_prefix_type from_option(const option& opt);
     };
     
     /**
@@ -352,13 +349,15 @@ public:
         uint32_t valid_lifetime;
         ipaddress_type address;
         
-        map_type(small_uint<4> dist = 0, small_uint<4> pref = 0, 
-          small_uint<1> r = 0, uint32_t valid_lifetime = 0, 
-          const ipaddress_type &address = ipaddress_type())
+        map_type(small_uint<4> dist = 0,
+                 small_uint<4> pref = 0, 
+                 small_uint<1> r = 0, 
+                 uint32_t valid_lifetime = 0, 
+                 const ipaddress_type& address = ipaddress_type())
         : dist(dist), pref(pref), r(r), valid_lifetime(valid_lifetime),
           address(address) { }
 
-        static map_type from_option(const option &opt);
+        static map_type from_option(const option& opt);
     };
     
     /**
@@ -372,12 +371,14 @@ public:
         uint32_t route_lifetime;
         prefix_type prefix;
         
-        route_info_type(uint8_t prefix_len = 0, small_uint<2> pref = 0, 
-          uint32_t route_lifetime = 0, const prefix_type &prefix = prefix_type())
+        route_info_type(uint8_t prefix_len = 0, 
+                        small_uint<2> pref = 0, 
+                        uint32_t route_lifetime = 0,
+                        const prefix_type& prefix = prefix_type())
         : prefix_len(prefix_len), pref(pref), route_lifetime(route_lifetime),
           prefix(prefix) { }
 
-        static route_info_type from_option(const option &opt);
+        static route_info_type from_option(const option& opt);
     };
     
     /**
@@ -390,10 +391,10 @@ public:
         servers_type servers;
         
         recursive_dns_type(uint32_t lifetime = 0, 
-          const servers_type &servers = servers_type())
+                           const servers_type& servers = servers_type())
         : lifetime(lifetime), servers(servers) {}
 
-        static recursive_dns_type from_option(const option &opt);
+        static recursive_dns_type from_option(const option& opt);
     };
     
     /**
@@ -406,10 +407,10 @@ public:
         key_type key;
         
         handover_key_req_type(small_uint<4> AT = 0,
-          const key_type &key = key_type())
+                              const key_type& key = key_type())
         : AT(AT), key(key) { }
 
-        static handover_key_req_type from_option(const option &opt);
+        static handover_key_req_type from_option(const option& opt);
     };
     
     /**
@@ -418,11 +419,12 @@ public:
     struct handover_key_reply_type : handover_key_req_type {
         uint16_t lifetime;
         
-        handover_key_reply_type(uint16_t lifetime = 0, small_uint<4> AT = 0,
-          const key_type &key = key_type())
+        handover_key_reply_type(uint16_t lifetime = 0, 
+                                small_uint<4> AT = 0,
+                                const key_type& key = key_type())
         : handover_key_req_type(AT, key), lifetime(lifetime) { }
 
-        static handover_key_reply_type from_option(const option &opt);
+        static handover_key_reply_type from_option(const option& opt);
     };
     
     /**
@@ -435,10 +437,10 @@ public:
         hai_type hai;
         
         handover_assist_info_type(uint8_t option_code=0, 
-          const hai_type &hai = hai_type())
+                                  const hai_type& hai = hai_type())
         : option_code(option_code), hai(hai) { }
 
-        static handover_assist_info_type from_option(const option &opt);
+        static handover_assist_info_type from_option(const option& opt);
     };
     
     /**
@@ -451,10 +453,10 @@ public:
         mn_type mn;
         
         mobile_node_id_type(uint8_t option_code=0, 
-          const mn_type &mn = mn_type())
+                            const mn_type& mn = mn_type())
         : option_code(option_code), mn(mn) { }
 
-        static mobile_node_id_type from_option(const option &opt);
+        static mobile_node_id_type from_option(const option& opt);
     };
     
     /**
@@ -467,10 +469,10 @@ public:
         domains_type domains;
         
         dns_search_list_type(uint32_t lifetime = 0,
-          const domains_type &domains = domains_type())
+                             const domains_type& domains = domains_type())
         : lifetime(lifetime), domains(domains) { }
 
-        static dns_search_list_type from_option(const option &opt);
+        static dns_search_list_type from_option(const option& opt);
     };
 
     /**
@@ -481,12 +483,11 @@ public:
         uint64_t timestamp;
 
         timestamp_type(uint64_t timestamp = 0)
-        : timestamp(timestamp)
-        {
+        : timestamp(timestamp) {
             std::fill(reserved, reserved + sizeof(reserved), 0);
         }
 
-        static timestamp_type from_option(const option &opt);
+        static timestamp_type from_option(const option& opt);
     };
 
     /**
@@ -497,12 +498,11 @@ public:
         uint32_t reserved2;
 
         shortcut_limit_type(uint8_t limit = 0)
-        : limit(limit), reserved1(), reserved2()
-        {
+        : limit(limit), reserved1(), reserved2() {
 
         }
 
-        static shortcut_limit_type from_option(const option &opt);
+        static shortcut_limit_type from_option(const option& opt);
     };
 
     /**
@@ -513,12 +513,11 @@ public:
         uint32_t interval;
 
         new_advert_interval_type(uint32_t interval = 0)
-        : reserved(), interval(interval)
-        {
+        : reserved(), interval(interval) {
 
         }
 
-        static new_advert_interval_type from_option(const option &opt);
+        static new_advert_interval_type from_option(const option& opt);
     };
 
     /**
@@ -566,7 +565,7 @@ public:
      * \param buffer The buffer from which this PDU will be constructed.
      * \param total_sz The total size of the buffer.
      */
-    ICMPv6(const uint8_t *buffer, uint32_t total_sz);
+    ICMPv6(const uint8_t* buffer, uint32_t total_sz);
     
     // Getters
 
@@ -575,7 +574,7 @@ public:
      *  \return The stored type field value.
      */
     Types type() const {
-        return static_cast<Types>(_header.type);
+        return static_cast<Types>(header_.type);
     }
 
     /**
@@ -583,7 +582,7 @@ public:
      *  \return The stored code field value.
      */
     uint8_t code() const {
-        return _header.code;
+        return header_.code;
     }
 
     /**
@@ -591,7 +590,7 @@ public:
      *  \return The stored cksum field value.
      */
     uint16_t checksum() const {
-        return Endian::be_to_host(_header.cksum);
+        return Endian::be_to_host(header_.cksum);
     }
 
     /**
@@ -599,7 +598,7 @@ public:
      *  \return The stored identifier field value.
      */
     uint16_t identifier() const {
-        return Endian::be_to_host(_header.u_echo.identifier);
+        return Endian::be_to_host(header_.u_echo.identifier);
     }
 
     /**
@@ -607,7 +606,7 @@ public:
      *  \return The stored sequence field value.
      */
     uint16_t sequence() const {
-        return Endian::be_to_host(_header.u_echo.sequence);
+        return Endian::be_to_host(header_.u_echo.sequence);
     }
 
     /**
@@ -615,7 +614,7 @@ public:
      *  \return The stored override field value.
      */
     small_uint<1> override() const {
-        return _header.u_nd_advt.override;
+        return header_.u_nd_advt.override;
     }
 
     /**
@@ -623,7 +622,7 @@ public:
      *  \return The stored solicited field value.
      */
     small_uint<1> solicited() const {
-        return _header.u_nd_advt.solicited;
+        return header_.u_nd_advt.solicited;
     }
 
     /**
@@ -631,7 +630,7 @@ public:
      *  \return The stored router field value.
      */
     small_uint<1> router() const {
-        return _header.u_nd_advt.router;
+        return header_.u_nd_advt.router;
     }
 
     /**
@@ -639,7 +638,7 @@ public:
      *  \return The stored hop_limit field value.
      */
     uint8_t hop_limit() const {
-        return _header.u_nd_ra.hop_limit;
+        return header_.u_nd_ra.hop_limit;
     }
 
     /**
@@ -647,7 +646,7 @@ public:
      *  \return The stored router_pref field value.
      */
     small_uint<2> router_pref() const {
-        return _header.u_nd_ra.router_pref;
+        return header_.u_nd_ra.router_pref;
     }
 
     /**
@@ -655,7 +654,7 @@ public:
      *  \return The stored home_agent field value.
      */
     small_uint<1> home_agent() const {
-        return _header.u_nd_ra.home_agent;
+        return header_.u_nd_ra.home_agent;
     }
 
     /**
@@ -663,7 +662,7 @@ public:
      *  \return The stored other field value.
      */
     small_uint<1> other() const {
-        return _header.u_nd_ra.other;
+        return header_.u_nd_ra.other;
     }
 
     /**
@@ -671,7 +670,7 @@ public:
      *  \return The stored managed field value.
      */
     small_uint<1> managed() const {
-        return _header.u_nd_ra.managed;
+        return header_.u_nd_ra.managed;
     }
 
     /**
@@ -679,7 +678,7 @@ public:
      *  \return The stored router_lifetime field value.
      */
     uint16_t router_lifetime() const {
-        return Endian::be_to_host(_header.u_nd_ra.router_lifetime);
+        return Endian::be_to_host(header_.u_nd_ra.router_lifetime);
     }
     
     /**
@@ -687,7 +686,7 @@ public:
      *  \return The stored reachable_time field value.
      */
     uint32_t reachable_time() const {
-        return Endian::be_to_host(reach_time);
+        return Endian::be_to_host(reach_time_);
     }
     
     /**
@@ -695,31 +694,31 @@ public:
      *  \return The stored retransmit_timer field value.
      */
     uint32_t retransmit_timer() const {
-        return Endian::be_to_host(retrans_timer);
+        return Endian::be_to_host(retrans_timer_);
     }
     
     /**
      *  \brief Getter for the target address field.
      *  \return The stored target address field value.
      */
-    const ipaddress_type &target_addr() const {
-        return _target_address;
+    const ipaddress_type& target_addr() const {
+        return target_address_;
     }
     
     /**
      *  \brief Getter for the destination address field.
      *  \return The stored destination address field value.
      */
-    const ipaddress_type &dest_addr() const {
-        return _dest_address;
+    const ipaddress_type& dest_addr() const {
+        return dest_address_;
     }
 
     /**
      *  \brief Getter for the ICMPv6 options.
      *  \return The stored options.
      */
-    const options_type &options() const {
-        return _options;
+    const options_type& options() const {
+        return options_;
     }
 
     /**
@@ -728,7 +727,7 @@ public:
      * \return Returns the length field value.
      */
     uint8_t length() const { 
-        return _header.rfc4884.length;
+        return header_.rfc4884.length;
     }
 
     /**
@@ -828,13 +827,13 @@ public:
      *  \brief Setter for the target address field.
      *  \param new_target_addr The new target address field value.
      */
-    void target_addr(const ipaddress_type &new_target_addr);
+    void target_addr(const ipaddress_type& new_target_addr);
     
     /**
      *  \brief Setter for the destination address field.
      *  \param new_dest_addr The new destination address field value.
      */
-    void dest_addr(const ipaddress_type &new_dest_addr);
+    void dest_addr(const ipaddress_type& new_dest_addr);
 
     /**
      *  \brief Setter for the reachable_time field.
@@ -869,8 +868,8 @@ public:
      */
     bool has_target_addr() const {
         return type() == NEIGHBOUR_SOLICIT || 
-                type() == NEIGHBOUR_ADVERT || 
-                type() == REDIRECT;
+               type() == NEIGHBOUR_ADVERT || 
+               type() == REDIRECT;
     }
     
     /**
@@ -890,7 +889,7 @@ public:
      * 
      * \param option The option to be added
      */
-    void add_option(const option &option);
+    void add_option(const option& option);
     
     #if TINS_IS_CXX11
         /**
@@ -902,7 +901,7 @@ public:
          */
         void add_option(option &&option) {
             internal_add_option(option);
-            _options.push_back(std::move(option));
+            options_.push_back(std::move(option));
         }
     #endif
 
@@ -939,19 +938,25 @@ public:
      *
      * \return The extensions field
      */
-    const ICMPExtensionsStructure& extensions() const { return extensions_; }
+    const ICMPExtensionsStructure& extensions() const {
+        return extensions_;
+    }
 
     /** 
      * \brief Getter for the extensions field.
      *
      * \return The extensions field
      */
-    ICMPExtensionsStructure& extensions() { return extensions_; }
+    ICMPExtensionsStructure& extensions() {
+        return extensions_;
+    }
 
     /**
      * \brief Indicates whether this object contains ICMP extensions
      */
-    bool has_extensions() const { return !extensions_.extensions().empty(); }
+    bool has_extensions() const {
+        return !extensions_.extensions().empty();
+    }
 
     /**
      * \brief Sets whether the length field will be set for packets that use it
@@ -977,7 +982,7 @@ public:
      * \param ptr The pointer to the buffer.
      * \param total_sz The size of the buffer.
      */
-    bool matches_response(const uint8_t *ptr, uint32_t total_sz) const;
+    bool matches_response(const uint8_t* ptr, uint32_t total_sz) const;
 
     /**
      * \brief Searchs for an option that matchs the given flag.
@@ -988,12 +993,12 @@ public:
      * 
      * \param type The option identifier to be searched.
      */
-    const option *search_option(OptionTypes type) const;
+    const option* search_option(OptionTypes type) const;
 
     /**
      * \sa PDU::clone
      */
-    ICMPv6 *clone() const {
+    ICMPv6* clone() const {
         return new ICMPv6(*this);
     }
     
@@ -1006,14 +1011,14 @@ public:
      * 
      * \param addr The source link layer address.
      */
-    void source_link_layer_addr(const hwaddress_type &addr);
+    void source_link_layer_addr(const hwaddress_type& addr);
     
     /**
      * \brief Setter for the target link layer address option.
      * 
      * \param addr The target link layer address.
      */
-    void target_link_layer_addr(const hwaddress_type &addr);
+    void target_link_layer_addr(const hwaddress_type& addr);
     
     /**
      * \brief Setter for the prefix information option.
@@ -1027,7 +1032,7 @@ public:
      * 
      * \param data The redirect header option data.
      */
-    void redirect_header(const byte_array &data);
+    void redirect_header(const byte_array& data);
     
     /**
      * \brief Setter for the MTU option.
@@ -1048,56 +1053,56 @@ public:
      * 
      * \param value The new advertisement interval option data.
      */
-    void new_advert_interval(const new_advert_interval_type &value);
+    void new_advert_interval(const new_advert_interval_type& value);
     
     /**
      * \brief Setter for the new home agent information option.
      * 
      * \param value The new home agent information option data.
      */
-    void new_home_agent_info(const new_ha_info_type &value);
+    void new_home_agent_info(const new_ha_info_type& value);
     
     /**
      * \brief Setter for the new source address list option.
      * 
      * \param value The new source address list option data.
      */
-    void source_addr_list(const addr_list_type &value);
+    void source_addr_list(const addr_list_type& value);
     
     /**
      * \brief Setter for the new target address list option.
      * 
      * \param value The new target address list option data.
      */
-    void target_addr_list(const addr_list_type &value);
+    void target_addr_list(const addr_list_type& value);
     
     /**
      * \brief Setter for the new RSA signature option.
      * 
      * \param value The new RSA signature option data.
      */
-    void rsa_signature(const rsa_sign_type &value);
+    void rsa_signature(const rsa_sign_type& value);
     
     /**
      * \brief Setter for the new timestamp option.
      * 
      * \param value The new timestamp option data.
      */
-    void timestamp(const timestamp_type &value);
+    void timestamp(const timestamp_type& value);
     
     /**
      * \brief Setter for the new nonce option.
      * 
      * \param value The new nonce option data.
      */
-    void nonce(const nonce_type &value);
+    void nonce(const nonce_type& value);
     
     /**
      * \brief Setter for the new IP address/prefix option.
      * 
      * \param value The new IP address/prefix option data.
      */
-    void ip_prefix(const ip_prefix_type &value);
+    void ip_prefix(const ip_prefix_type& value);
 
     /**
      * \brief Setter for the new link layer address option.
@@ -1111,63 +1116,63 @@ public:
      * 
      * \param value The new naack option data.
      */
-    void naack(const naack_type &value);
+    void naack(const naack_type& value);
     
     /**
      * \brief Setter for the map option.
      * 
      * \param value The new map option data.
      */
-    void map(const map_type &value);
+    void map(const map_type& value);
     
     /**
      * \brief Setter for the route information option.
      * 
      * \param value The new route information option data.
      */
-    void route_info(const route_info_type &value);
+    void route_info(const route_info_type& value);
     
     /**
      * \brief Setter for the recursive DNS servers option.
      * 
      * \param value The new recursive DNS servers option data.
      */
-    void recursive_dns_servers(const recursive_dns_type &value);
+    void recursive_dns_servers(const recursive_dns_type& value);
     
     /**
      * \brief Setter for the handover key request option.
      * 
      * \param value The new handover key request option data.
      */
-    void handover_key_request(const handover_key_req_type &value);
+    void handover_key_request(const handover_key_req_type& value);
     
     /**
      * \brief Setter for the handover key reply option.
      * 
      * \param value The new handover key reply option data.
      */
-    void handover_key_reply(const handover_key_reply_type &value);
+    void handover_key_reply(const handover_key_reply_type& value);
     
     /**
      * \brief Setter for the handover assist info option.
      * 
      * \param value The new handover assist info option data.
      */
-    void handover_assist_info(const handover_assist_info_type &value);
+    void handover_assist_info(const handover_assist_info_type& value);
     
     /**
      * \brief Setter for the mobile node identifier option.
      * 
      * \param value The new mobile node identifier option data.
      */
-    void mobile_node_identifier(const mobile_node_id_type &value);
+    void mobile_node_identifier(const mobile_node_id_type& value);
     
     /**
      * \brief Setter for the DNS search list option.
      * 
      * \param value The new DNS search list option data.
      */
-    void dns_search_list(const dns_search_list_type &value);
+    void dns_search_list(const dns_search_list_type& value);
     
     // ****************************************************************
     //                          Option getters
@@ -1367,7 +1372,7 @@ public:
     dns_search_list_type dns_search_list() const;
 private:
     TINS_BEGIN_PACK
-    struct icmp6hdr {
+    struct icmp6_header {
         uint8_t	type;
         uint8_t code;
         uint16_t cksum;
@@ -1420,40 +1425,43 @@ private:
         };
     } TINS_END_PACK;
     
-    void internal_add_option(const option &option);
-    void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
+    void internal_add_option(const option& option);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
     bool has_options() const;
-    void write_option(const option &opt, Memory::OutputMemoryStream& stream);
+    void write_option(const option& opt, Memory::OutputMemoryStream& stream);
     void parse_options(Memory::InputMemoryStream& stream);
-    void add_addr_list(uint8_t type, const addr_list_type &value);
+    void add_addr_list(uint8_t type, const addr_list_type& value);
     addr_list_type search_addr_list(OptionTypes type) const;
     options_type::const_iterator search_option_iterator(OptionTypes type) const;
     options_type::iterator search_option_iterator(OptionTypes type);
     void try_parse_extensions(Memory::InputMemoryStream& stream);
     bool are_extensions_allowed() const;
     uint32_t get_adjusted_inner_pdu_size() const;
+    uint8_t get_option_padding(uint32_t data_size);
 
     template<template <typename> class Functor>
-    const option *safe_search_option(OptionTypes opt, uint32_t size) const {
-        const option *option = search_option(opt);
-        if(!option || Functor<uint32_t>()(option->data_size(), size))
+    const option* safe_search_option(OptionTypes opt, uint32_t size) const {
+        const option* option = search_option(opt);
+        if (!option || Functor<uint32_t>()(option->data_size(), size)) {
             throw option_not_found();
+        }
         return option;
     }
 
     template<typename T>
     T search_and_convert(OptionTypes type) const {
-        const option *opt = search_option(type);
-        if(!opt)
+        const option* opt = search_option(type);
+        if (!opt) {
             throw option_not_found();
+        }
         return opt->to<T>();
     }
 
-    icmp6hdr _header;
-    ipaddress_type _target_address, _dest_address;
-    options_type _options;
-    uint32_t _options_size;
-    uint32_t reach_time, retrans_timer;
+    icmp6_header header_;
+    ipaddress_type target_address_, dest_address_;
+    options_type options_;
+    uint32_t options_size_;
+    uint32_t reach_time_, retrans_timer_;
     multicast_address_records_list multicast_records_;
     ICMPExtensionsStructure extensions_;
 };
diff --git a/include/tins/internals.h b/include/tins/internals.h
index 9b71c8b..14b9376 100644
--- a/include/tins/internals.h
+++ b/include/tins/internals.h
@@ -46,6 +46,7 @@
  */
 namespace Tins {
 namespace Memory {
+
 class InputMemoryStream;
 } // Memory
 class IPv4Address;
@@ -53,6 +54,7 @@ class IPv6Address;
 class ICMPExtensionsStructure;
 
 namespace Internals {
+
 template<size_t n>
 class byte_array {
 public:
@@ -73,7 +75,7 @@ public:
         std::copy(start, n, data);
     }
 
-    uint8_t &operator[](size_t i) {
+    uint8_t& operator[](size_t i) {
         return data[i];
     }
 
@@ -104,8 +106,8 @@ private:
     uint8_t data[n];
 };
 
-void skip_line(std::istream &input);
-bool from_hex(const std::string &str, uint32_t &result);
+void skip_line(std::istream& input);
+bool from_hex(const std::string& str, uint32_t& result);
 
 template<bool, typename T = void>
 struct enable_if {
@@ -117,13 +119,13 @@ struct enable_if<false, T> {
 
 };
 
-PDU *pdu_from_flag(Constants::Ethernet::e flag, const uint8_t *buffer,
+PDU* pdu_from_flag(Constants::Ethernet::e flag, const uint8_t* buffer,
   uint32_t size, bool rawpdu_on_no_match = true);
-PDU *pdu_from_flag(Constants::IP::e flag, const uint8_t *buffer,
+PDU* pdu_from_flag(Constants::IP::e flag, const uint8_t* buffer,
   uint32_t size, bool rawpdu_on_no_match = true);
-PDU *pdu_from_dlt_flag(int flag, const uint8_t *buffer,
+PDU* pdu_from_dlt_flag(int flag, const uint8_t* buffer,
   uint32_t size, bool rawpdu_on_no_match = true);
-PDU *pdu_from_flag(PDU::PDUType type, const uint8_t *buffer, uint32_t size);
+PDU* pdu_from_flag(PDU::PDUType type, const uint8_t* buffer, uint32_t size);
 
 Constants::Ethernet::e pdu_flag_to_ether_type(PDU::PDUType flag);
 Constants::IP::e pdu_flag_to_ip_type(PDU::PDUType flag);
@@ -133,58 +135,60 @@ void try_parse_icmp_extensions(Memory::InputMemoryStream& stream,
     uint32_t payload_length, ICMPExtensionsStructure& extensions);
 
 template<typename T>
-bool increment_buffer(T &addr) {
+bool increment_buffer(T& addr) {
     typename T::iterator it = addr.end() - 1;
-    while(it >= addr.begin() && *it == 0xff) {
+    while (it >= addr.begin() && *it == 0xff) {
         *it = 0;
         --it;
     }
     // reached end
-    if(it < addr.begin())
+    if (it < addr.begin()) {
         return true;
+    }
     (*it)++;
     return false;
 }
 
 template<typename T>
-bool decrement_buffer(T &addr) {
+bool decrement_buffer(T& addr) {
     typename T::iterator it = addr.end() - 1;
-    while(it >= addr.begin() && *it == 0) {
+    while (it >= addr.begin() && *it == 0) {
         *it = 0xff;
         --it;
     }
     // reached end
-    if(it < addr.begin())
+    if (it < addr.begin()) {
         return true;
+    }
     (*it)--;
     return false;
 }
 
-bool increment(IPv4Address &addr);
-bool increment(IPv6Address &addr);
-bool decrement(IPv4Address &addr);
-bool decrement(IPv6Address &addr);
+bool increment(IPv4Address& addr);
+bool increment(IPv6Address& addr);
+bool decrement(IPv4Address& addr);
+bool decrement(IPv6Address& addr);
 template<size_t n>
-bool increment(HWAddress<n> &addr) {
+bool increment(HWAddress<n>& addr) {
     return increment_buffer(addr);
 }
 template<size_t n>
-bool decrement(HWAddress<n> &addr) {
+bool decrement(HWAddress<n>& addr) {
     return decrement_buffer(addr);
 }
 
 IPv4Address last_address_from_mask(IPv4Address addr, IPv4Address mask);
-IPv6Address last_address_from_mask(IPv6Address addr, const IPv6Address &mask);
+IPv6Address last_address_from_mask(IPv6Address addr, const IPv6Address& mask);
 template<size_t n>
-HWAddress<n> last_address_from_mask(HWAddress<n> addr, const HWAddress<n> &mask) {
+HWAddress<n> last_address_from_mask(HWAddress<n> addr, const HWAddress<n>& mask) {
     typename HWAddress<n>::iterator addr_iter = addr.begin();
-    for(typename HWAddress<n>::const_iterator it = mask.begin(); it != mask.end(); ++it, ++addr_iter) {
+    for (typename HWAddress<n>::const_iterator it = mask.begin(); it != mask.end(); ++it, ++addr_iter) {
         *addr_iter = *addr_iter | ~*it;
     }
     return addr;
 }
 
-inline bool is_dot3(const uint8_t *ptr, size_t sz) {
+inline bool is_dot3(const uint8_t* ptr, size_t sz) {
     return (sz >= 13 && ptr[12] < 8);
 }
 
diff --git a/include/tins/ip.h b/include/tins/ip.h
index 8a389e9..18e47e1 100644
--- a/include/tins/ip.h
+++ b/include/tins/ip.h
@@ -41,705 +41,729 @@
 
 namespace Tins {
 namespace Memory {
+
 class OutputMemoryStream;
+
 } // Memory
 
+/**
+ * \class IP
+ * \brief Class that represents an IP PDU.
+ * 
+ * By default, IP PDUs are initialized, setting TTL to IP::DEFAULT_TTL,
+ * id field to 1 and version to 4. Taking this into account, users
+ * should set destination and source port and would be enough to send one.
+ *
+ * When IP is the lowest layer on a packet, and the packet is serialized
+ * this willc heck if the source address is different than 0.0.0.0. If it is,
+ * the address of the interface in which the packet is going to be sent
+ * is retrieved (by using the routing table and the destination address)
+ * and set as the source address. If you don't want this behaviour, simply
+ * set the source address to 0.0.0.0.
+ */
+class TINS_API IP : public PDU {
+public:
     /**
-     * \class IP
-     * \brief Class that represents an IP PDU.
-     * 
-     * By default, IP PDUs are initialized, setting TTL to IP::DEFAULT_TTL,
-     * id field to 1 and version to 4. Taking this into account, users
-     * should set destination and source port and would be enough to send one.
-     *
-     * When IP is the lowest layer on a packet, and the packet is serialized
-     * this willc heck if the source address is different than 0.0.0.0. If it is,
-     * the address of the interface in which the packet is going to be sent
-     * is retrieved (by using the routing table and the destination address)
-     * and set as the source address. If you don't want this behaviour, simply
-     * set the source address to 0.0.0.0.
+     * This PDU's flag.
      */
-    class TINS_API IP : public PDU {
-    public:
-        /**
-         * This PDU's flag.
-         */
-        static const PDU::PDUType pdu_flag = PDU::IP;
+    static const PDU::PDUType pdu_flag = PDU::IP;
+
+    /**
+     * The type used to store addresses.
+     */
+    typedef IPv4Address address_type;
+
+    /**
+     * Type used to represent the different IP flags.
+     */
+    enum Flags {
+        FLAG_RESERVED = 4,
+        DONT_FRAGMENT = 2,
+        MORE_FRAGMENTS = 1
+    };
+
+    /**
+     * \brief Enum indicating the option's class.
+     *
+     * Enum OptionClass represents the different classes of
+     * IP Options.
+     */
+    enum OptionClass {
+        CONTROL = 0,
+        MEASUREMENT = 2
+    };
+
+    /**
+     * \brief Enum indicating the option's id number.
+     *
+     * Enum Option indicates the possible IP Options.
+     */
+    enum OptionNumber {
+        END = 0,
+        NOOP = 1,
+        SEC = 2,
+        LSRR = 3,
+        TIMESTAMP = 4,
+        EXTSEC = 5,
+        RR = 7,
+        SID = 8,
+        SSRR = 9,
+        MTUPROBE = 11,
+        MTUREPLY = 12,
+        EIP = 17,
+        TR = 18,
+        ADDEXT = 19,
+        RTRALT = 20,
+        SDB = 21,
+        DPS = 23,
+        UMP = 24,
+        QS = 25
+    };
     
+    /**
+     * \brief The type used to represent an option's type.
+     */
+    TINS_BEGIN_PACK
+    struct option_identifier {
+    #if TINS_IS_LITTLE_ENDIAN
+        uint8_t number:5,
+                op_class:2,
+                copied:1;
+    #elif TINS_IS_BIG_ENDIAN
+        uint8_t copied:1,
+                op_class:2,
+                number:5;
+    #endif
         /**
-         * The type used to store addresses.
+         * \brief Default constructor.
+         * 
+         * Initializes every field to 0.
          */
-        typedef IPv4Address address_type;
-
-        /**
-         * Type used to represent the different IP flags.
-         */
-        enum Flags {
-            FLAG_RESERVED = 4,
-            DONT_FRAGMENT = 2,
-            MORE_FRAGMENTS = 1
-        };
-
-        /**
-         * \brief Enum indicating the option's class.
-         *
-         * Enum OptionClass represents the different classes of
-         * IP Options.
-         */
-        enum OptionClass {
-            CONTROL = 0,
-            MEASUREMENT = 2
-        };
-
-        /**
-         * \brief Enum indicating the option's id number.
-         *
-         * Enum Option indicates the possible IP Options.
-         */
-        enum OptionNumber {
-            END = 0,
-            NOOP = 1,
-            SEC = 2,
-            LSRR = 3,
-            TIMESTAMP = 4,
-            EXTSEC = 5,
-            RR = 7,
-            SID = 8,
-            SSRR = 9,
-            MTUPROBE = 11,
-            MTUREPLY = 12,
-            EIP = 17,
-            TR = 18,
-            ADDEXT = 19,
-            RTRALT = 20,
-            SDB = 21,
-            DPS = 23,
-            UMP = 24,
-            QS = 25
-        };
-        
-        /**
-         * \brief The type used to represent an option's type.
-         */
-        TINS_BEGIN_PACK
-        struct option_identifier {
+        option_identifier() 
         #if TINS_IS_LITTLE_ENDIAN
-            uint8_t number:5,
-                    op_class:2,
-                    copied:1;
-        #elif TINS_IS_BIG_ENDIAN
-            uint8_t copied:1,
-                    op_class:2,
-                    number:5;
+        : number(0), op_class(0), copied(0) {}
+        #else
+        : copied(0), op_class(0), number(0) {}
         #endif
-            /**
-             * \brief Default constructor.
-             * 
-             * Initializes every field to 0.
-             */
-            option_identifier() 
-            #if TINS_IS_LITTLE_ENDIAN
-            : number(0), op_class(0), copied(0) {}
-            #else
-            : copied(0), op_class(0), number(0) {}
-            #endif
-            
-            /**
-             * \brief Constructs this option from a single uint8_t value.
-             * 
-             * This parses the value and initializes each field with the
-             * appropriate value.
-             * 
-             * \param value The value to be parsed and used for 
-             * initialization
-             */
-            option_identifier(uint8_t value) 
-            #if TINS_IS_LITTLE_ENDIAN
-            : number(value & 0x1f), 
-              op_class((value >> 5) & 0x03), 
-              copied((value >> 7) & 0x01) {}
-            #elif TINS_IS_BIG_ENDIAN
-            : copied((value >> 7) & 0x01),
-              op_class((value >> 5) & 0x03), 
-              number(value & 0x1f) {}
-            #endif
-            
-            /**
-             * Constructor using user provided values for each field.
-             * \param number The number field value.
-             * \param op_class The option class field value.
-             * \param copied The copied field value.
-             */
-            option_identifier(OptionNumber number, OptionClass op_class,
-              small_uint<1> copied) 
-            #if TINS_IS_LITTLE_ENDIAN
-            : number(number), op_class(op_class), copied(copied) {}
-            #else
-            : copied(copied), op_class(op_class), number(number) {}
-            #endif
-            
-            /**
-             * \brief Equality operator.
-             */
-            bool operator==(const option_identifier &rhs) const {
-                return number == rhs.number && op_class == rhs.op_class && copied == rhs.copied;
-            }
-        } TINS_END_PACK;
         
         /**
-         * The IP options type.
-         */
-        typedef PDUOption<option_identifier, IP> option;
-
-        /**
-         * The type of the security option.
-         */
-        struct security_type {
-            uint16_t security, compartments;
-            uint16_t handling_restrictions;
-            small_uint<24> transmission_control;
-            
-            security_type(uint16_t sec = 0, uint16_t comp = 0,
-              uint16_t hand_res = 0, small_uint<24> tcc = 0)
-            : security(sec), compartments(comp), 
-              handling_restrictions(hand_res), transmission_control(tcc) 
-              {}
-            
-            static security_type from_option(const option &opt);
-        };
-        
-        /**
-         * The type of the Loose Source and Record Route
-         */
-        struct generic_route_option_type {
-            typedef std::vector<address_type> routes_type;
-            
-            uint8_t pointer;
-            routes_type routes;
-            
-            generic_route_option_type(uint8_t ptr = 0, 
-              routes_type rts = routes_type())
-            : pointer(ptr), routes(rts) {}
-            
-            static generic_route_option_type from_option(const option &opt);
-        };
-        
-        /**
-         * The type of the Loose Source and Record Route
-         */
-        typedef generic_route_option_type lsrr_type;
-        
-        /**
-         * The type of the Strict Source and Record Route
-         */
-        typedef generic_route_option_type ssrr_type;
-        
-        /**
-         * The type of the Record Route
-         */
-        typedef generic_route_option_type record_route_type;
-
-        /**
-         * The type used to store IP options.
-         */
-        typedef std::list<option> options_type;
-
-        /**
-         * \brief Constructor for building the IP PDU.
-         *
-         * Both the destination and source IP address can be supplied.
-         * By default, those fields are initialized using the IP 
-         * address 0.0.0.0.
-         *
-         * \param ip_dst The destination ip address(optional).
-         * \param ip_src The source ip address(optional).
-         */
-        IP(address_type ip_dst = address_type(), 
-            address_type ip_src = address_type());
-
-        /**
-         * \brief Constructs an IP object from a buffer and adds all 
-         * identifiable PDUs found in the buffer as children of this 
-         * one.
+         * \brief Constructs this option from a single uint8_t value.
          * 
-         * If there is not enough size for an IP header, a 
-         * malformed_packet exception is thrown.
+         * This parses the value and initializes each field with the
+         * appropriate value.
          * 
-         * \param buffer The buffer from which this PDU will be constructed.
-         * \param total_sz The total size of the buffer.
+         * \param value The value to be parsed and used for 
+         * initialization
          */
-        IP(const uint8_t *buffer, uint32_t total_sz);
-
-        /* Getters */
-
+        option_identifier(uint8_t value) 
+        #if TINS_IS_LITTLE_ENDIAN
+        : number(value & 0x1f), 
+          op_class((value >> 5) & 0x03), 
+          copied((value >> 7) & 0x01) {}
+        #elif TINS_IS_BIG_ENDIAN
+        : copied((value >> 7) & 0x01),
+          op_class((value >> 5) & 0x03), 
+          number(value & 0x1f) {}
+        #endif
+        
         /**
-         * \brief Getter for the header length field.
-         *
-         * \return The number of dwords the header occupies in an uin8_t.
+         * Constructor using user provided values for each field.
+         * \param number The number field value.
+         * \param op_class The option class field value.
+         * \param copied The copied field value.
          */
-        small_uint<4> head_len() const { return this->_ip.ihl; }
-
+        option_identifier(OptionNumber number, OptionClass op_class,
+          small_uint<1> copied) 
+        #if TINS_IS_LITTLE_ENDIAN
+        : number(number), op_class(op_class), copied(copied) {}
+        #else
+        : copied(copied), op_class(op_class), number(number) {}
+        #endif
+        
         /**
-         * \brief Getter for the type of service field.
-         *
-         * \return The this IP PDU's type of service.
+         * \brief Equality operator.
          */
-        uint8_t tos() const { return _ip.tos; }
-
-        /**
-         * \brief Getter for the total length field.
-         *
-         * \return The total length of this IP PDU.
-         */
-        uint16_t tot_len() const { 
-            return Endian::be_to_host(_ip.tot_len); 
+        bool operator==(const option_identifier& rhs) const {
+            return number == rhs.number && op_class == rhs.op_class && copied == rhs.copied;
         }
+    } TINS_END_PACK;
+    
+    /**
+     * The IP options type.
+     */
+    typedef PDUOption<option_identifier, IP> option;
 
-        /**
-         * \brief Getter for the id field.
-         *
-         * \return The id for this IP PDU.
-         */
-        uint16_t id() const { return Endian::be_to_host(_ip.id); }
+    /**
+     * The type of the security option.
+     */
+    struct security_type {
+        uint16_t security, compartments;
+        uint16_t handling_restrictions;
+        small_uint<24> transmission_control;
+        
+        security_type(uint16_t sec = 0, 
+                      uint16_t comp = 0,
+                      uint16_t hand_res = 0,
+                      small_uint<24> tcc = 0)
+        : security(sec), compartments(comp), 
+          handling_restrictions(hand_res), transmission_control(tcc) { }
+        
+        static security_type from_option(const option& opt);
+    };
+    
+    /**
+     * The type of the Loose Source and Record Route
+     */
+    struct generic_route_option_type {
+        typedef std::vector<address_type> routes_type;
+        
+        uint8_t pointer;
+        routes_type routes;
+        
+        generic_route_option_type(uint8_t ptr = 0, routes_type rts = routes_type())
+        : pointer(ptr), routes(rts) {}
+        
+        static generic_route_option_type from_option(const option& opt);
+    };
+    
+    /**
+     * The type of the Loose Source and Record Route
+     */
+    typedef generic_route_option_type lsrr_type;
+    
+    /**
+     * The type of the Strict Source and Record Route
+     */
+    typedef generic_route_option_type ssrr_type;
+    
+    /**
+     * The type of the Record Route
+     */
+    typedef generic_route_option_type record_route_type;
 
-        /**
-         * \brief Getter for the fragment offset field.
-         * 
-         * This method is deprecated. Use IP::fragment_offset and IP::flags.
-         *
-         * \deprecated
-         * \return The fragment offset for this IP PDU.
-         * \sa IP::fragment_offset
-         * \sa IP::flags
-         */
-        TINS_DEPRECATED(uint16_t frag_off() const) { return Endian::be_to_host(_ip.frag_off); }
+    /**
+     * The type used to store IP options.
+     */
+    typedef std::list<option> options_type;
 
+    /**
+     * \brief Constructor for building the IP PDU.
+     *
+     * Both the destination and source IP address can be supplied.
+     * By default, those fields are initialized using the IP 
+     * address 0.0.0.0.
+     *
+     * \param ip_dst The destination ip address(optional).
+     * \param ip_src The source ip address(optional).
+     */
+    IP(address_type ip_dst = address_type(), 
+       address_type ip_src = address_type());
+
+    /**
+     * \brief Constructs an IP object from a buffer and adds all 
+     * identifiable PDUs found in the buffer as children of this 
+     * one.
+     * 
+     * If there is not enough size for an IP header, a 
+     * malformed_packet exception is thrown.
+     * 
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    IP(const uint8_t* buffer, uint32_t total_sz);
+
+    /* Getters */
+
+    /**
+     * \brief Getter for the header length field.
+     *
+     * \return The number of dwords the header occupies in an uin8_t.
+     */
+    small_uint<4> head_len() const {
+        return this->ip_.ihl;
+    }
+
+    /**
+     * \brief Getter for the type of service field.
+     *
+     * \return The this IP PDU's type of service.
+     */
+    uint8_t tos() const {
+        return ip_.tos;
+    }
+
+    /**
+     * \brief Getter for the total length field.
+     *
+     * \return The total length of this IP PDU.
+     */
+    uint16_t tot_len() const {
+        return Endian::be_to_host(ip_.tot_len);
+    }
+
+    /**
+     * \brief Getter for the id field.
+     *
+     * \return The id for this IP PDU.
+     */
+    uint16_t id() const {
+        return Endian::be_to_host(ip_.id);
+    }
+
+    /**
+     * \brief Getter for the fragment offset field.
+     * 
+     * This method is deprecated. Use IP::fragment_offset and IP::flags.
+     *
+     * \deprecated
+     * \return The fragment offset for this IP PDU.
+     * \sa IP::fragment_offset
+     * \sa IP::flags
+     */
+    TINS_DEPRECATED(uint16_t frag_off() const) {
+        return Endian::be_to_host(ip_.frag_off);
+    }
+
+    /**
+     * \brief Getter for the fragment offset field.
+     * 
+     * This will return the fragment offset field, as present in the packet, 
+     * which indicates the offset of this fragment in blocks of 8 bytes. 
+     * 
+     * \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;
+    }
+
+    /**
+     * \brief Getter for the flags field.
+     *
+     * \return The IP flags field
+     */
+    Flags flags() const {
+        return static_cast<Flags>(Endian::be_to_host(ip_.frag_off) >> 13);
+    }
+
+    /**
+     * \brief Getter for the time to live field.
+     *
+     * \return The time to live for this IP PDU.
+     */
+    uint8_t ttl() const {
+        return ip_.ttl;
+    }
+
+    /**
+     * \brief Getter for the protocol field.
+     *
+     * \return The protocol for this IP PDU.
+     */
+    uint8_t protocol() const {
+        return ip_.protocol;
+    }
+
+    /**
+     * \brief Getter for the checksum field.
+     *
+     * \return The checksum for this IP PDU.
+     */
+    uint16_t checksum() const {
+        return Endian::be_to_host(ip_.check);
+    }
+
+    /**
+     * \brief Getter for the source address field.
+     *
+     * \return The source address for this IP PDU.
+     */
+    address_type src_addr() const {
+        return address_type(ip_.saddr);
+    }
+
+    /** 
+     * \brief Getter for the destination address field.
+     * \return The destination address for this IP PDU.
+     */
+    address_type dst_addr() const  {
+        return address_type(ip_.daddr);
+    }
+    
+    /** 
+     * \brief Getter for the version field.
+     * \return The version for this IP PDU.
+     */
+    small_uint<4> version() const {
+        return ip_.version;
+    }
+
+    /** 
+     * \brief Getter for the IP options.
+     * \return The stored options.
+     */
+    const options_type& options() const {
+        return ip_options_;
+    }
+
+    /* Setters */
+
+    /**
+     * \brief Setter for the type of service field.
+     *
+     * \param new_tos The new type of service.
+     */
+    void tos(uint8_t new_tos);
+
+    /**
+     * \brief Setter for the id field.
+     *
+     * \param new_id The new id.
+     */
+    void id(uint16_t new_id);
+
+    /**
+     * \brief Setter for the fragment offset field.
+     *
+     * This method is deprecated. Use IP::fragment_offset and IP::flags.
+     *
+     * \deprecated
+     * \param new_frag_off The new fragment offset.
+     * \sa IP::fragment_offset
+     * \sa IP::flags
+     */
+    TINS_DEPRECATED(void frag_off(uint16_t new_frag_off));
+    
+    /**
+     * \brief Setter for the fragment offset field.
+     *
+     * The value provided is measured in units of 8 byte blocks. This means that
+     * if you want this packet to have a fragment offset of <i>X</i>, 
+     * you need to provide <i>X / 8</i> as the argument to this method.
+     *  
+     * \param new_frag_off The new fragment offset, measured in units of 8 byte blocks.
+     */
+    void fragment_offset(small_uint<13> new_frag_off);
+
+    /**
+     * \brief Setter for the flags field.
+     * 
+     * \param new_flags The new IP flags field value.
+     */
+    void flags(Flags new_flags);
+
+    /**
+     * \brief Setter for the time to live field.
+     *
+     * \param new_ttl The new time to live.
+     */
+    void ttl(uint8_t new_ttl);
+
+    /**
+     * \brief Setter for the protocol field.
+     *
+     * Note that this protocol will be overwritten using the 
+     * inner_pdu's protocol type during serialization unless the IP 
+     * datagram is fragmented. 
+     * 
+     * If the packet is fragmented and was originally sniffed, the
+     * original protocol type will be kept when serialized.
+     * 
+     * If this packet has been crafted manually and the inner_pdu
+     * is, for example, a RawPDU, then setting the protocol yourself
+     * is necessary.
+     * 
+     * \param new_protocol The new protocol.
+     */
+    void protocol(uint8_t new_protocol);
+
+    /**
+     * \brief Setter for the source address field.
+     *
+     * \param ip The source address to be set.
+     */
+    void src_addr(address_type ip);
+
+    /**
+     * \brief Setter for the destination address field.
+     *
+     * \param ip The destination address to be set.
+     */
+    void dst_addr(address_type ip);
+    
+    /**
+     * \brief Setter for the version field.
+     *
+     * \param ver The version field to be set.
+     */
+    void version(small_uint<4> ver);
+
+    /**
+     * \brief Adds an IP option.
+     * 
+     * The option is added after the last option in the option 
+     * fields.
+     * 
+     * \param opt The option to be added
+     */
+    void add_option(const option& opt);
+    
+    #if TINS_IS_CXX11
         /**
-         * \brief Getter for the fragment offset field.
+         * \brief Adds an IP option.
          * 
-         * This will return the fragment offset field, as present in the packet, 
-         * which indicates the offset of this fragment in blocks of 8 bytes. 
+         * The option is move-constructed.
          * 
-         * \return The fragment offset, measured in units of 8 byte blocks 
+         * \param opt The option to be added.
          */
-        small_uint<13> fragment_offset() const { 
-            return Endian::be_to_host(_ip.frag_off) & 0x1fff;
+        void add_option(option &&opt) {
+            internal_add_option(opt);
+            ip_options_.push_back(std::move(opt));
         }
 
-        /**
-         * \brief Getter for the flags field.
-         *
-         * \return The IP flags field
-         */
-        Flags flags() const {
-            return static_cast<Flags>(Endian::be_to_host(_ip.frag_off) >> 13); 
-        }
-
-        /**
-         * \brief Getter for the time to live field.
-         *
-         * \return The time to live for this IP PDU.
-         */
-        uint8_t ttl() const { return _ip.ttl; }
-
-        /**
-         * \brief Getter for the protocol field.
-         *
-         * \return The protocol for this IP PDU.
-         */
-        uint8_t protocol() const { return _ip.protocol; }
-
-        /**
-         * \brief Getter for the checksum field.
-         *
-         * \return The checksum for this IP PDU.
-         */
-        uint16_t checksum() const { return Endian::be_to_host(_ip.check); }
-
-        /**
-         * \brief Getter for the source address field.
-         *
-         * \return The source address for this IP PDU.
-         */
-        address_type src_addr() const { return address_type(_ip.saddr); }
-
-        /** 
-         * \brief Getter for the destination address field.
-         * \return The destination address for this IP PDU.
-         */
-        address_type dst_addr() const  { return address_type(_ip.daddr); }
-        
-        /** 
-         * \brief Getter for the version field.
-         * \return The version for this IP PDU.
-         */
-        small_uint<4> version() const  { return _ip.version; }
-
-        /** 
-         * \brief Getter for the IP options.
-         * \return The stored options.
-         */
-        const options_type &options() const  { return _ip_options; }
-
-        /* Setters */
-
-        /**
-         * \brief Setter for the type of service field.
-         *
-         * \param new_tos The new type of service.
-         */
-        void tos(uint8_t new_tos);
-
-        /**
-         * \brief Setter for the id field.
-         *
-         * \param new_id The new id.
-         */
-        void id(uint16_t new_id);
-
-        /**
-         * \brief Setter for the fragment offset field.
-         *
-         * This method is deprecated. Use IP::fragment_offset and IP::flags.
-         *
-         * \deprecated
-         * \param new_frag_off The new fragment offset.
-         * \sa IP::fragment_offset
-         * \sa IP::flags
-         */
-        TINS_DEPRECATED(void frag_off(uint16_t new_frag_off));
-        
-        /**
-         * \brief Setter for the fragment offset field.
-         *
-         * The value provided is measured in units of 8 byte blocks. This means that
-         * if you want this packet to have a fragment offset of <i>X</i>, 
-         * you need to provide <i>X / 8</i> as the argument to this method.
-         *  
-         * \param new_frag_off The new fragment offset, measured in units of 8 byte blocks.
-         */
-        void fragment_offset(small_uint<13> new_frag_off);
-
-        /**
-         * \brief Setter for the flags field.
-         * 
-         * \param new_flags The new IP flags field value.
-         */
-        void flags(Flags new_flags);
-
-        /**
-         * \brief Setter for the time to live field.
-         *
-         * \param new_ttl The new time to live.
-         */
-        void ttl(uint8_t new_ttl);
-
-        /**
-         * \brief Setter for the protocol field.
-         *
-         * Note that this protocol will be overwritten using the 
-         * inner_pdu's protocol type during serialization unless the IP 
-         * datagram is fragmented. 
-         * 
-         * If the packet is fragmented and was originally sniffed, the
-         * original protocol type will be kept when serialized.
-         * 
-         * If this packet has been crafted manually and the inner_pdu
-         * is, for example, a RawPDU, then setting the protocol yourself
-         * is necessary.
-         * 
-         * \param new_protocol The new protocol.
-         */
-        void protocol(uint8_t new_protocol);
-
-        /**
-         * \brief Setter for the source address field.
-         *
-         * \param ip The source address to be set.
-         */
-        void src_addr(address_type ip);
-
-        /**
-         * \brief Setter for the destination address field.
-         *
-         * \param ip The destination address to be set.
-         */
-        void dst_addr(address_type ip);
-        
-        /**
-         * \brief Setter for the version field.
-         *
-         * \param ver The version field to be set.
-         */
-        void version(small_uint<4> ver);
-
         /**
          * \brief Adds an IP option.
          * 
-         * The option is added after the last option in the option 
-         * fields.
+         * The option is constructed from the provided parameters.
          * 
-         * \param opt The option to be added
+         * \param args The arguments to be used in the option's 
+         * constructor.
          */
-        void add_option(const option &opt);
-        
-        #if TINS_IS_CXX11
-            /**
-             * \brief Adds an IP option.
-             * 
-             * The option is move-constructed.
-             * 
-             * \param opt The option to be added.
-             */
-            void add_option(option &&opt) {
-                internal_add_option(opt);
-                _ip_options.push_back(std::move(opt));
-            }
-
-            /**
-             * \brief Adds an IP option.
-             * 
-             * The option is constructed from the provided parameters.
-             * 
-             * \param args The arguments to be used in the option's 
-             * constructor.
-             */
-            template<typename... Args>
-            void add_option(Args&&... args) {
-                _ip_options.emplace_back(std::forward<Args>(args)...);
-                internal_add_option(_ip_options.back());
-            }
-        #endif
-
-        /**
-         * \brief Removes an IP option.
-         * 
-         * If there are multiple options of the given type, only the first one
-         * will be removed.
-         *
-         * \param type The type of the option to be removed.
-         * \return true if the option was removed, false otherwise.
-         */
-        bool remove_option(option_identifier id);
-
-        /**
-         * \brief Searchs for an option that matchs the given flag.
-         * 
-         * If the option is not found, a null pointer is returned. 
-         * Deleting the returned pointer will result in <b>undefined 
-         * behaviour</b>.
-         * 
-         * \param id The option identifier to be searched.
-         */
-        const option *search_option(option_identifier id) const;
-
-        // Option setters
-        
-        /**
-         * \brief Adds an End Of List option.
-         */
-        void eol();
-
-        /**
-         * \brief Adds a NOP option.
-         */
-        void noop();
-
-        /**
-         * \brief Adds a security option.
-         *
-         * \param data The data to be stored in this option.
-         */
-        void security(const security_type &data);
-        
-        /**
-         * \brief Adds a Loose Source and Record Route option.
-         *
-         * \param data The data to be stored in this option.
-         */
-        void lsrr(const lsrr_type &data) {
-            add_route_option(131, data);
-        }
-        
-        /**
-         * \brief Adds a Strict Source and Record Route option.
-         *
-         * \param data The data to be stored in this option.
-         */
-        void ssrr(const ssrr_type &data) {
-            add_route_option(137, data);
-        }
-        
-        /**
-         * \brief Adds a Record Route option.
-         *
-         * \param data The data to be stored in this option.
-         */
-        void record_route(const record_route_type &data) {
-            add_route_option(7, data);
-        }
-        
-        /**
-         * \brief Adds a Stream Identifier option.
-         *
-         * \param stream_id The stream id to be stored in this option.
-         */
-        void stream_identifier(uint16_t stream_id);
-        
-        // Option getters
-        
-        /**
-         * \brief Searchs and returns a security option.
-         * 
-         * If no such option exists, an option_not_found exception
-         * is thrown.
-         * 
-         * \return security_type containing the option found.
-         */
-        security_type security() const;
-        
-        /**
-         * \brief Searchs and returns a Loose Source and Record Route 
-         * option.
-         * 
-         * If no such option exists, an option_not_found exception
-         * is thrown.
-         * 
-         * \return lsrr_type containing the option found.
-         */
-        lsrr_type lsrr() const {
-            return search_route_option(131);
-        }
-        
-        /**
-         * \brief Searchs and returns a Strict Source and Record Route 
-         * option.
-         * 
-         * If no such option exists, an option_not_found exception
-         * is thrown.
-         * 
-         * \return ssrr_type containing the option found.
-         */
-        ssrr_type ssrr() const {
-            return search_route_option(137);
-        }
-        
-        /**
-         * \brief Searchs and returns a Record Route option.
-         * 
-         * If no such option exists, an option_not_found exception
-         * is thrown.
-         * 
-         * \return record_route_type containing the option found.
-         */
-        record_route_type record_route() const {
-            return search_route_option(7);
+        template<typename... Args>
+        void add_option(Args&&... args) {
+            ip_options_.emplace_back(std::forward<Args>(args)...);
+            internal_add_option(ip_options_.back());
         }
+    #endif
 
-        /**
-         * \brief Searchs and returns a Stream Identifier option.
-         * 
-         * If no such option exists, an option_not_found exception
-         * is thrown.
-         * 
-         * \return uint16_t containing the option found.
-         */
-        uint16_t stream_identifier() const;
+    /**
+     * \brief Removes an IP option.
+     * 
+     * If there are multiple options of the given type, only the first one
+     * will be removed.
+     *
+     * \param type The type of the option to be removed.
+     * \return true if the option was removed, false otherwise.
+     */
+    bool remove_option(option_identifier id);
 
-        /* Virtual methods */
+    /**
+     * \brief Searchs for an option that matchs the given flag.
+     * 
+     * If the option is not found, a null pointer is returned. 
+     * Deleting the returned pointer will result in <b>undefined 
+     * behaviour</b>.
+     * 
+     * \param id The option identifier to be searched.
+     */
+    const option* search_option(option_identifier id) const;
 
-        /**
-         * \brief Returns the header size.
-         *
-         * This metod overrides PDU::header_size. \sa PDU::header_size
-         */
-        uint32_t header_size() const;
+    // Option setters
+    
+    /**
+     * \brief Adds an End Of List option.
+     */
+    void eol();
 
-        /**
-         * \sa PDU::send()
-         */
-        void send(PacketSender &sender, const NetworkInterface &);
+    /**
+     * \brief Adds a NOP option.
+     */
+    void noop();
 
-        /**
-         * \brief Check wether ptr points to a valid response for this PDU.
-         *
-         * \sa PDU::matches_response
-         * \param ptr The pointer to the buffer.
-         * \param total_sz The size of the buffer.
-         */
-        bool matches_response(const uint8_t *ptr, uint32_t total_sz) const;
+    /**
+     * \brief Adds a security option.
+     *
+     * \param data The data to be stored in this option.
+     */
+    void security(const security_type& data);
+    
+    /**
+     * \brief Adds a Loose Source and Record Route option.
+     *
+     * \param data The data to be stored in this option.
+     */
+    void lsrr(const lsrr_type& data) {
+        add_route_option(131, data);
+    }
+    
+    /**
+     * \brief Adds a Strict Source and Record Route option.
+     *
+     * \param data The data to be stored in this option.
+     */
+    void ssrr(const ssrr_type& data) {
+        add_route_option(137, data);
+    }
+    
+    /**
+     * \brief Adds a Record Route option.
+     *
+     * \param data The data to be stored in this option.
+     */
+    void record_route(const record_route_type& data) {
+        add_route_option(7, data);
+    }
+    
+    /**
+     * \brief Adds a Stream Identifier option.
+     *
+     * \param stream_id The stream id to be stored in this option.
+     */
+    void stream_identifier(uint16_t stream_id);
+    
+    // Option getters
+    
+    /**
+     * \brief Searchs and returns a security option.
+     * 
+     * If no such option exists, an option_not_found exception
+     * is thrown.
+     * 
+     * \return security_type containing the option found.
+     */
+    security_type security() const;
+    
+    /**
+     * \brief Searchs and returns a Loose Source and Record Route 
+     * option.
+     * 
+     * If no such option exists, an option_not_found exception
+     * is thrown.
+     * 
+     * \return lsrr_type containing the option found.
+     */
+    lsrr_type lsrr() const {
+        return search_route_option(131);
+    }
+    
+    /**
+     * \brief Searchs and returns a Strict Source and Record Route 
+     * option.
+     * 
+     * If no such option exists, an option_not_found exception
+     * is thrown.
+     * 
+     * \return ssrr_type containing the option found.
+     */
+    ssrr_type ssrr() const {
+        return search_route_option(137);
+    }
+    
+    /**
+     * \brief Searchs and returns a Record Route option.
+     * 
+     * If no such option exists, an option_not_found exception
+     * is thrown.
+     * 
+     * \return record_route_type containing the option found.
+     */
+    record_route_type record_route() const {
+        return search_route_option(7);
+    }
 
-        /**
-         * \brief Receives a matching response for this packet.
-         *
-         * \sa PDU::recv_response
-         * \param sender The packet sender which will receive the packet.
-         */
-        PDU *recv_response(PacketSender &sender, const NetworkInterface &);
+    /**
+     * \brief Searchs and returns a Stream Identifier option.
+     * 
+     * If no such option exists, an option_not_found exception
+     * is thrown.
+     * 
+     * \return uint16_t containing the option found.
+     */
+    uint16_t stream_identifier() const;
 
-        /**
-         * Indicates whether this PDU is fragmented.
-         *
-         * \return true if this PDU is fragmented, false otherwise.
-         */
-        bool is_fragmented() const;
+    /* Virtual methods */
 
-        /**
-         * \brief Getter for the PDU's type.
-         * \sa PDU::pdu_type
-         */
-        PDUType pdu_type() const { return PDU::IP; }
+    /**
+     * \brief Returns the header size.
+     *
+     * This metod overrides PDU::header_size. \sa PDU::header_size
+     */
+    uint32_t header_size() const;
 
-        /**
-         * \sa PDU::clone
-         */
-        IP *clone() const {
-            return new IP(*this);
-        }
-    private:
-        static const uint8_t DEFAULT_TTL;
+    /**
+     * \sa PDU::send()
+     */
+    void send(PacketSender& sender, const NetworkInterface &);
 
-        TINS_BEGIN_PACK
-        struct iphdr {
-        #if TINS_IS_LITTLE_ENDIAN
-            uint8_t ihl:4,
-                    version:4;
-        #else
-            uint8_t version:4,
-                    ihl:4;
-        #endif
-            uint8_t tos;
-            uint16_t tot_len;
-            uint16_t id;
-            uint16_t frag_off;
-            uint8_t ttl;
-            uint8_t protocol;
-            uint16_t check;
-            uint32_t saddr;
-            uint32_t daddr;
-            /*The options start here. */
-        } TINS_END_PACK;
+    /**
+     * \brief Check wether ptr points to a valid response for this PDU.
+     *
+     * \sa PDU::matches_response
+     * \param ptr The pointer to the buffer.
+     * \param total_sz The size of the buffer.
+     */
+    bool matches_response(const uint8_t* ptr, uint32_t total_sz) const;
 
+    /**
+     * \brief Receives a matching response for this packet.
+     *
+     * \sa PDU::recv_response
+     * \param sender The packet sender which will receive the packet.
+     */
+    PDU* recv_response(PacketSender& sender, const NetworkInterface &);
 
-        void head_len(small_uint<4> new_head_len);
-        void tot_len(uint16_t new_tot_len);
+    /**
+     * Indicates whether this PDU is fragmented.
+     *
+     * \return true if this PDU is fragmented, false otherwise.
+     */
+    bool is_fragmented() const;
 
-        void prepare_for_serialize(const PDU *parent);
-        void internal_add_option(const option &option);
-        void init_ip_fields();
-        void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
-        void write_option(const option &opt, Memory::OutputMemoryStream& stream);
-        void add_route_option(option_identifier id, const generic_route_option_type &data);
-        generic_route_option_type search_route_option(option_identifier id) const;
-        void checksum(uint16_t new_check);
-        options_type::const_iterator search_option_iterator(option_identifier id) const;
-        options_type::iterator search_option_iterator(option_identifier id);
-        void update_padded_options_size();
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
 
-        iphdr _ip;
-        uint16_t _options_size, _padded_options_size;
-        options_type _ip_options;
-    };
+    /**
+     * \sa PDU::clone
+     */
+    IP* clone() const {
+        return new IP(*this);
+    }
+private:
+    static const uint8_t DEFAULT_TTL;
+
+    TINS_BEGIN_PACK
+    struct ip_header {
+    #if TINS_IS_LITTLE_ENDIAN
+        uint8_t ihl:4,
+                version:4;
+    #else
+        uint8_t version:4,
+                ihl:4;
+    #endif
+        uint8_t tos;
+        uint16_t tot_len;
+        uint16_t id;
+        uint16_t frag_off;
+        uint8_t ttl;
+        uint8_t protocol;
+        uint16_t check;
+        uint32_t saddr;
+        uint32_t daddr;
+    } TINS_END_PACK;
+
+    void head_len(small_uint<4> new_head_len);
+    void tot_len(uint16_t new_tot_len);
+
+    void prepare_for_serialize(const PDU* parent);
+    void internal_add_option(const option& option);
+    void init_ip_fields();
+    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
+    void write_option(const option& opt, Memory::OutputMemoryStream& stream);
+    void add_route_option(option_identifier id, const generic_route_option_type& data);
+    generic_route_option_type search_route_option(option_identifier id) const;
+    void checksum(uint16_t new_check);
+    options_type::const_iterator search_option_iterator(option_identifier id) const;
+    options_type::iterator search_option_iterator(option_identifier id);
+    void update_padded_options_size();
+
+    ip_header ip_;
+    uint16_t options_size_, padded_options_size_;
+    options_type ip_options_;
+};
 
 } // Tins
 
diff --git a/include/tins/ip_address.h b/include/tins/ip_address.h
index 9bfbf4b..6f77d7a 100644
--- a/include/tins/ip_address.h
+++ b/include/tins/ip_address.h
@@ -63,7 +63,7 @@ public:
      * 
      * \param ip const char* containing the dotted-notation address.
      */
-    IPv4Address(const char *ip = 0);
+    IPv4Address(const char* ip = 0);
     
     /**
      * \brief Constructor taking a std::string.
@@ -72,7 +72,7 @@ public:
      * 
      * \param ip std::string containing the dotted-notation address.
      */
-    IPv4Address(const std::string &ip);
+    IPv4Address(const std::string& ip);
     
     /**
      * \brief Constructor taking a IP address represented as a
@@ -102,8 +102,8 @@ public:
      * \param rhs The address to be compared.
      * \return bool indicating whether this address equals rhs.
      */
-    bool operator==(const IPv4Address &rhs) const {
-        return ip_addr == rhs.ip_addr;
+    bool operator==(const IPv4Address& rhs) const {
+        return ip_addr_ == rhs.ip_addr_;
     }
     
     /**
@@ -113,7 +113,7 @@ public:
      * \return bool indicating whether this address is distinct 
      * from rhs.
      */
-    bool operator!=(const IPv4Address &rhs) const {
+    bool operator!=(const IPv4Address& rhs) const {
         return !(*this == rhs);
     }
     
@@ -123,8 +123,8 @@ public:
      * \param rhs The address to be compared.
      * \return bool indicating whether this address is less-than rhs.
      */
-    bool operator< (const IPv4Address &rhs) const {
-        return ip_addr < rhs.ip_addr;
+    bool operator< (const IPv4Address& rhs) const {
+        return ip_addr_ < rhs.ip_addr_;
     }
     
     /**
@@ -176,25 +176,27 @@ public:
      * \param addr The IPv4Address to be written.
      * \return std::stream& pointing to output.
      */
-    friend std::ostream &operator<<(std::ostream &output, const IPv4Address &addr);
+    friend std::ostream& operator<<(std::ostream& output, const IPv4Address& addr);
 private:
     uint32_t ip_to_int(const char* ip);
 
-    uint32_t ip_addr;
+    uint32_t ip_addr_;
 };
-} //namespace Tins
+
+} // Tins
 
 #if TINS_IS_CXX11
-namespace std
-{
+namespace std {
+
 template<>
 struct hash<Tins::IPv4Address> {
-    size_t operator()(const Tins::IPv4Address &addr) const {
+    size_t operator()(const Tins::IPv4Address& addr) const {
         return std::hash<uint32_t>()(addr);
     }
 };
-} // namespace std
-#endif
 
+} // std
+
+#endif // TINS_IS_CXX11
 
 #endif // TINS_IPADDRESS_H
diff --git a/include/tins/ip_reassembler.h b/include/tins/ip_reassembler.h
index 7fd4a72..3675981 100644
--- a/include/tins/ip_reassembler.h
+++ b/include/tins/ip_reassembler.h
@@ -37,6 +37,7 @@
 #include "ip_address.h"
 
 namespace Tins {
+
 /** 
  * \cond
  */
@@ -49,13 +50,12 @@ public:
     IPv4Fragment() : offset_() { }
 
     template<typename T>
-    IPv4Fragment(T *pdu, uint16_t offset)
-    : payload_(pdu->serialize()), offset_(offset) 
-    {
+    IPv4Fragment(T* pdu, uint16_t offset)
+    : payload_(pdu->serialize()), offset_(offset) {
         
     }
     
-    const payload_type &payload() const {
+    const payload_type& payload() const {
         return payload_;
     }
     
@@ -71,19 +71,19 @@ class TINS_API IPv4Stream {
 public:
     IPv4Stream();
     
-    void add_fragment(IP *ip);
+    void add_fragment(IP* ip);
     bool is_complete() const;
-    PDU *allocate_pdu() const;
+    PDU* allocate_pdu() const;
 private:
     typedef std::vector<IPv4Fragment> fragments_type;
     
-    uint16_t extract_offset(const IP *ip);
-    bool extract_more_frag(const IP *ip);
+    uint16_t extract_offset(const IP* ip);
+    bool extract_more_frag(const IP* ip);
 
-    fragments_type fragments;
-    bool received_end;
-    uint8_t transport_proto;
-    size_t received_size, total_size;
+    fragments_type fragments_;
+    bool received_end_;
+    uint8_t transport_proto_;
+    size_t received_size_, total_size_;
 };
 } // namespace Internals
 
@@ -134,7 +134,7 @@ public:
      * fragmented or REASSEMBLED if the packet was fragmented 
      * but has now been reassembled.
      */
-    packet_status process(PDU &pdu);
+    packet_status process(PDU& pdu);
 
     /**
      * Removes all of the packets and data stored.
@@ -157,11 +157,11 @@ private:
     typedef std::pair<uint16_t, address_pair> key_type;
     typedef std::map<key_type, Internals::IPv4Stream> streams_type;
 
-    key_type make_key(const IP *ip) const;
+    key_type make_key(const IP* ip) const;
     address_pair make_address_pair(IPv4Address addr1, IPv4Address addr2) const;
     
-    streams_type streams;
-    overlapping_technique technique;
+    streams_type streams_;
+    overlapping_technique technique_;
 };
 
 /**
@@ -176,8 +176,7 @@ public:
      * \param func The functor object.
      */
     IPv4ReassemblerProxy(Functor func)
-    : functor_(func)
-    {
+    : functor_(func) {
 
     }
 
@@ -189,15 +188,15 @@ public:
      * \return true if the packet wasn't forwarded, otherwise
      * the value returned by the functor.
      */
-    bool operator()(PDU &pdu) {
+    bool operator()(PDU& pdu) {
         // Forward it unless it's fragmented.
-        if(reassembler.process(pdu) != IPv4Reassembler::FRAGMENTED)
+        if(reassembler_.process(pdu) != IPv4Reassembler::FRAGMENTED)
             return functor_(pdu);
         else
             return true;
     }
 private:
-    IPv4Reassembler reassembler;
+    IPv4Reassembler reassembler_;
     Functor functor_;
 };
 
diff --git a/include/tins/ipsec.h b/include/tins/ipsec.h
index 5bacdab..8b3c63f 100644
--- a/include/tins/ipsec.h
+++ b/include/tins/ipsec.h
@@ -36,6 +36,7 @@
 #include "small_uint.h"
 
 namespace Tins {
+
 /**
  * \class IPSecAH
  * \brief Represents an IPSec Authentication Header.
@@ -66,7 +67,7 @@ public:
      * \param buffer The buffer from which this PDU will be constructed.
      * \param total_sz The total size of the buffer.
      */
-    IPSecAH(const uint8_t *buffer, uint32_t total_sz);
+    IPSecAH(const uint8_t* buffer, uint32_t total_sz);
 
     // Getters
 
@@ -75,7 +76,7 @@ public:
      *  \return The stored Next header field value.
      */
     uint8_t next_header() const {
-        return _header.next_header;
+        return header_.next_header;
     }
 
     /**
@@ -83,7 +84,7 @@ public:
      *  \return The stored Length field value.
      */
     uint8_t length() const {
-        return _header.length;
+        return header_.length;
     }
 
     /**
@@ -91,7 +92,7 @@ public:
      *  \return The stored Security Parameters Index field value.
      */
     uint32_t spi() const {
-        return Endian::be_to_host(_header.spi);
+        return Endian::be_to_host(header_.spi);
     }
 
     /**
@@ -99,15 +100,15 @@ public:
      *  \return The stored Sequence number field value.
      */
     uint32_t seq_number() const {
-        return Endian::be_to_host(_header.seq_number);
+        return Endian::be_to_host(header_.seq_number);
     }
     
     /**
      *  \brief Getter for the ICV field.
      *  \return The stored ICV field value.
      */
-    const byte_array &icv() const {
-        return _icv;
+    const byte_array& icv() const {
+        return icv_;
     }
 
     // Setters
@@ -138,9 +139,9 @@ public:
     
     /**
      *  \brief Setter for the ICV field.
-     *  \param new_icv The new ICV field value.
+     *  \param newicv_ The new ICV field value.
      */
-    void icv(const byte_array &new_icv);
+    void icv(const byte_array& newicv_);
 
     /**
      * \brief Returns the header size.
@@ -158,19 +159,19 @@ public:
     /**
      * \sa PDU::clone
      */
-    IPSecAH *clone() const {
+    IPSecAH* clone() const {
         return new IPSecAH(*this);
     }
 private:
-    struct header {
+    struct ipsec_header {
         uint8_t next_header, length;
         uint32_t spi, seq_number;
     };
 
-    void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU *);
     
-    header _header;
-    byte_array _icv;
+    ipsec_header header_;
+    byte_array icv_;
 };
 
 /**
@@ -199,7 +200,7 @@ public:
      * \param buffer The buffer from which this PDU will be constructed.
      * \param total_sz The total size of the buffer.
      */
-    IPSecESP(const uint8_t *buffer, uint32_t total_sz);
+    IPSecESP(const uint8_t* buffer, uint32_t total_sz);
 
     // Getters
     
@@ -208,7 +209,7 @@ public:
      *  \return The stored Security Parameters Index field value.
      */
     uint32_t spi() const {
-        return Endian::be_to_host(_header.spi);
+        return Endian::be_to_host(header_.spi);
     }
 
     /**
@@ -216,7 +217,7 @@ public:
      *  \return The stored Sequence number field value.
      */
     uint32_t seq_number() const {
-        return Endian::be_to_host(_header.seq_number);
+        return Endian::be_to_host(header_.seq_number);
     }
 
     // Setters
@@ -249,17 +250,17 @@ public:
     /**
      * \sa PDU::clone
      */
-    IPSecESP *clone() const {
+    IPSecESP* clone() const {
         return new IPSecESP(*this);
     }
 private:
-    struct header {
+    struct ipsec_header {
         uint32_t spi, seq_number;
     };
 
-    void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU *);
     
-    header _header;
+    ipsec_header header_;
 };
 }
 
diff --git a/include/tins/ipv6.h b/include/tins/ipv6.h
index 35bc711..f9a24ba 100644
--- a/include/tins/ipv6.h
+++ b/include/tins/ipv6.h
@@ -41,7 +41,9 @@
 
 namespace Tins {
 namespace Memory {
+
 class OutputMemoryStream;
+
 } // Memory
 
 class PacketSender;
@@ -96,8 +98,8 @@ public:
      * for the packet being constructed(optional).
      */
     IPv6(address_type ip_dst = address_type(), 
-        address_type ip_src = address_type(), 
-        PDU *child = 0);
+         address_type ip_src = address_type(), 
+         PDU* child = 0);
 
     /**
      * \brief Constructs an IPv6 object from a buffer and adds all 
@@ -109,7 +111,7 @@ public:
      * \param buffer The buffer from which this PDU will be constructed.
      * \param total_sz The total size of the buffer.
      */
-    IPv6(const uint8_t *buffer, uint32_t total_sz);
+    IPv6(const uint8_t* buffer, uint32_t total_sz);
 
     // Getters
 
@@ -118,7 +120,7 @@ public:
      *  \return The stored version field value.
      */
     small_uint<4> version() const {
-        return _header.version;
+        return header_.version;
     }
 
     /**
@@ -127,10 +129,10 @@ public:
      */
     uint8_t traffic_class() const {
         #if TINS_IS_LITTLE_ENDIAN
-        return ((_header.traffic_class << 4) & 0xf0) | 
-                ((_header.flow_label[0] >> 4) & 0x0f);
+        return ((header_.traffic_class << 4) & 0xf0) | 
+                ((header_.flow_label[0] >> 4) & 0x0f);
         #else
-        return _header.traffic_class;
+        return header_.traffic_class;
         #endif
     }
 
@@ -140,11 +142,11 @@ public:
      */
     small_uint<20> flow_label() const {
         #if TINS_IS_LITTLE_ENDIAN
-        return ((_header.flow_label[0] & 0x0f) << 16)
-                | (_header.flow_label[1] << 8)
-                | (_header.flow_label[2]);
+        return ((header_.flow_label[0] & 0x0f) << 16)
+                | (header_.flow_label[1] << 8)
+                | (header_.flow_label[2]);
         #else
-        return _header.flow_label;
+        return header_.flow_label;
         #endif
     }
 
@@ -153,7 +155,7 @@ public:
      *  \return The stored payload_length field value.
      */
     uint16_t payload_length() const {
-        return Endian::be_to_host(_header.payload_length);
+        return Endian::be_to_host(header_.payload_length);
     }
 
     /**
@@ -161,7 +163,7 @@ public:
      *  \return The stored next_header field value.
      */
     uint8_t next_header() const {
-        return _header.next_header;
+        return header_.next_header;
     }
 
     /**
@@ -169,7 +171,7 @@ public:
      *  \return The stored hop_limit field value.
      */
     uint8_t hop_limit() const {
-        return _header.hop_limit;
+        return header_.hop_limit;
     }
 
     /**
@@ -177,7 +179,7 @@ public:
      *  \return The stored src_addr field value.
      */
     address_type src_addr() const {
-        return _header.src_addr;
+        return header_.src_addr;
     }
 
     /**
@@ -185,7 +187,7 @@ public:
      *  \return The stored dst_addr field value.
      */
     address_type dst_addr() const {
-        return _header.dst_addr;
+        return header_.dst_addr;
     }
 
     /**
@@ -193,7 +195,7 @@ public:
      *  \return The stored headers.
      */
     const headers_type& headers() const {
-        return ext_headers;
+        return ext_headers_;
     }
 
     // Setters
@@ -238,13 +240,13 @@ public:
      * \brief Setter for the src_addr field.
      * \param new_src_addr The new src_addr field value.
      */
-    void src_addr(const address_type &new_src_addr);
+    void src_addr(const address_type& new_src_addr);
 
     /**
      * \brief Setter for the dst_addr field.
      * \param new_dst_addr The new dst_addr field value.
      */
-    void dst_addr(const address_type &new_dst_addr);
+    void dst_addr(const address_type& new_dst_addr);
     
     /**
      * \brief Returns the header size.
@@ -260,12 +262,12 @@ public:
      * \param ptr The pointer to the buffer.
      * \param total_sz The size of the buffer.
      */
-    bool matches_response(const uint8_t *ptr, uint32_t total_sz) const;
+    bool matches_response(const uint8_t* ptr, uint32_t total_sz) const;
     
     /**
      * \sa PDU::clone
      */
-    IPv6 *clone() const {
+    IPv6* clone() const {
         return new IPv6(*this);
     }
     
@@ -279,7 +281,7 @@ public:
     /**
      * \sa PDU::send()
      */
-    void send(PacketSender &sender, const NetworkInterface &);
+    void send(PacketSender& sender, const NetworkInterface &);
     #endif
     
     /**
@@ -287,7 +289,7 @@ public:
      * 
      * \param header The extension header to be added.
      */
-    void add_ext_header(const ext_header &header);
+    void add_ext_header(const ext_header& header);
     
     /**
      * \brief Searchs for an extension header that matchs the given 
@@ -299,11 +301,11 @@ public:
      * 
      * \param id The header identifier to be searched.
      */
-    const ext_header *search_header(ExtensionHeader id) const;
+    const ext_header* search_header(ExtensionHeader id) const;
 private:
-    void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
     void set_last_next_header(uint8_t value);
-    static void write_header(const ext_header &header, Memory::OutputMemoryStream& stream);
+    static void write_header(const ext_header& header, Memory::OutputMemoryStream& stream);
     static bool is_extension_header(uint8_t header_id);
 
     TINS_BEGIN_PACK
@@ -326,9 +328,9 @@ private:
         uint8_t src_addr[16], dst_addr[16];
     } TINS_END_PACK;
 
-    ipv6_header _header;
-    headers_type ext_headers;
-    uint32_t headers_size;
+    ipv6_header header_;
+    headers_type ext_headers_;
+    uint32_t headers_size_;
 };
 }
 
diff --git a/include/tins/ipv6_address.h b/include/tins/ipv6_address.h
index 6727e9d..4ce831d 100644
--- a/include/tins/ipv6_address.h
+++ b/include/tins/ipv6_address.h
@@ -43,16 +43,6 @@ namespace Tins {
  */
 class TINS_API IPv6Address {
 public:
-    /**
-     * The exception thrown when a malformed address is parsed.
-     */
-    class malformed_address : public std::exception {
-    public:
-        const char *what() const throw() {
-            return "Malformed address";
-        }
-    };
-    
     static const size_t address_size = 16;
     
     /**
@@ -76,14 +66,14 @@ public:
      * \param addr The text representation from which to construct this
      * object.
      */
-    IPv6Address(const char *addr);
+    IPv6Address(const char* addr);
     
     /**
      * \brief Constructor from a text representation std::string.
      * \param addr The text representation from which to construct this
      * object.
      */
-    IPv6Address(const std::string &addr);
+    IPv6Address(const std::string& addr);
     
     /**
      * \brief Constructor from a buffer.
@@ -105,21 +95,21 @@ public:
      * Returns an iterator to the beginning of this address.
      */
     iterator begin() {
-        return address;
+        return address_;
     }
     
     /**
      * Returns a const iterator to the beginning of this address.
      */
     const_iterator begin() const {
-        return address;
+        return address_;
     }
     
     /**
      * Returns an iterator to the one-past-the-end element of this address.
      */
     iterator end() {
-        return address + address_size;
+        return address_ + address_size;
     }
     
     /**
@@ -127,7 +117,7 @@ public:
      * address.
      */
     const_iterator end() const {
-        return address + address_size;
+        return address_ + address_size;
     }
     
     /**
@@ -137,8 +127,8 @@ public:
      * 
      * \return bool indicating whether addresses are equal.
      */
-    bool operator==(const IPv6Address &rhs) const {
-        return std::equal(begin(), end(), rhs.address);
+    bool operator==(const IPv6Address& rhs) const {
+        return std::equal(begin(), end(), rhs.address_);
     }
     
     /**
@@ -148,7 +138,7 @@ public:
      * 
      * \return bool indicating whether addresses are distinct.
      */
-    bool operator!=(const IPv6Address &rhs) const {
+    bool operator!=(const IPv6Address& rhs) const {
         return !(*this == rhs);
     }
     
@@ -159,7 +149,7 @@ public:
      * 
      * \return bool indicating whether this address is less-than rhs.
      */
-    bool operator<(const IPv6Address &rhs) const {
+    bool operator<(const IPv6Address& rhs) const {
         return std::lexicographical_compare(begin(), end(), rhs.begin(), rhs.end());
     }
     
@@ -206,26 +196,29 @@ public:
      * \param addr The parameter to be written.
      * \return std::ostream& pointing to the os parameter.
      */
-    friend std::ostream &operator<<(std::ostream &os, const IPv6Address &addr) {
+    friend std::ostream& operator<<(std::ostream& os, const IPv6Address& addr) {
         return os << addr.to_string();
     }
 private:
-    void init(const char *addr);
+    void init(const char* addr);
 
-    uint8_t address[address_size];
+    uint8_t address_[address_size];
 };
-} //namespace Tins
+
+} // Tins
 
 #if TINS_IS_CXX11
-namespace std
-{
+namespace std {
+
 template<>
 struct hash<Tins::IPv6Address> {
-    size_t operator()(const Tins::IPv6Address &addr) const {
+    size_t operator()(const Tins::IPv6Address& addr) const {
         return std::hash<std::string>()(addr.to_string());
     }
 };
-} // namespace std
-#endif
+
+} // std
+
+#endif // TINS_IS_CXX11
 
 #endif // TINS_IPV6_ADDRESS
diff --git a/include/tins/llc.h b/include/tins/llc.h
index 9e9cd87..90bdee0 100644
--- a/include/tins/llc.h
+++ b/include/tins/llc.h
@@ -40,366 +40,382 @@
 
 namespace Tins {
 
+/**
+ * \class LLC
+ * \brief Representing a LLC frame.
+ *
+ * This PDU follows the standard LLC frame described in the IEEE 802.2 specs.
+ */
+class TINS_API LLC : public PDU {
+public:
     /**
-     * \class LLC
-     * \brief Representing a LLC frame.
-     *
-     * This PDU follows the standard LLC frame described in the IEEE 802.2 specs.
+     * \brief This PDU's flag.
      */
-    class TINS_API LLC : public PDU {
-    public:
-        /**
-         * \brief This PDU's flag.
-         */
-        static const PDU::PDUType pdu_flag = PDU::LLC;
+    static const PDU::PDUType pdu_flag = PDU::LLC;
 
-    	/**
-         * \brief Represents the LLC global DSAP address.
-         */
-        static const uint8_t GLOBAL_DSAP_ADDR;
-        
-        /**
-         * \brief Represents the LLC NULL address.
-         */
-        static const uint8_t NULL_ADDR;
+	/**
+     * \brief Represents the LLC global DSAP address.
+     */
+    static const uint8_t GLOBAL_DSAP_ADDR;
+    
+    /**
+     * \brief Represents the LLC NULL address.
+     */
+    static const uint8_t NULL_ADDR;
 
-        /**
-         * \brief LLC Format flags.
-         */
-        enum Format {
-            INFORMATION = 0,
-            SUPERVISORY = 1,
-            UNNUMBERED = 3
-        };
-
-        /**
-         * \brief LLC Modifier functions.
-         */
-        enum ModifierFunctions {
-        	UI = 0x00,
-        	XID = 0x1D,
-        	TEST = 0x07,
-        	SABME = 0x1E,
-        	DISC = 0x02,
-        	UA = 0x06,
-        	DM = 0x18,
-        	FRMR = 0x11
-        };
-
-        /**
-         * \brief LLC Supervisory functions
-         */
-        enum SupervisoryFunctions {
-        	RECEIVE_READY = 0,
-        	REJECT = 2,
-        	RECEIVE_NOT_READY = 1
-        };
-
-        /**
-         * \brief Default constructor.
-         */
-    	LLC();
-
-    	/**
-    	 * \brief Constructs an instance of LLC, setting the dsap and ssap.
-    	 * The control field is set to 0.
-    	 * \param dsap The dsap value to be set.
-    	 * \param ssap The ssap value to be set.
-    	 */
-    	LLC(uint8_t dsap, uint8_t ssap);
-
-        /**
-         * \brief Constructs a LLC object from a buffer and adds all 
-         * identifiable PDUs found in the buffer as children of this one.
-         * 
-         * If there is not enough size for a LLC header, a malformed_packet
-         * exception is thrown.
-         * 
-         * \param buffer The buffer from which this PDU will be constructed.
-         * \param total_sz The total size of the buffer.
-         */
-    	LLC(const uint8_t *buffer, uint32_t total_sz);
-
-        /* Setters */
-
-    	/**
-		 * \brief Setter for the group destination bit.
-		 * \param value The value to be set.
-		 */
-        void group(bool value);
-
-        /**
-		 * \brief Setter for the dsap field.
-		 * \param new_dsap The new dsap field.
-		 */
-		void dsap(uint8_t new_dsap);
-
-		/**
-		 * \brief Setter for the response bit.
-		 * \param value The value to be set.
-		 */
-		void response(bool value);
-
-		/**
-		 * \brief Setter for the ssap field.
-		 * \param new_ssap The new ssap field.
-		 */
-		void ssap(uint8_t new_ssap);
-
-		/**
-		 * \brief Setter for the LLC frame format type.
-		 * \param type The LLC frame format to set.
-		 */
-		void type(Format type);
-
-		/**
-		 * \brief Setter for sender send sequence number.
-		 * 	Only applied if format is INFORMATION.
-		 * \param seq_number New sender send sequence number to be set.
-		 */
-		void send_seq_number(uint8_t seq_number);
-
-		/**
-		 * \brief Setter for sender receive sequence number.
-		 * 	Only applied if format is INFORMATION or SUPERVISORY.
-		 * \param seq_number New sender receive sequence number to be set.
-		 */
-		void receive_seq_number(uint8_t seq_number);
-
-		/**
-		 * \brief Setter for the poll/final flag.
-		 * \param value Bool indicating the value of the flag.
-		 */
-		void poll_final(bool value);
-
-		/**
-		 * \brief Setter for the supervisory function.
-		 * Only applied if format is SUPERVISORY.
-		 * \param new_func Value to set on the supervisory function field.
-		 */
-		void supervisory_function(SupervisoryFunctions new_func);
-
-		/**
-		 * \brief Setter for the modifier function field.
-		 * Only applied if format is UNNUMBERED.
-		 * \param modifier_func Value to set on the modifier function field.
-		 */
-		void modifier_function(ModifierFunctions mod_func);
-
-		/**
-		 * \brief Add a xid information field.
-		 * Only applied if format is UNNUMBERED and function is XID.
-		 * \param xid_id XID information of the MAC sublayer.
-		 * \param llc_type_class Value to set the llc_type_class field.
-		 * \param receive_window XID sender's receive window size.
-		 */
-		void add_xid_information(uint8_t xid_id, uint8_t llc_type_class, uint8_t receive_window);
-
-		//TODO: Add Acknowledged connectionless information
-
-        /* Getters */
-
-		/**
-		 * \brief Getter for the group destination bit.
-		 * \return Whether the group bit is set or not.
-		 */
-		bool group() {return _header.dsap & 0x01; }
-
-		/**
-		 * \brief Getter for the dsap field.
-		 * \return The dsap field value
-		 */
-		uint8_t dsap() {return _header.dsap; }
-
-		/**
-		 * \brief Getter for the response bit.
-		 * \return Whether the response bit is set or not.
-		 */
-		bool response() {return (_header.ssap & 0x01); }
-
-		/**
-		 * \brief Getter for the ssap field.
-		 * \return The ssap field.
-		 */
-		uint8_t ssap() {return _header.ssap; }
-
-		/**
-		 * \brief Getter for the LLC frame format type.
-		 * \return The LLC frame format.
-		 */
-		uint8_t type() {return _type; }
-
-		/**
-		 * \brief Getter for sender send sequence number.
-		 *
-		 * \return The sender send sequence number if format is INFORMATION else 0.
-		 */
-		uint8_t send_seq_number() {
-			return (type() == INFORMATION) ? (control_field.info.send_seq_num) : 0;
-		}
-
-		/**
-		 * \brief Getter for sender receive sequence number.
-		 *
-		 * \return 	The sender receive sequence number if format is
-		 * 			INFORMATION or SUPERVISORY else 0.
-		 */
-		uint8_t receive_seq_number() {
-			switch (type()) {
-				case INFORMATION:
-					return control_field.info.recv_seq_num;
-				case SUPERVISORY:
-					return control_field.super.recv_seq_num;
-				case UNNUMBERED:
-					return 0;
-                default:
-                    return 0;
-			}
-		}
-
-		/**
-		 * \brief Getter for the poll/final flag.
-		 * \return Whether the poll/final flag is set.
-		 */
-		bool poll_final() {
-			switch (type()) {
-				case UNNUMBERED:
-					return control_field.unnumbered.poll_final_bit;
-				case INFORMATION:
-					return control_field.info.poll_final_bit;
-				case SUPERVISORY:
-					return control_field.super.poll_final_bit;
-                default:
-                    return false;
-			}
-		}
-
-		/**
-		 * \brief Getter for the supervisory function.
-		 *
-		 * \return The supervisory function if format is SUPERVISORY else 0.
-		 */
-		uint8_t supervisory_function() {
-			if (type() == SUPERVISORY)
-				return control_field.super.supervisory_func;
-			return 0;
-		}
-
-		/**
-		 * \brief Getter for the modifier function field.
-		 *
-		 * \return The modifier function if format is UNNUMBERED else 0.
-		 */
-		uint8_t modifier_function() {
-			if (type() == UNNUMBERED)
-				return (control_field.unnumbered.mod_func1 << 3) + control_field.unnumbered.mod_func2;
-			return 0;
-		}
-
-        /**
-         * \brief Returns the LLC frame's header length.
-         *
-         * \return The header's size.
-         * \sa PDU::header_size()
-         */
-        uint32_t header_size() const;
-
-        /**
-         * \brief Getter for the PDU's type.
-         * \sa PDU::pdu_type
-         */
-        PDUType pdu_type() const { return pdu_flag; }
-
-        /**
-		 * \brief Delete all the information fields added.
-		 */
-		void clear_information_fields();
-
-        /**
-         * \brief Clones this PDU.
-         *
-         * \sa PDU::clone
-         */
-        LLC *clone() const {
-            return new LLC(*this);
-        }
-    private:
-        TINS_BEGIN_PACK
-        struct llchdr {
-            uint8_t dsap;
-            uint8_t ssap;
-        } TINS_END_PACK;
-
-        #if TINS_IS_LITTLE_ENDIAN
-            TINS_BEGIN_PACK
-            struct info_control_field {
-                uint16_t
-                            type_bit:1,
-                            send_seq_num:7,
-                            poll_final_bit:1,
-                            recv_seq_num:7;
-            } TINS_END_PACK;
-
-            TINS_BEGIN_PACK
-            struct super_control_field {
-                uint16_t	type_bit:2,
-                            supervisory_func:2,
-                            unused:4,
-                            poll_final_bit:1,
-                            recv_seq_num:7;
-            } TINS_END_PACK;
-
-            TINS_BEGIN_PACK
-            struct un_control_field {
-                uint8_t		type_bits:2,
-                            mod_func1:2,
-                            poll_final_bit:1,
-                            mod_func2:3;
-            } TINS_END_PACK;
-        #elif TINS_IS_BIG_ENDIAN
-            TINS_BEGIN_PACK
-            struct info_control_field {
-                uint16_t    send_seq_num:7,
-                            type_bit:1,
-                            recv_seq_num:7,
-                            poll_final_bit:1;
-            } TINS_END_PACK;
-
-            TINS_BEGIN_PACK
-            struct super_control_field {
-                uint16_t	unused:4,
-                            supervisory_func:2,
-                            type_bit:2,
-                            recv_seq_num:7,
-                            poll_final_bit:1;
-            } TINS_END_PACK;
-
-            TINS_BEGIN_PACK
-            struct un_control_field {
-                uint8_t		mod_func2:3,
-                            poll_final_bit:1,
-                            mod_func1:2,
-                            type_bits:2;
-            } TINS_END_PACK;
-        #endif
-        
-        typedef std::vector<uint8_t> field_type;
-        typedef std::list<field_type> field_list;
-
-        void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
-
-        llchdr _header;
-        uint8_t control_field_length;
-        union {
-        	info_control_field info;
-        	super_control_field super;
-        	un_control_field unnumbered;
-        } control_field;
-        Format _type;
-        uint8_t information_field_length;
-        field_list information_fields;
+    /**
+     * \brief LLC Format flags.
+     */
+    enum Format {
+        INFORMATION = 0,
+        SUPERVISORY = 1,
+        UNNUMBERED = 3
     };
 
-}
+    /**
+     * \brief LLC Modifier functions.
+     */
+    enum ModifierFunctions {
+    	UI = 0x00,
+    	XID = 0x1D,
+    	TEST = 0x07,
+    	SABME = 0x1E,
+    	DISC = 0x02,
+    	UA = 0x06,
+    	DM = 0x18,
+    	FRMR = 0x11
+    };
+
+    /**
+     * \brief LLC Supervisory functions
+     */
+    enum SupervisoryFunctions {
+    	RECEIVE_READY = 0,
+    	REJECT = 2,
+    	RECEIVE_NOT_READY = 1
+    };
+
+    /**
+     * \brief Default constructor.
+     */
+	LLC();
+
+	/**
+	 * \brief Constructs an instance of LLC, setting the dsap and ssap.
+	 * The control field is set to 0.
+	 * \param dsap The dsap value to be set.
+	 * \param ssap The ssap value to be set.
+	 */
+	LLC(uint8_t dsap, uint8_t ssap);
+
+    /**
+     * \brief Constructs a LLC object from a buffer and adds all 
+     * identifiable PDUs found in the buffer as children of this one.
+     * 
+     * If there is not enough size for a LLC header, a malformed_packet
+     * exception is thrown.
+     * 
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+	LLC(const uint8_t* buffer, uint32_t total_sz);
+
+    /* Setters */
+
+	/**
+	 * \brief Setter for the group destination bit.
+	 * \param value The value to be set.
+	 */
+    void group(bool value);
+
+    /**
+	 * \brief Setter for the dsap field.
+	 * \param new_dsap The new dsap field.
+	 */
+	void dsap(uint8_t new_dsap);
+
+	/**
+	 * \brief Setter for the response bit.
+	 * \param value The value to be set.
+	 */
+	void response(bool value);
+
+	/**
+	 * \brief Setter for the ssap field.
+	 * \param new_ssap The new ssap field.
+	 */
+	void ssap(uint8_t new_ssap);
+
+	/**
+	 * \brief Setter for the LLC frame format type.
+	 * \param type The LLC frame format to set.
+	 */
+	void type(Format type);
+
+	/**
+	 * \brief Setter for sender send sequence number.
+	 * 	Only applied if format is INFORMATION.
+	 * \param seq_number New sender send sequence number to be set.
+	 */
+	void send_seq_number(uint8_t seq_number);
+
+	/**
+	 * \brief Setter for sender receive sequence number.
+	 * 	Only applied if format is INFORMATION or SUPERVISORY.
+	 * \param seq_number New sender receive sequence number to be set.
+	 */
+	void receive_seq_number(uint8_t seq_number);
+
+	/**
+	 * \brief Setter for the poll/final flag.
+	 * \param value Bool indicating the value of the flag.
+	 */
+	void poll_final(bool value);
+
+	/**
+	 * \brief Setter for the supervisory function.
+	 * Only applied if format is SUPERVISORY.
+	 * \param new_func Value to set on the supervisory function field.
+	 */
+	void supervisory_function(SupervisoryFunctions new_func);
+
+	/**
+	 * \brief Setter for the modifier function field.
+	 * Only applied if format is UNNUMBERED.
+	 * \param modifier_func Value to set on the modifier function field.
+	 */
+	void modifier_function(ModifierFunctions mod_func);
+
+	/**
+	 * \brief Add a xid information field.
+	 * Only applied if format is UNNUMBERED and function is XID.
+	 * \param xid_id XID information of the MAC sublayer.
+	 * \param llc_type_class Value to set the llc_type_class field.
+	 * \param receive_window XID sender's receive window size.
+	 */
+	void add_xid_information(uint8_t xid_id, 
+                             uint8_t llc_type_class,
+                             uint8_t receive_window);
+
+	//TODO: Add Acknowledged connectionless information
+
+    /* Getters */
+
+	/**
+	 * \brief Getter for the group destination bit.
+	 * \return Whether the group bit is set or not.
+	 */
+	bool group() {
+        return header_.dsap & 0x01;
+    }
+
+	/**
+	 * \brief Getter for the dsap field.
+	 * \return The dsap field value
+	 */
+	uint8_t dsap() {
+        return header_.dsap;
+    }
+
+	/**
+	 * \brief Getter for the response bit.
+	 * \return Whether the response bit is set or not.
+	 */
+	bool response() {
+        return (header_.ssap & 0x01);
+    }
+
+	/**
+	 * \brief Getter for the ssap field.
+	 * \return The ssap field.
+	 */
+	uint8_t ssap() {
+        return header_.ssap;
+    }
+
+	/**
+	 * \brief Getter for the LLC frame format type.
+	 * \return The LLC frame format.
+	 */
+	uint8_t type() {
+        return type_;
+    }
+
+	/**
+	 * \brief Getter for sender send sequence number.
+	 *
+	 * \return The sender send sequence number if format is INFORMATION else 0.
+	 */
+	uint8_t send_seq_number() {
+		return (type() == INFORMATION) ? (control_field.info.send_seq_num) : 0;
+	}
+
+	/**
+	 * \brief Getter for sender receive sequence number.
+	 *
+	 * \return 	The sender receive sequence number if format is
+	 * 			INFORMATION or SUPERVISORY else 0.
+	 */
+	uint8_t receive_seq_number() {
+		switch (type()) {
+			case INFORMATION:
+				return control_field.info.recv_seq_num;
+			case SUPERVISORY:
+				return control_field.super.recv_seq_num;
+			case UNNUMBERED:
+				return 0;
+            default:
+                return 0;
+		}
+	}
+
+	/**
+	 * \brief Getter for the poll/final flag.
+	 * \return Whether the poll/final flag is set.
+	 */
+	bool poll_final() {
+		switch (type()) {
+			case UNNUMBERED:
+				return control_field.unnumbered.poll_final_bit;
+			case INFORMATION:
+				return control_field.info.poll_final_bit;
+			case SUPERVISORY:
+				return control_field.super.poll_final_bit;
+            default:
+                return false;
+		}
+	}
+
+	/**
+	 * \brief Getter for the supervisory function.
+	 *
+	 * \return The supervisory function if format is SUPERVISORY else 0.
+	 */
+	uint8_t supervisory_function() {
+		if (type() == SUPERVISORY) {
+			return control_field.super.supervisory_func;
+        }
+		return 0;
+	}
+
+	/**
+	 * \brief Getter for the modifier function field.
+	 *
+	 * \return The modifier function if format is UNNUMBERED else 0.
+	 */
+	uint8_t modifier_function() {
+		if (type() == UNNUMBERED) {
+			return (control_field.unnumbered.mod_func1 << 3) + control_field.unnumbered.mod_func2;
+        }
+		return 0;
+	}
+
+    /**
+     * \brief Returns the LLC frame's header length.
+     *
+     * \return The header's size.
+     * \sa PDU::header_size()
+     */
+    uint32_t header_size() const;
+
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
+
+    /**
+	 * \brief Delete all the information fields added.
+	 */
+	void clear_information_fields();
+
+    /**
+     * \brief Clones this PDU.
+     *
+     * \sa PDU::clone
+     */
+    LLC* clone() const {
+        return new LLC(*this);
+    }
+private:
+    TINS_BEGIN_PACK
+    struct llchdr {
+        uint8_t dsap;
+        uint8_t ssap;
+    } TINS_END_PACK;
+
+    #if TINS_IS_LITTLE_ENDIAN
+        TINS_BEGIN_PACK
+        struct info_control_field {
+            uint16_t
+                        type_bit:1,
+                        send_seq_num:7,
+                        poll_final_bit:1,
+                        recv_seq_num:7;
+        } TINS_END_PACK;
+
+        TINS_BEGIN_PACK
+        struct super_control_field {
+            uint16_t	type_bit:2,
+                        supervisory_func:2,
+                        unused:4,
+                        poll_final_bit:1,
+                        recv_seq_num:7;
+        } TINS_END_PACK;
+
+        TINS_BEGIN_PACK
+        struct un_control_field {
+            uint8_t		type_bits:2,
+                        mod_func1:2,
+                        poll_final_bit:1,
+                        mod_func2:3;
+        } TINS_END_PACK;
+    #elif TINS_IS_BIG_ENDIAN
+        TINS_BEGIN_PACK
+        struct info_control_field {
+            uint16_t    send_seq_num:7,
+                        type_bit:1,
+                        recv_seq_num:7,
+                        poll_final_bit:1;
+        } TINS_END_PACK;
+
+        TINS_BEGIN_PACK
+        struct super_control_field {
+            uint16_t	unused:4,
+                        supervisory_func:2,
+                        type_bit:2,
+                        recv_seq_num:7,
+                        poll_final_bit:1;
+        } TINS_END_PACK;
+
+        TINS_BEGIN_PACK
+        struct un_control_field {
+            uint8_t		mod_func2:3,
+                        poll_final_bit:1,
+                        mod_func1:2,
+                        type_bits:2;
+        } TINS_END_PACK;
+    #endif
+    
+    typedef std::vector<uint8_t> field_type;
+    typedef std::list<field_type> field_list;
+
+    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
+
+    llchdr header_;
+    uint8_t control_field_length_;
+    union {
+    	info_control_field info;
+    	super_control_field super;
+    	un_control_field unnumbered;
+    } control_field;
+    Format type_;
+    uint8_t information_field_length_;
+    field_list information_fields_;
+};
+
+} // Tins
 
 #endif // TINS_IEEE8022_H
diff --git a/include/tins/loopback.h b/include/tins/loopback.h
index 9e50bee..5fb2966 100644
--- a/include/tins/loopback.h
+++ b/include/tins/loopback.h
@@ -34,6 +34,10 @@
 #include "macros.h"
 
 namespace Tins {
+
+/**
+ * \brief Represents a Loopback PDU
+ */
 class TINS_API Loopback : public PDU {
 public:
     /**
@@ -61,13 +65,15 @@ public:
      * \param buffer The buffer from which this PDU will be constructed.
      * \param total_sz The total size of the buffer.
      */
-    Loopback(const uint8_t *buffer, uint32_t total_sz);
+    Loopback(const uint8_t* buffer, uint32_t total_sz);
     
     /**
      * \brief Getter for the family identifier.
      * \return The stored family identifier.
      */
-    uint32_t family() const { return _family; }
+    uint32_t family() const {
+        return family_;
+    }
     
     /**
      * \brief Setter for the family identifier.
@@ -84,7 +90,9 @@ public:
      * \brief Getter for the PDU's type.
      * \sa PDU::pdu_type
      */
-    PDUType pdu_type() const { return pdu_flag; }
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
     
     /** 
      * \brief Check wether ptr points to a valid response for this PDU.
@@ -93,26 +101,27 @@ public:
      * \param ptr The pointer to the buffer.
      * \param total_sz The size of the buffer.
      */
-    bool matches_response(const uint8_t *ptr, uint32_t total_sz) const;
+    bool matches_response(const uint8_t* ptr, uint32_t total_sz) const;
     
     /**
      * \sa PDU::clone
      */
-    Loopback *clone() const {
+    Loopback* clone() const {
         return new Loopback(*this);
     }
-    // Null/Loopback can only be sent in *BSD
+    // Null/Loopback can only be sent in* BSD
     #ifdef BSD
     /**
      * \sa PDU::send()
      */
-    void send(PacketSender &sender, const NetworkInterface &iface);
+    void send(PacketSender& sender, const NetworkInterface& iface);
     #endif // BSD
 private:
-    void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
 
-    uint32_t _family;
+    uint32_t family_;
 };
-}
+
+} // Tins
 
 #endif // TINS_LOOPBACK_H
diff --git a/include/tins/memory_helpers.h b/include/tins/memory_helpers.h
index 0f02ae3..144ac2a 100644
--- a/include/tins/memory_helpers.h
+++ b/include/tins/memory_helpers.h
@@ -38,6 +38,7 @@
 #include "ip_address.h"
 #include "ipv6_address.h"
 #include "hw_address.h"
+#include "endianness.h"
 
 namespace Tins {
 namespace Memory {
@@ -71,6 +72,9 @@ public:
     }
 
     void skip(uint32_t size) {
+        if (TINS_UNLIKELY(size > size_)) {
+            throw malformed_packet();
+        }
         buffer_ += size;
         size_ -= size;
     }
@@ -86,6 +90,16 @@ public:
         return output;
     }
 
+    template <typename T>
+    T read_le() {
+        return Endian::le_to_host(read<T>());
+    }
+
+    template <typename T>
+    T read_be() {
+        return Endian::be_to_host(read<T>());
+    }
+
     template <typename T>
     void read(T& value) {
         if (!can_read(sizeof(value))) {
@@ -95,6 +109,14 @@ public:
         skip(sizeof(value));
     }
 
+    void read(std::vector<uint8_t>& value, size_t count) {
+        if (!can_read(count)) {
+            throw malformed_packet();
+        }
+        value.assign(pointer(), pointer() + count);
+        skip(count);
+    }
+
     void read(IPv4Address& address) {
         address = IPv4Address(read<uint32_t>());
     }
@@ -150,7 +172,14 @@ public:
     : buffer_(buffer), size_(total_sz) {
     }
 
+    OutputMemoryStream(std::vector<uint8_t>& buffer)
+    : buffer_(&buffer[0]), size_(buffer.size()) {
+    }
+
     void skip(uint32_t size) {
+        if (TINS_UNLIKELY(size > size_)) {
+            throw malformed_packet();
+        }
         buffer_ += size;
         size_ -= size;
     }
@@ -164,6 +193,16 @@ public:
         skip(sizeof(value));
     }
 
+    template <typename T>
+    void write_be(const T& value) {
+        write(Endian::host_to_be(value));
+    }
+
+    template <typename T>
+    void write_le(const T& value) {
+        write(Endian::host_to_le(value));
+    }
+
     template <typename ForwardIterator>
     void write(ForwardIterator start, ForwardIterator end) {
         const uint32_t length = std::distance(start, end); 
diff --git a/include/tins/mpls.h b/include/tins/mpls.h
index d81d3b8..525f301 100644
--- a/include/tins/mpls.h
+++ b/include/tins/mpls.h
@@ -128,12 +128,14 @@ public:
      * \brief Getter for the PDU's type.
      * \sa PDU::pdu_type
      */
-    PDUType pdu_type() const { return pdu_flag; }
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
 
     /**
      * \sa PDU::clone
      */
-    MPLS *clone() const {
+    MPLS* clone() const {
         return new MPLS(*this);
     }
 private:
@@ -144,7 +146,7 @@ private:
         uint8_t ttl;
     } TINS_END_PACK;
 
-    void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
 
     mpls_header header_;
 };
diff --git a/include/tins/network_interface.h b/include/tins/network_interface.h
index e129f5d..701e64b 100644
--- a/include/tins/network_interface.h
+++ b/include/tins/network_interface.h
@@ -38,6 +38,7 @@
 #include "ip_address.h"
 
 namespace Tins {
+
 /**
  * \class NetworkInterface
  * \brief Abstraction of a network interface
@@ -89,14 +90,14 @@ public:
      * 
      * \param name The name of the interface this object will abstract.
      */
-    NetworkInterface(const std::string &name);
+    NetworkInterface(const std::string& name);
     
     /**
      * \brief Constructor from const char*.
      * 
      * \param name The name of the interface this object will abstract.
      */
-    NetworkInterface(const char *name);
+    NetworkInterface(const char* name);
     
     /**
      * \brief Constructs a NetworkInterface from an ip address.
@@ -114,7 +115,7 @@ public:
      * \return id_type containing the identifier.
      */
     id_type id() const {
-        return iface_id;
+        return iface_id_;
     }
     
     /**
@@ -153,7 +154,7 @@ public:
      * default constructor. 
      */
     operator bool() const {
-        return iface_id != 0;
+        return iface_id_ != 0;
     }
 
     /**
@@ -175,8 +176,8 @@ public:
      * 
      * \param rhs The interface being compared.
      */
-    bool operator==(const NetworkInterface &rhs) const {
-        return iface_id == rhs.iface_id;
+    bool operator==(const NetworkInterface& rhs) const {
+        return iface_id_ == rhs.iface_id_;
     }
     
     /**
@@ -184,13 +185,15 @@ public:
      * 
      * \param rhs The interface being compared.
      */
-    bool operator!=(const NetworkInterface &rhs) const {
+    bool operator!=(const NetworkInterface& rhs) const {
         return !(*this == rhs);
     }
 private:
-    id_type resolve_index(const char *name);
+    id_type resolve_index(const char* name);
 
-    id_type iface_id;
+    id_type iface_id_;
 };
-}
+
+} // Tins
+
 #endif // TINS_NETWORK_INTERFACE_H
diff --git a/include/tins/offline_packet_filter.h b/include/tins/offline_packet_filter.h
index d7ebd84..fc0ca8f 100644
--- a/include/tins/offline_packet_filter.h
+++ b/include/tins/offline_packet_filter.h
@@ -36,6 +36,7 @@
 #include "macros.h"
 
 namespace Tins {
+
 class PDU;
 
 /**
@@ -85,10 +86,10 @@ public:
      * \param snap_len The snapshot length to use.
      */
     template<typename T>
-    OfflinePacketFilter(const std::string& filter, const DataLinkType<T>& lt,
-        unsigned int snap_len = 65535)
-    : string_filter(filter)
-    {
+    OfflinePacketFilter(const std::string& filter, 
+                        const DataLinkType<T>& lt,
+                        unsigned int snap_len = 65535)
+    : string_filter_(filter) {
         init(filter, lt.get_type(), snap_len);
     }
 
@@ -149,9 +150,9 @@ private:
         unsigned int snap_len);
 
 
-    pcap_t* handle;
-    mutable bpf_program filter;
-    std::string string_filter;
+    pcap_t* handle_;
+    mutable bpf_program filter_;
+    std::string string_filter_;
 };
 } // Tins
 
diff --git a/include/tins/packet.h b/include/tins/packet.h
index fbe229e..f7be3a0 100644
--- a/include/tins/packet.h
+++ b/include/tins/packet.h
@@ -39,6 +39,7 @@
  * \namespace Tins
  */
 namespace Tins {
+
 template<typename WrappedType, typename TimestampType>
 class PacketWrapper;
 
@@ -101,20 +102,20 @@ public:
      * This is the timestamp in which the packet was taken out of the
      * network interface/pcap file.
      */
-    const Timestamp &timestamp() const {
+    const Timestamp& timestamp() const {
         return ts_;
     }
 private:
     friend class BaseSniffer;
     friend class SnifferIterator;
     
-    PacketWrapper(pdu_type pdu, const Timestamp &ts) 
+    PacketWrapper(pdu_type pdu, const Timestamp& ts) 
     : pdu_(pdu), ts_(ts) {}
     
     PacketWrapper(const PacketWrapper&);
     PacketWrapper& operator=(const PacketWrapper&);
     void* operator new (size_t size);
-    void operator delete (void *p);
+    void operator delete (void* p);
 
     pdu_type pdu_;
     timestamp_type ts_;
@@ -149,8 +150,8 @@ public:
      * 
      * The PDU* is cloned using PDU::clone.
      */
-    Packet(const PDU *apdu, const Timestamp &tstamp) 
-    : pdu_(apdu->clone()), ts(tstamp) { }
+    Packet(const PDU* apdu, const Timestamp& tstamp) 
+    : pdu_(apdu->clone()), ts_(tstamp) { }
 
     /**
      * \brief Constructs a Packet from a PDU* and a Timestamp.
@@ -160,8 +161,8 @@ public:
      * will be done automatically by the Packet when it goes out
      * of scope.
      */
-    Packet(PDU *apdu, const Timestamp &tstamp, own_pdu) 
-    : pdu_(apdu), ts(tstamp) { }
+    Packet(PDU* apdu, const Timestamp& tstamp, own_pdu) 
+    : pdu_(apdu), ts_(tstamp) { }
     
     /**
      * \brief Constructs a Packet from a const PDU&.
@@ -171,8 +172,8 @@ public:
      * This calls PDU::clone on the PDU parameter.
      * 
      */
-    Packet(const PDU &rhs) 
-    : pdu_(rhs.clone()), ts(Timestamp::current_time()) { }
+    Packet(const PDU& rhs) 
+    : pdu_(rhs.clone()), ts_(Timestamp::current_time()) { }
     
     /**
      * \brief Constructs a Packet from a RefPacket.
@@ -180,21 +181,21 @@ public:
      * This calls PDU::clone on the RefPacket's PDU.
      * 
      */
-    Packet(const RefPacket &pck) 
-    : pdu_(pck.pdu().clone()), ts(pck.timestamp()) { }
+    Packet(const RefPacket& pck) 
+    : pdu_(pck.pdu().clone()), ts_(pck.timestamp()) { }
 
     /**
      * \brief Constructs a Packet from a PtrPacket object.
      */
-    Packet(const PtrPacket &pck)
-    : pdu_(pck.pdu()), ts(pck.timestamp()) { }
+    Packet(const PtrPacket& pck)
+    : pdu_(pck.pdu()), ts_(pck.timestamp()) { }
     
     /**
      * \brief Copy constructor.
      * 
      * This calls PDU::clone on the rhs's PDU* member.
      */
-    Packet(const Packet &rhs) : ts(rhs.timestamp()) {
+    Packet(const Packet& rhs) : ts_(rhs.timestamp()) {
         pdu_ = rhs.pdu() ? rhs.pdu()->clone() : 0;
     }
     
@@ -203,20 +204,20 @@ public:
      * 
      * This calls PDU::clone on the rhs's PDU* member.
      */
-    Packet& operator=(const Packet &rhs) {
-        if(this != &rhs) {
+    Packet& operator=(const Packet& rhs) {
+        if (this != &rhs) {
             delete pdu_;
-            ts = rhs.timestamp();
+            ts_ = rhs.timestamp();
             pdu_ = rhs.pdu() ? rhs.pdu()->clone() : 0;
         }
-        return *this;
+        return* this;
     }
     
     #if TINS_IS_CXX11
     /**
      * Move constructor.
      */
-    Packet(Packet &&rhs) TINS_NOEXCEPT : pdu_(rhs.pdu()), ts(rhs.timestamp()) {
+    Packet(Packet &&rhs) TINS_NOEXCEPT : pdu_(rhs.pdu()), ts_(rhs.timestamp()) {
         rhs.pdu_ = nullptr;
     }
     
@@ -224,11 +225,11 @@ public:
      * Move assignment operator.
      */
     Packet& operator=(Packet &&rhs) TINS_NOEXCEPT { 
-        if(this != &rhs) {
+        if (this != &rhs) {
             std::swap(pdu_, rhs.pdu_);
-            ts = rhs.timestamp();
+            ts_ = rhs.timestamp();
         }
-        return *this;
+        return* this;
     }
     #endif
     
@@ -244,8 +245,8 @@ public:
     /**
      * Returns this Packet's timestamp.
      */
-    const Timestamp &timestamp() const {
-        return ts;
+    const Timestamp& timestamp() const {
+        return ts_;
     }
     
     /**
@@ -253,7 +254,7 @@ public:
      * 
      * Caller <b>must not</b> delete the pointer. \sa Packet::release_pdu
      */
-    PDU *pdu() {
+    PDU* pdu() {
         return pdu_;
     }
     
@@ -262,7 +263,7 @@ public:
      * 
      * Caller <b>must not</b> delete the pointer. \sa Packet::release_pdu
      */
-    const PDU *pdu() const {
+    const PDU* pdu() const {
         return pdu_;
     }
     
@@ -275,8 +276,8 @@ public:
      * when Packet's destructor is called, the stored pointer will be 
      * deleted.
      */
-    PDU *release_pdu() {
-        PDU *some_pdu = pdu_;
+    PDU* release_pdu() {
+        PDU* some_pdu = pdu_;
         pdu_ = 0;
         return some_pdu;
     }
@@ -298,13 +299,13 @@ public:
      * 
      * \param rhs The PDU to be appended.
      */
-    Packet &operator/=(const PDU &rhs) {
+    Packet& operator/=(const PDU& rhs) {
         pdu_ /= rhs;
-        return *this;
+        return* this;
     }
 private:
-    PDU *pdu_;
-    Timestamp ts;
+    PDU* pdu_;
+    Timestamp ts_;
 };
 }
 
diff --git a/include/tins/packet_sender.h b/include/tins/packet_sender.h
index cb203fa..80b9453 100644
--- a/include/tins/packet_sender.h
+++ b/include/tins/packet_sender.h
@@ -48,377 +48,382 @@ struct timeval;
 struct sockaddr;
 
 namespace Tins {
-    class PDU;
+
+class PDU;
+
+/**
+ * \class PacketSender
+ * \brief Sends packets through a network interface.
+ *
+ * This class allows sending packets through a network interface.
+ * It can send basically two types of packets:
+ *
+ * - Those that contain a link layer PDU (EthernetII, SLL, etc). These
+ * will be serialized and sent through an interface that has to be 
+ * specified. This can be done by providing it when you call 
+ * PacketSender::send, or set a default one using 
+ * PacketSender::default_interface.
+ * - Those that don't contain a link layer PDU. In this case, the 
+ * kernel will be responsible for picking the appropriate network interface
+ * based on the destination address.
+ *
+ * \par Note for Windows users:
+ * Sending layer 3 PDUs (without a link layer protocol) is very restricted
+ * on Windows (<a href="https://msdn.microsoft.com/en-us/library/windows/desktop/ms740548(v=vs.85).aspx">link</a>).
+ * Therefore it's recommended you always send packets which contain link layer PDUs.
+ * This will use Winpcap's pcap_sendpacket to inject the packets.
+ *
+ * Sending packets can be done via PacketSender::send:
+ *
+ * \code
+ * // Construct a packet which uses an EthernetII link layer.
+ * EthernetII pkt1 = ...;
+ *
+ * // Construct a packet sender, which we'll use to send packets.
+ * PacketSender sender;
+ * 
+ * // Send it through interface eth0
+ * sender.send(pkt1, "eth0");
+ *
+ * // Set the default interface to eth0
+ * sender.default_interface("eth0");
+ * 
+ * // This is now equivalent to the previous send.
+ * sender.send(pkt1);
+ *
+ * // Construct a packet which has no link layer protocol.
+ * IP ip = IP("192.168.0.1") / TCP(22, 928);
+ *
+ * // Here the kernel will figure out which interface to use and it will
+ * // append the appropriate link layer protocol PDU. It will also perform
+ * // the necessary ARP lookups in order to use the destination host's
+ * // hardware address.
+ * //
+ * // libtins will find which is the appropriate source IP address to use.
+ * // This will be done by the kernel as well, but it's required when 
+ * // calculating checksums.
+ * sender.send(ip);
+ * \endcode
+ *
+ * PacketSender also supports sending a packet and waiting for a response.
+ * This can be done by using PacketSender::send_recv.
+ *
+ * This class opens sockets as it needs to, and closes them when the object
+ * is destructed.
+ *
+ * \sa PacketSender::send
+ * \sa PacketSender::send_recv
+ */
+class TINS_API PacketSender {
+public:
+    /** 
+     * The default timeout for receive actions.
+     */
+    static const uint32_t DEFAULT_TIMEOUT;
+
+    /** 
+     * Flags to indicate the socket type.
+     */
+    enum SocketType {
+        ETHER_SOCKET,
+        IP_TCP_SOCKET,
+        IP_UDP_SOCKET,
+        IP_RAW_SOCKET,
+        ARP_SOCKET,
+        ICMP_SOCKET,
+        IPV6_SOCKET,
+        SOCKETS_END
+    };
+
+    /**
+     * \brief Constructor for PacketSender objects.
+     * 
+     * \param iface The default interface in which to send the packets.
+     * \param recv_timeout The timeout which will be used when receiving responses.
+     */
+    PacketSender(const NetworkInterface& iface = NetworkInterface(),
+                 uint32_t recv_timeout = DEFAULT_TIMEOUT,
+                 uint32_t usec = 0);
+    
+    #if TINS_IS_CXX11
+        /**
+         * \brief Move constructor.
+         * \param rhs The sender to be moved.
+         */
+        PacketSender(PacketSender &&rhs) TINS_NOEXCEPT {
+            *this = std::move(rhs);
+        }
+        
+        /**
+         * \brief Move assignment operator.
+         * \param rhs The sender to be moved.
+         */
+        PacketSender& operator=(PacketSender &&rhs) TINS_NOEXCEPT {
+            sockets_ = std::move(rhs.sockets_);
+            rhs.sockets_ = std::vector<int>(SOCKETS_END, INVALID_RAW_SOCKET);
+            #ifndef _WIN32
+                #if defined(BSD) || defined(__FreeBSD_kernel__)
+                ether_socket_ = std::move(rhs.ether_socket_);
+                #else
+                ether_socket_ = rhs.ether_socket_;
+                rhs.ether_socket_ = INVALID_RAW_SOCKET;
+                #endif
+            #endif
+            types_ = rhs.types_; // no move
+            _timeout = rhs._timeout;
+            timeout_usec_ = rhs.timeout_usec_;
+            default_iface_ = rhs.default_iface_;
+            return* this;
+        }
+    #endif
+    
+    /** 
+     * \brief PacketSender destructor.
+     * 
+     * This gracefully closes all open sockets.
+     */
+    ~PacketSender();
+
+    #if !defined(_WIN32) || defined(HAVE_PACKET_SENDER_PCAP_SENDPACKET)
+    /** 
+     * \brief Opens a layer 2 socket.
+     * 
+     * If this operation fails, then a socket_open_error will be thrown.
+     */
+    void open_l2_socket(const NetworkInterface& iface = NetworkInterface());
+    #endif // !_WIN32 || defined(HAVE_PACKET_SENDER_PCAP_SENDPACKET)
+
+    /** 
+     * \brief Opens a layer 3 socket, using the corresponding protocol
+     * for the given flag.
+     * 
+     * If this operation fails, then a socket_open_error will be thrown.
+     * If the provided socket type is not valid, an invalid_socket_type
+     * exception will be throw.
+     * 
+     * \param type The type of socket which will be used to pick the protocol flag
+     * for this socket.
+     */
+    void open_l3_socket(SocketType type);
+
+    /** 
+     * \brief Closes the socket associated with the given flag.
+     * 
+     * If the provided type is invalid, meaning no such open socket
+     * exists, an invalid_socket_type exception is thrown.
+     * 
+     * If any socket close errors are encountered, a socket_close_error
+     * is thrown.
+     * 
+     * \param type The type of the socket to be closed.
+     */
+    void close_socket(SocketType type, const NetworkInterface& iface = NetworkInterface());
+
+    /**
+     * \brief Sets the default interface.
+     * 
+     * The interface will be used whenever PacketSender::send(PDU&) 
+     * is called.
+     */
+    void default_interface(const NetworkInterface& iface);
     
     /**
-     * \class PacketSender
-     * \brief Sends packets through a network interface.
-     *
-     * This class allows sending packets through a network interface.
-     * It can send basically two types of packets:
-     *
-     * - Those that contain a link layer PDU (EthernetII, SLL, etc). These
-     * will be serialized and sent through an interface that has to be 
-     * specified. This can be done by providing it when you call 
-     * PacketSender::send, or set a default one using 
-     * PacketSender::default_interface.
-     * - Those that don't contain a link layer PDU. In this case, the 
-     * kernel will be responsible for picking the appropriate network interface
-     * based on the destination address.
-     *
-     * \par Note for Windows users:
-     * Sending layer 3 PDUs (without a link layer protocol) is very restricted
-     * on Windows (<a href="https://msdn.microsoft.com/en-us/library/windows/desktop/ms740548(v=vs.85).aspx">link</a>).
-     * Therefore it's recommended you always send packets which contain link layer PDUs.
-     * This will use Winpcap's pcap_sendpacket to inject the packets.
-     *
-     * Sending packets can be done via PacketSender::send:
-     *
-     * \code
-     * // Construct a packet which uses an EthernetII link layer.
-     * EthernetII pkt1 = ...;
-     *
-     * // Construct a packet sender, which we'll use to send packets.
-     * PacketSender sender;
+     * \brief Gets the default interface.
      * 
-     * // Send it through interface eth0
-     * sender.send(pkt1, "eth0");
-     *
-     * // Set the default interface to eth0
-     * sender.default_interface("eth0");
-     * 
-     * // This is now equivalent to the previous send.
-     * sender.send(pkt1);
-     *
-     * // Construct a packet which has no link layer protocol.
-     * IP ip = IP("192.168.0.1") / TCP(22, 928);
-     *
-     * // Here the kernel will figure out which interface to use and it will
-     * // append the appropriate link layer protocol PDU. It will also perform
-     * // the necessary ARP lookups in order to use the destination host's
-     * // hardware address.
-     * //
-     * // libtins will find which is the appropriate source IP address to use.
-     * // This will be done by the kernel as well, but it's required when 
-     * // calculating checksums.
-     * sender.send(ip);
-     * \endcode
-     *
-     * PacketSender also supports sending a packet and waiting for a response.
-     * This can be done by using PacketSender::send_recv.
-     *
-     * This class opens sockets as it needs to, and closes them when the object
-     * is destructed.
-     *
-     * \sa PacketSender::send
-     * \sa PacketSender::send_recv
+     * \sa PacketSender::default_interface
      */
-    class TINS_API PacketSender {
-    public:
-        /** 
-         * The default timeout for receive actions.
-         */
-        static const uint32_t DEFAULT_TIMEOUT;
+    const NetworkInterface& default_interface() const;
+
+    /** 
+     * \brief Sends a PDU. 
+     * 
+     * This method opens the appropriate socket, if it's not open yet, 
+     * and sends the PDU on the open socket.
+     * 
+     * If any send error occurs, then a socket_write_error is thrown.
+     * 
+     * If the PDU contains a link layer protocol, then default_interface
+     * is used.
+     * 
+     * \sa PacketSender::default_interface
+     * 
+     * \param pdu The PDU to be sent.
+     */
+    void send(PDU& pdu);
     
-        /** 
-         * Flags to indicate the socket type.
-         */
-        enum SocketType {
-            ETHER_SOCKET,
-            IP_TCP_SOCKET,
-            IP_UDP_SOCKET,
-            IP_RAW_SOCKET,
-            ARP_SOCKET,
-            ICMP_SOCKET,
-            IPV6_SOCKET,
-            SOCKETS_END
-        };
+    /** 
+     * \brief Sends a PDU. 
+     * 
+     * \sa PacketSender::send
+     * 
+     * This overload takes a NetworkInterface. The packet is sent
+     * through that interface if a link-layer PDU is present, 
+     * otherwise this call is equivalent to send(PDU&).
+     * 
+     * The interface stored in the link layer PDU(if any), is restored
+     * after this method ends.
+     * 
+     * \param pdu The PDU to be sent.
+     * \param iface The network interface to use.
+     */
+    void send(PDU& pdu, const NetworkInterface& iface);
 
-        /**
-         * \brief Constructor for PacketSender objects.
-         * 
-         * \param iface The default interface in which to send the packets.
-         * \param recv_timeout The timeout which will be used when receiving responses.
-         */
-        PacketSender(const NetworkInterface &iface = NetworkInterface(), 
-          uint32_t recv_timeout = DEFAULT_TIMEOUT, uint32_t usec = 0);
-        
-        #if TINS_IS_CXX11
-            /**
-             * \brief Move constructor.
-             * \param rhs The sender to be moved.
-             */
-            PacketSender(PacketSender &&rhs) TINS_NOEXCEPT {
-                *this = std::move(rhs);
-            }
-            
-            /**
-             * \brief Move assignment operator.
-             * \param rhs The sender to be moved.
-             */
-            PacketSender& operator=(PacketSender &&rhs) TINS_NOEXCEPT {
-                _sockets = std::move(rhs._sockets);
-                rhs._sockets = std::vector<int>(SOCKETS_END, INVALID_RAW_SOCKET);
-                #ifndef _WIN32
-                    #if defined(BSD) || defined(__FreeBSD_kernel__)
-                    _ether_socket = std::move(rhs._ether_socket);
-                    #else
-                    _ether_socket = rhs._ether_socket;
-                    rhs._ether_socket = INVALID_RAW_SOCKET;
-                    #endif
-                #endif
-                _types = rhs._types; // no move
-                _timeout = rhs._timeout;
-                _timeout_usec = rhs._timeout_usec;
-                default_iface = rhs.default_iface;
-                return *this;
-            }
-        #endif
-        
-        /** 
-         * \brief PacketSender destructor.
-         * 
-         * This gracefully closes all open sockets.
-         */
-        ~PacketSender();
+    /** 
+     * \brief Sends a PDU and waits for its response. 
+     * 
+     * This method is used to send PDUs and receive their response. 
+     * The packet is sent, and then a response is awaited. 
+     * PDU::matches_pdu is called on the packet sent in order to
+     * check whether a packet received is a response. 
+     *
+     * This will match every response to a packet. For example,
+     * if you send a TCP packet, any response matching the same
+     * IP addresses and ports will be taken as a response to it.
+     * This also happens for other protocols, such as ARP, ICMP, 
+     * DHCP, DNS, IP, etc.
+     *
+     * If you send a packet and get an ICMP response indicating
+     * an error (such as host unreachable, ttl exceeded, etc),
+     * that packet will be considered a response.
+     * 
+     * \param pdu The PDU to send.
+     * \return Returns the response PDU, 0 if not response was received.
+     */
+    PDU* send_recv(PDU& pdu);
+    
+    /** 
+     * \brief Sends a PDU and waits for its response. 
+     *
+     * Sends a packet and receives a response. This overload takes 
+     * a NetworkInterface. 
+     * 
+     * \sa PacketSender::send_recv(PDU&);
+     * \param pdu The PDU to send.
+     * \param iface The network interface in which to send and receive.
+     * \return Returns the response PDU, 0 if not response was received.
+     */
+    PDU* send_recv(PDU& pdu, const NetworkInterface& iface);
 
-        #if !defined(_WIN32) || defined(HAVE_PACKET_SENDER_PCAP_SENDPACKET)
-        /** 
-         * \brief Opens a layer 2 socket.
-         * 
-         * If this operation fails, then a socket_open_error will be thrown.
-         */
-        void open_l2_socket(const NetworkInterface& iface = NetworkInterface());
-        #endif // !_WIN32 || defined(HAVE_PACKET_SENDER_PCAP_SENDPACKET)
+    #ifndef _WIN32
+    /** 
+     * \brief Receives a layer 2 PDU response to a previously sent PDU.
+     *
+     * This method is used internally. You should just use PacketSender::send_recv.
+     * 
+     * This PacketSender will receive data from a raw socket, open using 
+     * the corresponding flag, according to the given type of protocol, until 
+     * a match for the given PDU is received. 
+     * 
+     * \param pdu The PDU which will try to match the responses.
+     * \param link_addr The sockaddr struct which will be used to receive the PDU.
+     * \param len_addr The sockaddr struct length.
+     * \return Returns the response PDU. If no response is received, then 0 is returned.
+     */
+    PDU* recv_l2(PDU& pdu, struct sockaddr* link_addr, uint32_t len_addr,
+      const NetworkInterface& iface = NetworkInterface());
 
-        /** 
-         * \brief Opens a layer 3 socket, using the corresponding protocol
-         * for the given flag.
-         * 
-         * If this operation fails, then a socket_open_error will be thrown.
-         * If the provided socket type is not valid, an invalid_socket_type
-         * exception will be throw.
-         * 
-         * \param type The type of socket which will be used to pick the protocol flag
-         * for this socket.
-         */
-        void open_l3_socket(SocketType type);
+    #endif // _WIN32
 
-        /** 
-         * \brief Closes the socket associated with the given flag.
-         * 
-         * If the provided type is invalid, meaning no such open socket
-         * exists, an invalid_socket_type exception is thrown.
-         * 
-         * If any socket close errors are encountered, a socket_close_error
-         * is thrown.
-         * 
-         * \param type The type of the socket to be closed.
-         */
-        void close_socket(SocketType type, const NetworkInterface &iface = NetworkInterface());
+    #if !defined(_WIN32) || defined(HAVE_PACKET_SENDER_PCAP_SENDPACKET)
+    /** 
+     * \brief Sends a level 2 PDU.
+     *
+     * This method is used internally. You should just use PacketSender::send.
+     * 
+     * This method sends a layer 2 PDU, using a raw socket, open 
+     * using the corresponding flag, according to the given type of 
+     * protocol. 
+     * 
+     * If any socket write error occurs, a socket_write_error is thrown.
+     * 
+     * \param pdu The PDU to send.
+     * \param link_addr The sockaddr struct which will be used to send the PDU.
+     * \param len_addr The sockaddr struct length.
+     */
+    void send_l2(PDU& pdu, struct sockaddr* link_addr, uint32_t len_addr, 
+      const NetworkInterface& iface = NetworkInterface());
+    #endif // !_WIN32 || HAVE_PACKET_SENDER_PCAP_SENDPACKET
 
-        /**
-         * \brief Sets the default interface.
-         * 
-         * The interface will be used whenever PacketSender::send(PDU&) 
-         * is called.
-         */
-        void default_interface(const NetworkInterface &iface);
-        
-        /**
-         * \brief Gets the default interface.
-         * 
-         * \sa PacketSender::default_interface
-         */
-        const NetworkInterface& default_interface() const;
+    /** 
+     * \brief Receives a layer 3 PDU response to a previously sent PDU.
+     *
+     * This method is used internally. You should just use PacketSender::send_recv.
+     * 
+     * This PacketSender will receive data from a raw socket, open using the corresponding flag,
+     * according to the given type of protocol, until a match for the given PDU is received. 
+     * 
+     * \param pdu The PDU which will try to match the responses.
+     * \param link_addr The sockaddr struct which will be used to receive the PDU.
+     * \param len_addr The sockaddr struct length.
+     * \param type The socket protocol type.
+     * \return Returns the response PDU. If no response is received, then 0 is returned.
+     */
+    PDU* recv_l3(PDU& pdu, struct sockaddr* link_addr, uint32_t len_addr, SocketType type);
 
-        /** 
-         * \brief Sends a PDU. 
-         * 
-         * This method opens the appropriate socket, if it's not open yet, 
-         * and sends the PDU on the open socket.
-         * 
-         * If any send error occurs, then a socket_write_error is thrown.
-         * 
-         * If the PDU contains a link layer protocol, then default_interface
-         * is used.
-         * 
-         * \sa PacketSender::default_interface
-         * 
-         * \param pdu The PDU to be sent.
-         */
-        void send(PDU &pdu);
-        
-        /** 
-         * \brief Sends a PDU. 
-         * 
-         * \sa PacketSender::send
-         * 
-         * This overload takes a NetworkInterface. The packet is sent
-         * through that interface if a link-layer PDU is present, 
-         * otherwise this call is equivalent to send(PDU&).
-         * 
-         * The interface stored in the link layer PDU(if any), is restored
-         * after this method ends.
-         * 
-         * \param pdu The PDU to be sent.
-         * \param iface The network interface to use.
-         */
-        void send(PDU &pdu, const NetworkInterface &iface);
+    /** 
+     * \brief Sends a level 3 PDU.
+     *
+     * This method is used internally. You should just use PacketSender::send.
+     * 
+     * This method sends a layer 3 PDU, using a raw socket, open using the corresponding flag,
+     * according to the given type of protocol.
+     * 
+     * If any socket write error occurs, a socket_write_error is thrown.
+     * 
+     * \param pdu The PDU to send.
+     * \param link_addr The sockaddr struct which will be used to send the PDU.
+     * \param len_addr The sockaddr struct length.
+     * \param type The socket protocol type.
+     */
+    void send_l3(PDU& pdu, struct sockaddr* link_addr, uint32_t len_addr, SocketType type);
+private:
+    static const int INVALID_RAW_SOCKET;
 
-        /** 
-         * \brief Sends a PDU and waits for its response. 
-         * 
-         * This method is used to send PDUs and receive their response. 
-         * The packet is sent, and then a response is awaited. 
-         * PDU::matches_pdu is called on the packet sent in order to
-         * check whether a packet received is a response. 
-         *
-         * This will match every response to a packet. For example,
-         * if you send a TCP packet, any response matching the same
-         * IP addresses and ports will be taken as a response to it.
-         * This also happens for other protocols, such as ARP, ICMP, 
-         * DHCP, DNS, IP, etc.
-         *
-         * If you send a packet and get an ICMP response indicating
-         * an error (such as host unreachable, ttl exceeded, etc),
-         * that packet will be considered a response.
-         * 
-         * \param pdu The PDU to send.
-         * \return Returns the response PDU, 0 if not response was received.
-         */
-        PDU *send_recv(PDU &pdu);
-        
-        /** 
-         * \brief Sends a PDU and waits for its response. 
-         *
-         * Sends a packet and receives a response. This overload takes 
-         * a NetworkInterface. 
-         * 
-         * \sa PacketSender::send_recv(PDU&);
-         * \param pdu The PDU to send.
-         * \param iface The network interface in which to send and receive.
-         * \return Returns the response PDU, 0 if not response was received.
-         */
-        PDU *send_recv(PDU &pdu, const NetworkInterface &iface);
+    typedef std::map<SocketType, int> SocketTypeMap;
 
-        #ifndef _WIN32
-        /** 
-         * \brief Receives a layer 2 PDU response to a previously sent PDU.
-         *
-         * This method is used internally. You should just use PacketSender::send_recv.
-         * 
-         * This PacketSender will receive data from a raw socket, open using 
-         * the corresponding flag, according to the given type of protocol, until 
-         * a match for the given PDU is received. 
-         * 
-         * \param pdu The PDU which will try to match the responses.
-         * \param link_addr The sockaddr struct which will be used to receive the PDU.
-         * \param len_addr The sockaddr struct length.
-         * \return Returns the response PDU. If no response is received, then 0 is returned.
-         */
-        PDU *recv_l2(PDU &pdu, struct sockaddr *link_addr, uint32_t len_addr,
-          const NetworkInterface &iface = NetworkInterface());
+    PacketSender(const PacketSender&);
+    PacketSender& operator=(const PacketSender&);
+    int find_type(SocketType type);
+    int timeval_subtract (struct timeval* result, struct timeval* x, struct timeval* y);
+    #ifndef _WIN32
+        bool ether_socket_initialized(const NetworkInterface& iface = NetworkInterface()) const;
+        int getether_socket_(const NetworkInterface& iface = NetworkInterface());
+    #endif
+    template<typename T>
+    void send(PDU& pdu, const NetworkInterface& iface) {
+        static_cast<T&>(pdu).send(*this, iface);
+    }
+    #ifdef HAVE_PACKET_SENDER_PCAP_SENDPACKET
+        pcap_t* make_pcap_handle(const NetworkInterface& iface) const;
+    #endif // HAVE_PACKET_SENDER_PCAP_SENDPACKET
+    
+    PDU* recv_match_loop(const std::vector<int>& sockets, 
+                         PDU& pdu,
+                         struct sockaddr* link_addr, 
+                         uint32_t addrlen);
 
-        #endif // _WIN32
-
-        #if !defined(_WIN32) || defined(HAVE_PACKET_SENDER_PCAP_SENDPACKET)
-        /** 
-         * \brief Sends a level 2 PDU.
-         *
-         * This method is used internally. You should just use PacketSender::send.
-         * 
-         * This method sends a layer 2 PDU, using a raw socket, open 
-         * using the corresponding flag, according to the given type of 
-         * protocol. 
-         * 
-         * If any socket write error occurs, a socket_write_error is thrown.
-         * 
-         * \param pdu The PDU to send.
-         * \param link_addr The sockaddr struct which will be used to send the PDU.
-         * \param len_addr The sockaddr struct length.
-         */
-        void send_l2(PDU &pdu, struct sockaddr* link_addr, uint32_t len_addr, 
-          const NetworkInterface &iface = NetworkInterface());
-        #endif // !_WIN32 || HAVE_PACKET_SENDER_PCAP_SENDPACKET
-
-        /** 
-         * \brief Receives a layer 3 PDU response to a previously sent PDU.
-         *
-         * This method is used internally. You should just use PacketSender::send_recv.
-         * 
-         * This PacketSender will receive data from a raw socket, open using the corresponding flag,
-         * according to the given type of protocol, until a match for the given PDU is received. 
-         * 
-         * \param pdu The PDU which will try to match the responses.
-         * \param link_addr The sockaddr struct which will be used to receive the PDU.
-         * \param len_addr The sockaddr struct length.
-         * \param type The socket protocol type.
-         * \return Returns the response PDU. If no response is received, then 0 is returned.
-         */
-        PDU *recv_l3(PDU &pdu, struct sockaddr *link_addr, uint32_t len_addr, SocketType type);
-
-        /** 
-         * \brief Sends a level 3 PDU.
-         *
-         * This method is used internally. You should just use PacketSender::send.
-         * 
-         * This method sends a layer 3 PDU, using a raw socket, open using the corresponding flag,
-         * according to the given type of protocol.
-         * 
-         * If any socket write error occurs, a socket_write_error is thrown.
-         * 
-         * \param pdu The PDU to send.
-         * \param link_addr The sockaddr struct which will be used to send the PDU.
-         * \param len_addr The sockaddr struct length.
-         * \param type The socket protocol type.
-         */
-        void send_l3(PDU &pdu, struct sockaddr *link_addr, uint32_t len_addr, SocketType type);
-    private:
-        static const int INVALID_RAW_SOCKET;
-
-        typedef std::map<SocketType, int> SocketTypeMap;
-
-        PacketSender(const PacketSender&);
-        PacketSender& operator=(const PacketSender&);
-        int find_type(SocketType type);
-        int timeval_subtract (struct timeval *result, struct timeval *x, struct timeval *y);
-        #ifndef _WIN32
-            bool ether_socket_initialized(const NetworkInterface& iface = NetworkInterface()) const;
-            int get_ether_socket(const NetworkInterface& iface = NetworkInterface());
-        #endif
-        template<typename T>
-        void send(PDU &pdu, const NetworkInterface &iface) {
-            static_cast<T&>(pdu).send(*this, iface);
-        }
-        #ifdef HAVE_PACKET_SENDER_PCAP_SENDPACKET
-            pcap_t* make_pcap_handle(const NetworkInterface& iface) const;
-        #endif // HAVE_PACKET_SENDER_PCAP_SENDPACKET
-        
-        PDU *recv_match_loop(const std::vector<int>& sockets, PDU &pdu, struct sockaddr* link_addr, 
-            uint32_t addrlen);
-
-        std::vector<int> _sockets;
-        #ifndef _WIN32
-            #if defined(BSD) || defined(__FreeBSD_kernel__)
-            typedef std::map<uint32_t, int> BSDEtherSockets;
-            BSDEtherSockets _ether_socket;
-            #else
-            int _ether_socket;
-            #endif
-        #endif
-        SocketTypeMap _types;
-        uint32_t _timeout, _timeout_usec;
-        NetworkInterface default_iface;
-        // In BSD we need to store the buffer size, retrieved using BIOCGBLEN
+    std::vector<int> sockets_;
+    #ifndef _WIN32
         #if defined(BSD) || defined(__FreeBSD_kernel__)
-        int buffer_size;
-        #endif // BSD
-        #ifdef HAVE_PACKET_SENDER_PCAP_SENDPACKET
-            typedef std::map<NetworkInterface, pcap_t*> PcapHandleMap; 
-            PcapHandleMap pcap_handles;
-        #endif // HAVE_PACKET_SENDER_PCAP_SENDPACKET
-    };
-}
+        typedef std::map<uint32_t, int> BSDEtherSockets;
+        BSDEtherSockets ether_socket_;
+        #else
+        int ether_socket_;
+        #endif
+    #endif
+    SocketTypeMap types_;
+    uint32_t _timeout, timeout_usec_;
+    NetworkInterface default_iface_;
+    // In BSD we need to store the buffer size, retrieved using BIOCGBLEN
+    #if defined(BSD) || defined(__FreeBSD_kernel__)
+    int buffer_size_;
+    #endif // BSD
+    #ifdef HAVE_PACKET_SENDER_PCAP_SENDPACKET
+        typedef std::map<NetworkInterface, pcap_t*> PcapHandleMap; 
+        PcapHandleMap pcap_handles_;
+    #endif // HAVE_PACKET_SENDER_PCAP_SENDPACKET
+};
+
+} // Tins
 
 #endif // TINS_PACKET_SENDER_H
diff --git a/include/tins/packet_writer.h b/include/tins/packet_writer.h
index 61a8c60..6d8676c 100644
--- a/include/tins/packet_writer.h
+++ b/include/tins/packet_writer.h
@@ -115,8 +115,7 @@ public:
      * \sa PcapIdentifier.
      */
     template<typename T>
-    PacketWriter(const std::string &file_name, const DataLinkType<T>& lt)
-    {
+    PacketWriter(const std::string& file_name, const DataLinkType<T>& lt) {
         init(file_name, lt.get_type());
     }
 
@@ -130,7 +129,7 @@ public:
      * \param lt The link type which will be written to this file.
      * \sa LinkType.
      */
-    PacketWriter(const std::string &file_name, LinkType lt);
+    PacketWriter(const std::string& file_name, LinkType lt);
     
     #if TINS_IS_CXX11
         /**
@@ -154,11 +153,11 @@ public:
          * \param rhs The PacketWriter to be moved.
          */
         PacketWriter& operator=(PacketWriter &&rhs) TINS_NOEXCEPT {
-            handle = 0;
-            dumper = 0;
-            std::swap(handle, rhs.handle);
-            std::swap(dumper, rhs.dumper);
-            return *this;
+            handle_ = 0;
+            dumper_ = 0;
+            std::swap(handle_, rhs.handle_);
+            std::swap(dumper_, rhs.dumper_);
+            return* this;
         }
     #endif
     
@@ -173,7 +172,7 @@ public:
      * \brief Writes a PDU to this file. 
      * \param pdu The PDU to be written.
      */
-    void write(PDU &pdu);
+    void write(PDU& pdu);
 
     /**
      * \brief Writes a Packet to this file. 
@@ -183,7 +182,7 @@ public:
      *
      * \param packet The packet to be written.
      */
-    void write(Packet &packet);
+    void write(Packet& packet);
     
     /**
      * \brief Writes a PDU to this file. 
@@ -193,7 +192,7 @@ public:
      * raw and smart pointers.
      */
     template<typename T>
-    void write(T &pdu) {
+    void write(T& pdu) {
         write(Utils::dereference_until_pdu(pdu));
     }
     
@@ -206,8 +205,9 @@ public:
      */
     template<typename ForwardIterator>
     void write(ForwardIterator start, ForwardIterator end) {
-        while(start != end) 
+        while (start != end) {
             write(Utils::dereference_until_pdu(*start++));
+        }
     }
 private:
     // You shall not copy
@@ -217,8 +217,8 @@ private:
     void init(const std::string& file_name, int link_type);
     void write(PDU& pdu, const struct timeval& tv);
 
-    pcap_t *handle;
-    pcap_dumper_t *dumper; 
+    pcap_t* handle_;
+    pcap_dumper_t* dumper_; 
 };
 }
 
diff --git a/include/tins/pdu.h b/include/tins/pdu.h
index 3a52e0e..b36c457 100644
--- a/include/tins/pdu.h
+++ b/include/tins/pdu.h
@@ -42,514 +42,521 @@
  */
 namespace Tins {
 
-    class PacketSender;
-    class NetworkInterface;
-    
+class PacketSender;
+class NetworkInterface;
+
+/**
+ * The type used to store several PDU option values.
+ */
+typedef std::vector<uint8_t> byte_array;
+
+/** 
+ * \class PDU
+ * \brief Base class for protocol data units.
+ *
+ * Every PDU implementation inherits from this class. 
+ *
+ * PDUs can contain 0 or 1 inner PDU. By stacking several PDUs together,
+ * you can construct packets. These are created upwards: upper layers 
+ * will be children of the lower ones. 
+ *
+ * If you want to find a specific protocol within a PDU chain, you can use
+ * PDU::find_pdu and PDU::rfind_pdu. Both of them take a template parameter
+ * that indicates the PDU type you are looking for. The first one returns a 
+ * pointer to the first object of that type, and the second one returns a 
+ * reference (and throws if it is not found). 
+ * 
+ * For example:
+ *
+ * \code
+ * // Take a whole packet from somewhere.
+ * EthernetII packet = ...;
+ *
+ * // Find the IP layer
+ * const IP* ip = packet.find_pdu<IP>();
+ * if(ip) {
+ *     // If the pointer is not null, then it will point to the IP layer
+ * }
+ *
+ * // Find the TCP layer. This will throw a pdu_not_found exception
+ * // if there is no TCP layer in this packet.
+ * const TCP& tcp = packet.rfind_pdu<TCP>();
+ * \endcode
+ *
+ * PDU objects can be serialized. Serialization converts the entire PDU
+ * stack into a vector of bytes. This process might modify some parameters
+ * on packets depending on which protocols are used in it. For example:
+ *
+ * - If the lowest protocol layer is IP (this means that there is no 
+ * link layer protocol in the packet), then it calculates the source address
+ * that should be used in that IP PDU. \sa IP
+ * - If a protocol contains a checksum field, its value will be calculated
+ * and included in its serialized contents.
+ * - If a protocol contains a "next protocol" field, it is also set based
+ * on the type of the next PDU in the packet.
+ *
+ * If you want to serialize a packet, just use PDU::serialize:
+ *
+ * \code
+ * // Construct a packet
+ * EthernetII packet = EthernetII() / IP() / TCP() / RawPDU("hello");
+ *
+ * // Now serialize it. This is a std::vector<uint8_t>.
+ * PDU::serialization_type buffer = packet.serialize();
+ * \endcode
+ */
+class TINS_API PDU {
+public:
     /**
-     * The type used to store several PDU option values.
+     * The type that will be returned when serializing PDUs.
      */
-    typedef std::vector<uint8_t> byte_array;
+    typedef byte_array serialization_type;
 
-    /** 
-     * \class PDU
-     * \brief Base class for protocol data units.
-     *
-     * Every PDU implementation inherits from this class. 
-     *
-     * PDUs can contain 0 or 1 inner PDU. By stacking several PDUs together,
-     * you can construct packets. These are created upwards: upper layers 
-     * will be children of the lower ones. 
-     *
-     * If you want to find a specific protocol within a PDU chain, you can use
-     * PDU::find_pdu and PDU::rfind_pdu. Both of them take a template parameter
-     * that indicates the PDU type you are looking for. The first one returns a 
-     * pointer to the first object of that type, and the second one returns a 
-     * reference (and throws if it is not found). 
-     * 
-     * For example:
-     *
-     * \code
-     * // Take a whole packet from somewhere.
-     * EthernetII packet = ...;
-     *
-     * // Find the IP layer
-     * const IP* ip = packet.find_pdu<IP>();
-     * if(ip) {
-     *     // If the pointer is not null, then it will point to the IP layer
-     * }
-     *
-     * // Find the TCP layer. This will throw a pdu_not_found exception
-     * // if there is no TCP layer in this packet.
-     * const TCP& tcp = packet.rfind_pdu<TCP>();
-     * \endcode
-     *
-     * PDU objects can be serialized. Serialization converts the entire PDU
-     * stack into a vector of bytes. This process might modify some parameters
-     * on packets depending on which protocols are used in it. For example:
-     *
-     * - If the lowest protocol layer is IP (this means that there is no 
-     * link layer protocol in the packet), then it calculates the source address
-     * that should be used in that IP PDU. \sa IP
-     * - If a protocol contains a checksum field, its value will be calculated
-     * and included in its serialized contents.
-     * - If a protocol contains a "next protocol" field, it is also set based
-     * on the type of the next PDU in the packet.
-     *
-     * If you want to serialize a packet, just use PDU::serialize:
-     *
-     * \code
-     * // Construct a packet
-     * EthernetII packet = EthernetII() / IP() / TCP() / RawPDU("hello");
-     *
-     * // Now serialize it. This is a std::vector<uint8_t>.
-     * PDU::serialization_type buffer = packet.serialize();
-     * \endcode
+    /**
+     * The typep used to identify the endianness of every PDU.
      */
-    class TINS_API PDU {
-    public:
-        /**
-         * The type that will be returned when serializing PDUs.
-         */
-        typedef byte_array serialization_type;
+    enum endian_type {
+        BE,
+        LE
+    };
 
-        /**
-         * The typep used to identify the endianness of every PDU.
-         */
-        enum endian_type {
-            BE,
-            LE
-        };
-
-        /**
-         * \brief Enum which identifies each type of PDU.
-         *
-         * This enum is used to identify the PDU type.
-         */
-        enum PDUType {
-            RAW,
-            ETHERNET_II,
-            IEEE802_3,
-            DOT3 = IEEE802_3,
-            RADIOTAP,
-            DOT11,
-            DOT11_ACK,
-            DOT11_ASSOC_REQ,
-            DOT11_ASSOC_RESP,
-            DOT11_AUTH,
-            DOT11_BEACON,
-            DOT11_BLOCK_ACK,
-            DOT11_BLOCK_ACK_REQ,
-            DOT11_CF_END,
-            DOT11_DATA,
-            DOT11_CONTROL,
-            DOT11_DEAUTH,
-            DOT11_DIASSOC,
-            DOT11_END_CF_ACK,
-            DOT11_MANAGEMENT,
-            DOT11_PROBE_REQ,
-            DOT11_PROBE_RESP,
-            DOT11_PS_POLL,
-            DOT11_REASSOC_REQ,
-            DOT11_REASSOC_RESP,
-            DOT11_RTS,
-            DOT11_QOS_DATA,
-            LLC,
-            SNAP,
-            IP,
-            ARP,
-            TCP,
-            UDP,
-            ICMP,
-            BOOTP,
-            DHCP,
-            EAPOL,
-            RC4EAPOL,
-            RSNEAPOL,
-            DNS,
-            LOOPBACK,
-            IPv6,
-            ICMPv6,
-            SLL,
-            DHCPv6,
-            DOT1Q,
-            PPPOE,
-            STP,
-            PPI,
-            IPSEC_AH,
-            IPSEC_ESP,
-            PKTAP,
-            MPLS,
-            USER_DEFINED_PDU = 1000
-        };
-        
-        /**
-         * The endianness used by this PDU. This can be overriden
-         * by subclasses.
-         */
-        static const endian_type endianness = BE;
-
-        /** 
-         * \brief Default constructor.
-         */
-        PDU();
-        
-        #if TINS_IS_CXX11
-            /**
-             * \brief Move constructor.
-             * 
-             * \param rhs The PDU to be moved.
-             */
-            PDU(PDU &&rhs) TINS_NOEXCEPT 
-            : _inner_pdu(0)
-            {
-                std::swap(_inner_pdu, rhs._inner_pdu);
-            }
-            
-            /**
-             * \brief Move assignment operator.
-             * 
-             * \param rhs The PDU to be moved.
-             */
-            PDU& operator=(PDU &&rhs) TINS_NOEXCEPT {
-                std::swap(_inner_pdu, rhs._inner_pdu);
-                return *this;
-            }
-        #endif
-
-        /** 
-         * \brief PDU destructor.
-         *
-         * Deletes the inner pdu, as a consequence every child pdu is
-         * deleted.
-         */
-        virtual ~PDU();
-
-        /** \brief The header's size
-         */
-        virtual uint32_t header_size() const = 0;
-
-        /** \brief Trailer's size.
-         *
-         * Some protocols require a trailer(like Ethernet). This defaults to 0.
-         */
-        virtual uint32_t trailer_size() const { return 0; }
-
-        /** \brief The whole chain of PDU's size, including this one.
-         *
-         * Returns the sum of this and all children PDUs' size.
-         */
-        uint32_t size() const;
-
-        /**
-         * \brief Getter for the inner PDU.
-         * \return The current inner PDU. Might be 0.
-         */
-        PDU *inner_pdu() const { return _inner_pdu; }
-        
-        /**
-         * \brief Releases the inner PDU.
-         * 
-         * This method makes this PDU to <b>no longer own</b> the inner
-         * PDU. The current inner PDU is returned, and is <b>not</b>
-         * destroyed. That means after calling this function, you are 
-         * responsible for using operator delete on the returned pointer.
-         * 
-         * Use this method if you want to somehow re-use a PDU that
-         * is already owned by another PDU.
-         * 
-         * \return The current inner PDU. Might be 0.
-         */
-        PDU *release_inner_pdu();
-
-        /**
-         * \brief Sets the child PDU.
-         *
-         * When setting a new inner_pdu, the instance takesownership of
-         * the object, therefore deleting it when it's no longer required.
-         * 
-         * \param next_pdu The new child PDU.
-         */
-        void inner_pdu(PDU *next_pdu);
-        
-        /**
-         * \brief Sets the child PDU.
-         *
-         * The PDU parameter is cloned using PDU::clone.
-         * 
-         * \param next_pdu The new child PDU.
-         */
-        void inner_pdu(const PDU &next_pdu);
-
-
-        /** 
-         * \brief Serializes the whole chain of PDU's, including this one.
-         *
-         * This allocates a std::vector of size size(), and fills it
-         * with the serialization this PDU, and all of the inner ones'.
-         * 
-         * \return serialization_type containing the serialization
-         * of the whole stack of PDUs.
-         */
-        serialization_type serialize();
-
-        /**
-         * \brief Finds and returns the first PDU that matches the given flag.
-         *
-         * This method searches for the first PDU which has the same type flag as
-         * the given one. If the first PDU matches that flag, it is returned.
-         * If no PDU matches, 0 is returned.
-         * \param flag The flag which being searched.
-         */
-        template<typename T> 
-        T *find_pdu(PDUType type = T::pdu_flag) {
-            PDU *pdu = this;
-            while(pdu) {
-                if(pdu->matches_flag(type))
-                    return static_cast<T*>(pdu);
-                pdu = pdu->inner_pdu();
-            }
-            return 0;
-        }
-        
-        /**
-         * \brief Finds and returns the first PDU that matches the given flag.
-         *
-         * \param flag The flag which being searched.
-         */
-        template<typename T> 
-        const T *find_pdu(PDUType type = T::pdu_flag) const {
-            return const_cast<PDU*>(this)->find_pdu<T>();
-        }
-
-        /**
-         * \brief Finds and returns the first PDU that matches the given flag.
-         * 
-         * If the PDU is not found, a pdu_not_found exception is thrown.
-         * 
-         * \sa PDU::find_pdu
-         * 
-         * \param flag The flag which being searched.
-         */
-        template<typename T>
-        T &rfind_pdu(PDUType type = T::pdu_flag) {
-            T *ptr = find_pdu<T>(type);
-            if(!ptr)
-                throw pdu_not_found();
-            return *ptr;
-        }
-
-        /**
-         * \brief Finds and returns the first PDU that matches the given flag.
-         *
-         * \param flag The flag which being searched.
-         */
-        template<typename T> 
-        const T &rfind_pdu(PDUType type = T::pdu_flag) const {
-            return const_cast<PDU*>(this)->rfind_pdu<T>();
-        }
-
-        /**
-         * \brief Clones this packet.
-         *
-         * This method clones this PDU and clones every inner PDU,
-         * therefore obtaining a clone of the whole inner PDU chain.
-         * The pointer returned must be deleted by the user.
-         * \return A pointer to a clone of this packet.
-         */
-        virtual PDU *clone() const = 0;
-
-        /** 
-         * \brief Send the stack of PDUs through a PacketSender.
-         *
-         * This method will be called only for the PDU on the bottom of the stack,
-         * therefore it should only implement this method if it can be sent.
-         * 
-         * PacketSender implements specific methods to send packets which start
-         * on every valid TCP/IP stack layer; this should only be a proxy for
-         * those methods.
-         * 
-         * If this PDU does not represent a link layer protocol, then
-         * the interface argument will be ignored.
-         * 
-         * \param sender The PacketSender which will send the packet.
-         * \param iface The network interface in which this packet will 
-         * be sent.
-         */
-        virtual void send(PacketSender &sender, const NetworkInterface &iface);
-
-        /** 
-         * \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.
-         * \param iface The interface in which to expect the response.
-         */
-        virtual PDU *recv_response(PacketSender &sender, const NetworkInterface &iface);
-
-        /** 
-         * \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(const uint8_t *ptr, uint32_t total_sz) const { 
-            return false; 
-        }
-
-        /**
-         * \brief Check wether this PDU matches the specified flag.
-         *
-         * This method should be reimplemented in PDU classes which have
-         * subclasses, and try to match the given PDU to each of its parent
-         * classes' flag.
-         * \param flag The flag to match.
-         */
-        virtual bool matches_flag(PDUType flag) const {
-           return flag == pdu_type();
-        }
-
-        /**
-         * \brief Getter for the PDU's type.
-         *
-         * \return Returns the PDUType corresponding to the PDU.
-         */
-        virtual PDUType pdu_type() const = 0;
-    protected:
-        /**
-         * \brief Copy constructor.
-         */
-        PDU(const PDU &other);
-
-        /**
-         * \brief Copy assignment operator.
-         */
-        PDU &operator=(const PDU &other);
-
-        /**
-         * \brief Copy other PDU's inner PDU(if any).
-         * \param pdu The PDU from which to copy the inner PDU.
-         */
-        void copy_inner_pdu(const PDU &pdu);
-
-        /**
-         * \brief Prepares this PDU for serialization.
-         * 
-         * This method is called before the inner PDUs are serialized.
-         * It's useful in situations such as when serializing IP PDUs,
-         * which don't contain any link layer encapsulation, and therefore
-         * require to set the source IP address before the TCP/UDP checksum
-         * is calculated.
-         * 
-         * By default, this method does nothing
-         * 
-         * \param parent The parent PDU.
-         */
-        virtual void prepare_for_serialize(const PDU *parent) { }
-
-        /** 
-         * \brief Serializes this PDU and propagates this action to child PDUs.
-         *
-         * \param buffer The buffer in which to store this PDU's serialization.
-         * \param total_sz The total size of the buffer.
-         * \param parent The parent PDU. Will be 0 if there's the parent does not exist.
-         */
-        void serialize(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
-
-        /** 
-         * \brief Serializes this TCP PDU.
-         *
-         * Each PDU must override this method and implement it's own
-         * serialization.
-         * \param buffer The buffer in which the PDU will be serialized.
-         * \param total_sz The size available in the buffer.
-         * \param parent The PDU that's one level below this one on the stack. Might be 0.
-         */
-        virtual void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent) = 0;
-    private:
-        PDU *_inner_pdu;
+    /**
+     * \brief Enum which identifies each type of PDU.
+     *
+     * This enum is used to identify the PDU type.
+     */
+    enum PDUType {
+        RAW,
+        ETHERNET_II,
+        IEEE802_3,
+        DOT3 = IEEE802_3,
+        RADIOTAP,
+        DOT11,
+        DOT11_ACK,
+        DOT11_ASSOC_REQ,
+        DOT11_ASSOC_RESP,
+        DOT11_AUTH,
+        DOT11_BEACON,
+        DOT11_BLOCK_ACK,
+        DOT11_BLOCK_ACK_REQ,
+        DOT11_CF_END,
+        DOT11_DATA,
+        DOT11_CONTROL,
+        DOT11_DEAUTH,
+        DOT11_DIASSOC,
+        DOT11_END_CF_ACK,
+        DOT11_MANAGEMENT,
+        DOT11_PROBE_REQ,
+        DOT11_PROBE_RESP,
+        DOT11_PS_POLL,
+        DOT11_REASSOC_REQ,
+        DOT11_REASSOC_RESP,
+        DOT11_RTS,
+        DOT11_QOS_DATA,
+        LLC,
+        SNAP,
+        IP,
+        ARP,
+        TCP,
+        UDP,
+        ICMP,
+        BOOTP,
+        DHCP,
+        EAPOL,
+        RC4EAPOL,
+        RSNEAPOL,
+        DNS,
+        LOOPBACK,
+        IPv6,
+        ICMPv6,
+        SLL,
+        DHCPv6,
+        DOT1Q,
+        PPPOE,
+        STP,
+        PPI,
+        IPSEC_AH,
+        IPSEC_ESP,
+        PKTAP,
+        MPLS,
+        USER_DEFINED_PDU = 1000
     };
     
     /**
-     * \brief Concatenation operator.
-     * 
-     * This operator concatenates several PDUs. A copy of the right 
-     * operand is set at the end of the left one's inner PDU chain.
-     * This means that:
-     * 
-     * IP some_ip = IP("127.0.0.1") / TCP(12, 13) / RawPDU("bleh");
-     * 
-     * Works as expected, meaning the output PDU will look like the 
-     * following:
-     * 
-     * IP - TCP - RawPDU
-     * 
-     * \param lop The left operand, which will be the one modified.
-     * \param rop The right operand, the one which will be appended
-     * to lop.
+     * The endianness used by this PDU. This can be overriden
+     * by subclasses.
      */
-    template<typename T>
-    T &operator/= (T &lop, const PDU &rop) {
-        PDU *last = &lop;
-        while(last->inner_pdu())
-            last = last->inner_pdu();
-        last->inner_pdu(rop.clone());
-        return lop;
+    static const endian_type endianness = BE;
+
+    /** 
+     * \brief Default constructor.
+     */
+    PDU();
+    
+    #if TINS_IS_CXX11
+        /**
+         * \brief Move constructor.
+         * 
+         * \param rhs The PDU to be moved.
+         */
+        PDU(PDU &&rhs) TINS_NOEXCEPT 
+        : inner_pdu_(0) {
+            std::swap(inner_pdu_, rhs.inner_pdu_);
+        }
+        
+        /**
+         * \brief Move assignment operator.
+         * 
+         * \param rhs The PDU to be moved.
+         */
+        PDU& operator=(PDU &&rhs) TINS_NOEXCEPT {
+            std::swap(inner_pdu_, rhs.inner_pdu_);
+            return* this;
+        }
+    #endif
+
+    /** 
+     * \brief PDU destructor.
+     *
+     * Deletes the inner pdu, as a consequence every child pdu is
+     * deleted.
+     */
+    virtual ~PDU();
+
+    /** \brief The header's size
+     */
+    virtual uint32_t header_size() const = 0;
+
+    /** \brief Trailer's size.
+     *
+     * Some protocols require a trailer(like Ethernet). This defaults to 0.
+     */
+    virtual uint32_t trailer_size() const {
+        return 0;
+    }
+
+    /** \brief The whole chain of PDU's size, including this one.
+     *
+     * Returns the sum of this and all children PDUs' size.
+     */
+    uint32_t size() const;
+
+    /**
+     * \brief Getter for the inner PDU.
+     * \return The current inner PDU. Might be 0.
+     */
+    PDU* inner_pdu() const {
+        return inner_pdu_;
     }
     
     /**
-     * \brief Concatenation operator.
+     * \brief Releases the inner PDU.
      * 
-     * \sa operator/=
+     * This method makes this PDU to <b>no longer own</b> the inner
+     * PDU. The current inner PDU is returned, and is <b>not</b>
+     * destroyed. That means after calling this function, you are 
+     * responsible for using operator delete on the returned pointer.
+     * 
+     * Use this method if you want to somehow re-use a PDU that
+     * is already owned by another PDU.
+     * 
+     * \return The current inner PDU. Might be 0.
      */
-    template<typename T>
-    T operator/ (T lop, const PDU &rop) {
-        lop /= rop;
-        return lop;
+    PDU* release_inner_pdu();
+
+    /**
+     * \brief Sets the child PDU.
+     *
+     * When setting a new inner_pdu, the instance takesownership of
+     * the object, therefore deleting it when it's no longer required.
+     * 
+     * \param next_pdu The new child PDU.
+     */
+    void inner_pdu(PDU* next_pdu);
+    
+    /**
+     * \brief Sets the child PDU.
+     *
+     * The PDU parameter is cloned using PDU::clone.
+     * 
+     * \param next_pdu The new child PDU.
+     */
+    void inner_pdu(const PDU& next_pdu);
+
+
+    /** 
+     * \brief Serializes the whole chain of PDU's, including this one.
+     *
+     * This allocates a std::vector of size size(), and fills it
+     * with the serialization this PDU, and all of the inner ones'.
+     * 
+     * \return serialization_type containing the serialization
+     * of the whole stack of PDUs.
+     */
+    serialization_type serialize();
+
+    /**
+     * \brief Finds and returns the first PDU that matches the given flag.
+     *
+     * This method searches for the first PDU which has the same type flag as
+     * the given one. If the first PDU matches that flag, it is returned.
+     * If no PDU matches, 0 is returned.
+     * \param flag The flag which being searched.
+     */
+    template<typename T> 
+    T* find_pdu(PDUType type = T::pdu_flag) {
+        PDU* pdu = this;
+        while (pdu) {
+            if (pdu->matches_flag(type)) {
+                return static_cast<T*>(pdu);
+            }
+            pdu = pdu->inner_pdu();
+        }
+        return 0;
     }
     
     /**
-     * \brief Concatenation operator on PDU pointers.
+     * \brief Finds and returns the first PDU that matches the given flag.
+     *
+     * \param flag The flag which being searched.
+     */
+    template<typename T> 
+    const T* find_pdu(PDUType type = T::pdu_flag) const {
+        return const_cast<PDU*>(this)->find_pdu<T>();
+    }
+
+    /**
+     * \brief Finds and returns the first PDU that matches the given flag.
      * 
-     * \sa operator/=
+     * If the PDU is not found, a pdu_not_found exception is thrown.
+     * 
+     * \sa PDU::find_pdu
+     * 
+     * \param flag The flag which being searched.
      */
     template<typename T>
-    T *operator/= (T* lop, const PDU &rop) {
-        *lop /= rop;
-        return lop;
+    T& rfind_pdu(PDUType type = T::pdu_flag) {
+        T* ptr = find_pdu<T>(type);
+        if (!ptr) {
+            throw pdu_not_found();
+        }
+        return* ptr;
     }
 
-    namespace Internals {
-        template<typename T>
-        struct remove_pointer {
-            typedef T type;
-        };
-
-        template<typename T>
-        struct remove_pointer<T*> {
-            typedef T type;
-        };
+    /**
+     * \brief Finds and returns the first PDU that matches the given flag.
+     *
+     * \param flag The flag which being searched.
+     */
+    template<typename T> 
+    const T& rfind_pdu(PDUType type = T::pdu_flag) const {
+        return const_cast<PDU*>(this)->rfind_pdu<T>();
     }
 
-    template<typename T, typename U>
-    T tins_cast(U *pdu) {
-        typedef typename Internals::remove_pointer<T>::type TrueT;
-        return pdu && (TrueT::pdu_flag == pdu->pdu_type()) ?
-            static_cast<T>(pdu) :
-            0;
+    /**
+     * \brief Clones this packet.
+     *
+     * This method clones this PDU and clones every inner PDU,
+     * therefore obtaining a clone of the whole inner PDU chain.
+     * The pointer returned must be deleted by the user.
+     * \return A pointer to a clone of this packet.
+     */
+    virtual PDU* clone() const = 0;
+
+    /** 
+     * \brief Send the stack of PDUs through a PacketSender.
+     *
+     * This method will be called only for the PDU on the bottom of the stack,
+     * therefore it should only implement this method if it can be sent.
+     * 
+     * PacketSender implements specific methods to send packets which start
+     * on every valid TCP/IP stack layer; this should only be a proxy for
+     * those methods.
+     * 
+     * If this PDU does not represent a link layer protocol, then
+     * the interface argument will be ignored.
+     * 
+     * \param sender The PacketSender which will send the packet.
+     * \param iface The network interface in which this packet will 
+     * be sent.
+     */
+    virtual void send(PacketSender& sender, const NetworkInterface& iface);
+
+    /** 
+     * \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.
+     * \param iface The interface in which to expect the response.
+     */
+    virtual PDU* recv_response(PacketSender& sender, const NetworkInterface& iface);
+
+    /** 
+     * \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(const uint8_t* ptr, uint32_t total_sz) const { 
+        return false; 
     }
 
-    template<typename T, typename U>
-    T &tins_cast(U &pdu) {
-        T *ptr = tins_cast<T*>(&pdu);
-        if(!ptr)
-            throw bad_tins_cast();
-        return *ptr;
+    /**
+     * \brief Check wether this PDU matches the specified flag.
+     *
+     * This method should be reimplemented in PDU classes which have
+     * subclasses, and try to match the given PDU to each of its parent
+     * classes' flag.
+     * \param flag The flag to match.
+     */
+    virtual bool matches_flag(PDUType flag) const {
+       return flag == pdu_type();
     }
+
+    /**
+     * \brief Getter for the PDU's type.
+     *
+     * \return Returns the PDUType corresponding to the PDU.
+     */
+    virtual PDUType pdu_type() const = 0;
+protected:
+    /**
+     * \brief Copy constructor.
+     */
+    PDU(const PDU& other);
+
+    /**
+     * \brief Copy assignment operator.
+     */
+    PDU& operator=(const PDU& other);
+
+    /**
+     * \brief Copy other PDU's inner PDU(if any).
+     * \param pdu The PDU from which to copy the inner PDU.
+     */
+    void copy_inner_pdu(const PDU& pdu);
+
+    /**
+     * \brief Prepares this PDU for serialization.
+     * 
+     * This method is called before the inner PDUs are serialized.
+     * It's useful in situations such as when serializing IP PDUs,
+     * which don't contain any link layer encapsulation, and therefore
+     * require to set the source IP address before the TCP/UDP checksum
+     * is calculated.
+     * 
+     * By default, this method does nothing
+     * 
+     * \param parent The parent PDU.
+     */
+    virtual void prepare_for_serialize(const PDU* parent) { }
+
+    /** 
+     * \brief Serializes this PDU and propagates this action to child PDUs.
+     *
+     * \param buffer The buffer in which to store this PDU's serialization.
+     * \param total_sz The total size of the buffer.
+     * \param parent The parent PDU. Will be 0 if there's the parent does not exist.
+     */
+    void serialize(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
+
+    /** 
+     * \brief Serializes this TCP PDU.
+     *
+     * Each PDU must override this method and implement it's own
+     * serialization.
+     * \param buffer The buffer in which the PDU will be serialized.
+     * \param total_sz The size available in the buffer.
+     * \param parent The PDU that's one level below this one on the stack. Might be 0.
+     */
+    virtual void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent) = 0;
+private:
+    PDU* inner_pdu_;
+};
+
+/**
+ * \brief Concatenation operator.
+ * 
+ * This operator concatenates several PDUs. A copy of the right 
+ * operand is set at the end of the left one's inner PDU chain.
+ * This means that:
+ * 
+ * IP some_ip = IP("127.0.0.1") / TCP(12, 13) / RawPDU("bleh");
+ * 
+ * Works as expected, meaning the output PDU will look like the 
+ * following:
+ * 
+ * IP - TCP - RawPDU
+ * 
+ * \param lop The left operand, which will be the one modified.
+ * \param rop The right operand, the one which will be appended
+ * to lop.
+ */
+template<typename T>
+T& operator/= (T& lop, const PDU& rop) {
+    PDU* last = &lop;
+    while (last->inner_pdu()) {
+        last = last->inner_pdu();
+    }
+    last->inner_pdu(rop.clone());
+    return lop;
 }
 
+/**
+ * \brief Concatenation operator.
+ * 
+ * \sa operator/=
+ */
+template<typename T>
+T operator/ (T lop, const PDU& rop) {
+    lop /= rop;
+    return lop;
+}
+
+/**
+ * \brief Concatenation operator on PDU pointers.
+ * 
+ * \sa operator/=
+ */
+template<typename T>
+T* operator/= (T* lop, const PDU& rop) {
+    *lop /= rop;
+    return lop;
+}
+
+namespace Internals {
+    template<typename T>
+    struct remove_pointer {
+        typedef T type;
+    };
+
+    template<typename T>
+    struct remove_pointer<T*> {
+        typedef T type;
+    };
+}
+
+template<typename T, typename U>
+T tins_cast(U* pdu) {
+    typedef typename Internals::remove_pointer<T>::type TrueT;
+    return pdu && (TrueT::pdu_flag == pdu->pdu_type()) ?
+           static_cast<T>(pdu) : 0;
+}
+
+template<typename T, typename U>
+T& tins_cast(U& pdu) {
+    T* ptr = tins_cast<T*>(&pdu);
+    if (!ptr) {
+        throw bad_tins_cast();
+    }
+    return* ptr;
+}
+
+} // Tins
+
 #endif // TINS_PDU_H
diff --git a/include/tins/pdu_allocator.h b/include/tins/pdu_allocator.h
index cffa2c6..9b1a555 100644
--- a/include/tins/pdu_allocator.h
+++ b/include/tins/pdu_allocator.h
@@ -45,9 +45,9 @@ class IP;
 class IPv6;
 
 namespace Internals {
+
 template<typename PDUType>
-PDU *default_allocator(const uint8_t *buffer, uint32_t size)
-{
+PDU* default_allocator(const uint8_t* buffer, uint32_t size) {
     return new PDUType(buffer, size);
 }
 
@@ -58,25 +58,21 @@ public:
     typedef PDU *(*allocator_type)(const uint8_t *, uint32_t);
 
     template<typename PDUType>
-    static void register_allocator(id_type identifier)
-    {
+    static void register_allocator(id_type identifier) {
         allocators[identifier] = &default_allocator<PDUType>;
         pdu_types[PDUType::pdu_flag] = identifier;
     }
 
-    static PDU *allocate(id_type identifier, const uint8_t *buffer, uint32_t size) 
-    {
+    static PDU* allocate(id_type identifier, const uint8_t* buffer, uint32_t size) {
         typename allocators_type::const_iterator it = allocators.find(identifier);
         return (it == allocators.end()) ? 0 : (*it->second)(buffer, size);
     }
 
-    static bool pdu_type_registered(PDU::PDUType type)
-    {
+    static bool pdu_type_registered(PDU::PDUType type) {
         return pdu_types.count(type) != 0;
     }
 
-    static id_type pdu_type_to_id(PDU::PDUType type) 
-    {
+    static id_type pdu_type_to_id(PDU::PDUType type) {
         typename pdu_map_types::const_iterator it = pdu_types.find(type);
         return it->second;
     }
@@ -118,26 +114,23 @@ TINS_GENERATE_TAG_MAPPER(IPv6, uint8_t)
 #undef TINS_GENERATE_TAG_MAPPER
 
 template<typename PDUType>
-PDU* allocate(
-    typename pdu_tag_mapper<PDUType>::type::identifier_type id, 
-    const uint8_t *buffer, 
-    uint32_t size)
-{
+PDU* allocate(typename pdu_tag_mapper<PDUType>::type::identifier_type id, 
+              const uint8_t* buffer, 
+              uint32_t size) {
     return PDUAllocator<typename pdu_tag_mapper<PDUType>::type>::allocate(id, buffer, size);
 }
 
 template<typename PDUType>
-bool pdu_type_registered(PDU::PDUType type)
-{
+bool pdu_type_registered(PDU::PDUType type) {
     return PDUAllocator<typename pdu_tag_mapper<PDUType>::type>::pdu_type_registered(type);
 }
 
 template<typename PDUType>
-typename pdu_tag_mapper<PDUType>::type::identifier_type pdu_type_to_id(PDU::PDUType type) 
-{
+typename pdu_tag_mapper<PDUType>::type::identifier_type pdu_type_to_id(PDU::PDUType type)  {
     return PDUAllocator<typename pdu_tag_mapper<PDUType>::type>::pdu_type_to_id(type);
 }
-} // namespace Interals
+
+} // Interals
 /**
  * \endcond
  */
@@ -170,13 +163,13 @@ namespace Allocators {
  * the same way.
  */
 template<typename PDUType, typename AllocatedType>
-void register_allocator(typename Internals::pdu_tag_mapper<PDUType>::type::identifier_type id)
-{
+void register_allocator(typename Internals::pdu_tag_mapper<PDUType>::type::identifier_type id) {
     Internals::PDUAllocator<
         typename Internals::pdu_tag_mapper<PDUType>::type
     >::template register_allocator<AllocatedType>(id);
 }
-} // namespace Allocators
-} // namespace Tins
+
+} // Allocators
+} // Tins
 
 #endif // TINS_PDU_ALLOCATOR_H
diff --git a/include/tins/pdu_cacher.h b/include/tins/pdu_cacher.h
index c71991a..c730cf9 100644
--- a/include/tins/pdu_cacher.h
+++ b/include/tins/pdu_cacher.h
@@ -68,14 +68,15 @@ public:
     /**
      * Default constructs the cached PDU.
      */
-    PDUCacher() : cached_size() {}
+    PDUCacher() 
+    : cached_size_() {}
     
     /**
      * Constructor from a cached_type.
      * \param pdu The PDU to be copy constructed.
      */
-    PDUCacher(const cached_type &pdu) : cached(pdu),
-      cached_size()  {}
+    PDUCacher(const cached_type& pdu) 
+    : cached_(pdu), cached_size_()  {}
     
     /**
      * Forwards the call to the cached PDU. 
@@ -83,9 +84,10 @@ public:
      * \sa PDU::header_size.
      */
     uint32_t header_size() const {
-        if(cached_serialization.empty())
-            cached_size = cached.size();
-        return cached_size;
+        if (cached_serialization_.empty()) {
+            cached_size_ = cached_.size();
+        }
+        return cached_size_;
     }
     
     /**
@@ -93,7 +95,7 @@ public:
      * 
      * \sa PDU::clone.
      */
-    PDUCacher *clone() const {
+    PDUCacher* clone() const {
         return new PDUCacher<T>(*this);
     }
     
@@ -102,8 +104,8 @@ public:
      * 
      * \sa PDU::send.
      */
-    void send(PacketSender &sender, const NetworkInterface &iface) {
-        cached.send(sender, iface);
+    void send(PacketSender& sender, const NetworkInterface& iface) {
+        cached_.send(sender, iface);
     }
     
     /**
@@ -111,8 +113,8 @@ public:
      * 
      * \sa PDU::recv_responde.
      */
-    PDU *recv_response(PacketSender &sender, const NetworkInterface &iface) {
-        return cached.recv_response(sender, iface);
+    PDU* recv_response(PacketSender& sender, const NetworkInterface& iface) {
+        return cached_.recv_response(sender, iface);
     }
     
     /**
@@ -120,8 +122,8 @@ public:
      * 
      * \sa PDU::matches_response.
      */
-    bool matches_response(const uint8_t *ptr, uint32_t total_sz) const {
-        return cached.matches_response(ptr, total_sz);
+    bool matches_response(const uint8_t* ptr, uint32_t total_sz) const {
+        return cached_.matches_response(ptr, total_sz);
     }
     
     /**
@@ -130,7 +132,7 @@ public:
      * \sa PDU::matches_flag.
      */
     bool matches_flag(PDUType flag) const {
-        return cached.matches_flag(flag);
+        return cached_.matches_flag(flag);
     }
     
     /**
@@ -139,19 +141,19 @@ public:
      * \sa PDU::pdu_type.
      */
     PDUType pdu_type() const {
-        return cached.pdu_type();
+        return cached_.pdu_type();
     }
 private:
-    void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent) {
-        if(cached_serialization.size() != total_sz) {
-            cached_serialization = cached.serialize();
+    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent) {
+        if (cached_serialization_.size() != total_sz) {
+            cached_serialization_ = cached_.serialize();
         }
-        std::copy(cached_serialization.begin(), cached_serialization.end(), buffer);
+        std::copy(cached_serialization_.begin(), cached_serialization_.end(), buffer);
     }
 
-    cached_type cached;
-    PDU::serialization_type cached_serialization;
-    mutable uint32_t cached_size;
+    cached_type cached_;
+    PDU::serialization_type cached_serialization_;
+    mutable uint32_t cached_size_;
 };
 }
 
diff --git a/include/tins/pdu_option.h b/include/tins/pdu_option.h
index 75d2cbe..9e5ee71 100644
--- a/include/tins/pdu_option.h
+++ b/include/tins/pdu_option.h
@@ -54,13 +54,16 @@ class PDUOption;
 namespace Internals {
     template<typename T, typename X, typename PDUType>
     T convert_to_integral(const PDUOption<X, PDUType> & opt) {
-        if(opt.data_size() != sizeof(T))
+        if (opt.data_size() != sizeof(T)) {
             throw malformed_option();
+        }
         T data = *(T*)opt.data_ptr();
-        if(PDUType::endianness == PDUType::BE)
+        if (PDUType::endianness == PDUType::BE) {
             data = Endian::be_to_host(data);
-        else
+        }
+        else {
             data = Endian::le_to_host(data);
+        }
         return data;
     }
     
@@ -76,9 +79,10 @@ namespace Internals {
     struct converter<uint8_t> {
         template<typename X, typename PDUType>
         static uint8_t convert(const PDUOption<X, PDUType>& opt) {
-            if(opt.data_size() != 1)
+            if (opt.data_size() != 1) {
                 throw malformed_option();
-            return *opt.data_ptr();
+            }
+            return* opt.data_ptr();
         }
     };
     
@@ -110,8 +114,9 @@ namespace Internals {
     struct converter<HWAddress<n> > {
         template<typename X, typename PDUType>
         static HWAddress<n> convert(const PDUOption<X, PDUType>& opt) {
-            if(opt.data_size() != n)
+            if (opt.data_size() != n) {
                 throw malformed_option();
+            }
             return HWAddress<n>(opt.data_ptr());
         }
     };
@@ -120,13 +125,16 @@ namespace Internals {
     struct converter<IPv4Address> {
         template<typename X, typename PDUType>
         static IPv4Address convert(const PDUOption<X, PDUType>& opt) {
-            if(opt.data_size() != sizeof(uint32_t))
+            if (opt.data_size() != sizeof(uint32_t)) {
                 throw malformed_option();
-            const uint32_t *ptr = (const uint32_t*)opt.data_ptr();
-            if(PDUType::endianness == PDUType::BE)
+            }
+            const uint32_t* ptr = (const uint32_t*)opt.data_ptr();
+            if (PDUType::endianness == PDUType::BE) {
                 return IPv4Address(*ptr);
-            else
+            }
+            else {
                 return IPv4Address(Endian::change_endian(*ptr));
+            }
         }
     };
 
@@ -134,8 +142,9 @@ namespace Internals {
     struct converter<IPv6Address> {
         template<typename X, typename PDUType>
         static IPv6Address convert(const PDUOption<X, PDUType>& opt) {
-            if(opt.data_size() != IPv6Address::address_size)
+            if (opt.data_size() != IPv6Address::address_size) {
                 throw malformed_option();
+            }
             return IPv6Address(opt.data_ptr());
         }
     };
@@ -156,8 +165,8 @@ namespace Internals {
         template<typename X, typename PDUType>
         static std::vector<float> convert(const PDUOption<X, PDUType>& opt) {
             std::vector<float> output;
-            const uint8_t *ptr = opt.data_ptr(), *end = ptr + opt.data_size();
-            while(ptr != end) {
+            const uint8_t* ptr = opt.data_ptr(), *end = ptr + opt.data_size();
+            while (ptr != end) {
                 output.push_back(float(*(ptr++) & 0x7f) / 2);
             }
             return output;
@@ -168,18 +177,21 @@ namespace Internals {
     struct converter<std::vector<T>, typename enable_if<is_unsigned_integral<T>::value>::type> {
         template<typename X, typename PDUType>
         static std::vector<T> convert(const PDUOption<X, PDUType>& opt) {
-            if(opt.data_size() % sizeof(T) != 0)
+            if (opt.data_size() % sizeof(T) != 0) {
                 throw malformed_option();
-            const T *ptr = (const T*)opt.data_ptr();
-            const T *end = (const T*)(opt.data_ptr() + opt.data_size());
+            }
+            const T* ptr = (const T*)opt.data_ptr();
+            const T* end = (const T*)(opt.data_ptr() + opt.data_size());
             
             std::vector<T> output(std::distance(ptr, end));
             typename std::vector<T>::iterator it = output.begin();
-            while(ptr < end) {
-                if(PDUType::endianness == PDUType::BE)
+            while (ptr < end) {
+                if (PDUType::endianness == PDUType::BE) {
                     *it++ = Endian::be_to_host(*ptr++);
-                else
+                }
+                else {
                     *it++ = Endian::le_to_host(*ptr++);
+                }
             }
             return output;
         }
@@ -194,18 +206,19 @@ namespace Internals {
     > {
         template<typename X, typename PDUType>
         static std::vector<std::pair<T, U> > convert(const PDUOption<X, PDUType>& opt) {
-            if(opt.data_size() % (sizeof(T) + sizeof(U)) != 0)
+            if (opt.data_size() % (sizeof(T) + sizeof(U)) != 0) {
                 throw malformed_option();
-            const uint8_t *ptr = opt.data_ptr(), *end = ptr + opt.data_size();
+            }
+            const uint8_t* ptr = opt.data_ptr(), *end = ptr + opt.data_size();
             
             std::vector<std::pair<T, U> > output;
-            while(ptr < end) {
+            while (ptr < end) {
                 std::pair<T, U> data;
                 data.first = *(const T*)ptr;
                 ptr += sizeof(T);
                 data.second = *(const U*)ptr;
                 ptr += sizeof(U);
-                if(PDUType::endianness == PDUType::BE) {
+                if (PDUType::endianness == PDUType::BE) {
                     data.first = Endian::be_to_host(data.first);
                     data.second = Endian::be_to_host(data.second);
                 }
@@ -223,18 +236,21 @@ namespace Internals {
     struct converter<std::vector<IPv4Address> > {
         template<typename X, typename PDUType>
         static std::vector<IPv4Address> convert(const PDUOption<X, PDUType>& opt) {
-            if(opt.data_size() % 4 != 0)
+            if (opt.data_size() % 4 != 0) {
                 throw malformed_option();
-            const uint32_t *ptr = (const uint32_t*)opt.data_ptr();
-            const uint32_t *end = (const uint32_t*)(opt.data_ptr() + opt.data_size());
+            }
+            const uint32_t* ptr = (const uint32_t*)opt.data_ptr();
+            const uint32_t* end = (const uint32_t*)(opt.data_ptr() + opt.data_size());
             
             std::vector<IPv4Address> output(std::distance(ptr, end));
             std::vector<IPv4Address>::iterator it = output.begin();
-            while(ptr < end) {
-                if(PDUType::endianness == PDUType::BE)
+            while (ptr < end) {
+                if (PDUType::endianness == PDUType::BE) {
                     *it++ = IPv4Address(*ptr++);
-                else
+                }
+                else {
                     *it++ = IPv4Address(Endian::change_endian(*ptr++));
+                }
             }
             return output;
         }
@@ -244,11 +260,12 @@ namespace Internals {
     struct converter<std::vector<IPv6Address> > {
         template<typename X, typename PDUType>
         static std::vector<IPv6Address> convert(const PDUOption<X, PDUType>& opt) {
-            if(opt.data_size() % IPv6Address::address_size != 0)
+            if (opt.data_size() % IPv6Address::address_size != 0) {
                 throw malformed_option();
-            const uint8_t *ptr = opt.data_ptr(), *end = opt.data_ptr() + opt.data_size();
+            }
+            const uint8_t* ptr = opt.data_ptr(), *end = opt.data_ptr() + opt.data_size();
             std::vector<IPv6Address> output;
-            while(ptr < end) {
+            while (ptr < end) {
                 output.push_back(IPv6Address(ptr));
                 ptr += IPv6Address::address_size;
             }
@@ -265,12 +282,13 @@ namespace Internals {
     > {
         template<typename X, typename PDUType>
         static std::pair<T, U> convert(const PDUOption<X, PDUType>& opt) {
-            if(opt.data_size() != sizeof(T) + sizeof(U))
+            if (opt.data_size() != sizeof(T) + sizeof(U)) {
                 throw malformed_option();
+            }
             std::pair<T, U> output;
             std::memcpy(&output.first, opt.data_ptr(), sizeof(T));
             std::memcpy(&output.second, opt.data_ptr() + sizeof(T), sizeof(U));
-            if(PDUType::endianness == PDUType::BE) {
+            if (PDUType::endianness == PDUType::BE) {
                 output.first = Endian::be_to_host(output.first);
                 output.second = Endian::be_to_host(output.second);
             }
@@ -312,7 +330,9 @@ public:
      * \param length The option's data length.
      * \param data The option's data(if any).
      */
-    PDUOption(option_type opt = option_type(), size_t length = 0, const data_type *data = 0) 
+    PDUOption(option_type opt = option_type(), 
+              size_t length = 0,
+              const data_type* data = 0) 
     : option_(opt), size_(static_cast<uint16_t>(length)) {
         set_payload_contents(data, data + (data ? length : 0));
     }
@@ -343,11 +363,11 @@ public:
     PDUOption& operator=(PDUOption&& rhs) {
         option_ = rhs.option_;
         size_ = rhs.size_;
-        if(real_size_ > small_buffer_size) {
+        if (real_size_ > small_buffer_size) {
             delete[] payload_.big_buffer_ptr;
         }
         real_size_ = rhs.real_size_;
-        if(real_size_ > small_buffer_size) {
+        if (real_size_ > small_buffer_size) {
             payload_.big_buffer_ptr = nullptr;
             std::swap(payload_.big_buffer_ptr, rhs.payload_.big_buffer_ptr);
             rhs.real_size_ = 0;
@@ -359,7 +379,7 @@ public:
                 payload_.small_buffer
             );
         }
-        return *this;
+        return* this;
     }
     
     #endif // TINS_IS_CXX11
@@ -371,19 +391,19 @@ public:
     PDUOption& operator=(const PDUOption& rhs) {
         option_ = rhs.option_;
         size_ = rhs.size_;
-        if(real_size_ > small_buffer_size) {
+        if (real_size_ > small_buffer_size) {
             delete[] payload_.big_buffer_ptr;
         }
         real_size_ = rhs.real_size_;
         set_payload_contents(rhs.data_ptr(), rhs.data_ptr() + rhs.data_size());
-        return *this;
+        return* this;
     }
     
     /**
      * \brief Destructor.
      */
     ~PDUOption() {
-        if(real_size_ > small_buffer_size) {
+        if (real_size_ > small_buffer_size) {
             delete[] payload_.big_buffer_ptr;
         }
     }
@@ -448,10 +468,10 @@ public:
      * 
      * \return const data_type& containing this option's value.
      */
-    const data_type *data_ptr() const {
+    const data_type* data_ptr() const {
         return real_size_ <= small_buffer_size ?
-            payload_.small_buffer : 
-            payload_.big_buffer_ptr;
+               payload_.small_buffer : 
+               payload_.big_buffer_ptr;
     }
     
     /**
@@ -498,7 +518,7 @@ private:
             throw option_payload_too_large();
         }
         real_size_ = static_cast<uint16_t>(total_size);
-        if(real_size_ <= small_buffer_size) {
+        if (real_size_ <= small_buffer_size) {
             std::copy(
                 start,
                 end,
diff --git a/include/tins/pktap.h b/include/tins/pktap.h
index 2b4f93b..f2c3b86 100644
--- a/include/tins/pktap.h
+++ b/include/tins/pktap.h
@@ -35,6 +35,9 @@
 
 namespace Tins {
 
+/**
+ * \brief Represents a PKTAP PDU
+ */
 class TINS_API PKTAP : public PDU {
 public:
     /**
@@ -64,7 +67,9 @@ public:
      * \brief Getter for the PDU's type.
      * \sa PDU::pdu_type
      */
-    PDUType pdu_type() const { return pdu_flag; }
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
 
     /**
      * \brief Returns the header size.
@@ -77,7 +82,7 @@ public:
     /**
      * \sa PDU::clone
      */
-    PKTAP *clone() const {
+    PKTAP* clone() const {
         return new PKTAP(*this);
     }
 private:
@@ -99,8 +104,7 @@ private:
         uint8_t ecommand[20];
     };
 
-    void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
-
+    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
 
     pktap_header header_;
 };
diff --git a/include/tins/ppi.h b/include/tins/ppi.h
index cdcc695..c32f3a6 100644
--- a/include/tins/ppi.h
+++ b/include/tins/ppi.h
@@ -36,6 +36,7 @@
 #include "small_uint.h"
 
 namespace Tins {
+
 /**
  * \class PPI
  * \brief Represents a Per-Packet Information PDU.
@@ -62,7 +63,7 @@ public:
      * \param buffer The buffer from which this PDU will be constructed.
      * \param total_sz The total size of the buffer.
      */
-    PPI(const uint8_t *buffer, uint32_t total_sz);
+    PPI(const uint8_t* buffer, uint32_t total_sz);
 
     // Getters
 
@@ -71,7 +72,7 @@ public:
      *  \return The stored version field value.
      */
     uint8_t version() const {
-        return _header.version;
+        return header_.version;
     }
 
     /**
@@ -79,7 +80,7 @@ public:
      *  \return The stored flags field value.
      */
     uint8_t flags() const {
-        return _header.flags;
+        return header_.flags;
     }
 
     /**
@@ -87,7 +88,7 @@ public:
      *  \return The stored length field value.
      */
     uint16_t length() const {
-        return Endian::le_to_host(_header.length);
+        return Endian::le_to_host(header_.length);
     }
 
     /**
@@ -95,7 +96,7 @@ public:
      *  \return The stored Data Link Type field value.
      */
     uint32_t dlt() const {
-        return Endian::le_to_host(_header.dlt);
+        return Endian::le_to_host(header_.dlt);
     }
 
     /**
@@ -109,28 +110,30 @@ public:
      * \brief Getter for the PDU's type.
      * \sa PDU::pdu_type
      */
-    PDUType pdu_type() const { return pdu_flag; }
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
 
     /**
      * \brief Clones this PDU.
      *
      * \sa PDU::clone
      */
-    PPI *clone() const {
+    PPI* clone() const {
         return new PPI(*this);
     }
 private:
-    void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU *);
     void parse_80211(const uint8_t* buffer, uint32_t total_sz);
 
-    struct header {
+    struct ppi_header {
         uint8_t version, flags;
         uint16_t length;
         uint32_t dlt;
     };
 
-    header _header;
-    byte_array _data;
+    ppi_header header_;
+    byte_array data_;
 };
 }
 
diff --git a/include/tins/pppoe.h b/include/tins/pppoe.h
index 7d6e0c0..e281a67 100644
--- a/include/tins/pppoe.h
+++ b/include/tins/pppoe.h
@@ -93,10 +93,10 @@ public:
         uint32_t vendor_id;
         data_type data;
         
-        vendor_spec_type(uint32_t vendor_id = 0, const data_type &data = data_type())
+        vendor_spec_type(uint32_t vendor_id = 0, const data_type& data = data_type())
         : vendor_id(vendor_id), data(data) { }
         
-        static vendor_spec_type from_option(const tag &opt);
+        static vendor_spec_type from_option(const tag& opt);
     };
     
     /**
@@ -120,7 +120,7 @@ public:
      * \param buffer The buffer from which this PDU will be constructed.
      * \param total_sz The total size of the buffer.
      */
-    PPPoE(const uint8_t *buffer, uint32_t total_sz);
+    PPPoE(const uint8_t* buffer, uint32_t total_sz);
 
     // Getters
 
@@ -129,7 +129,7 @@ public:
      *  \return The stored version field value.
      */
     small_uint<4> version() const {
-        return _header.version;
+        return header_.version;
     }
 
     /**
@@ -137,7 +137,7 @@ public:
      *  \return The stored type field value.
      */
     small_uint<4> type() const {
-        return _header.type;
+        return header_.type;
     }
 
     /**
@@ -145,7 +145,7 @@ public:
      *  \return The stored code field value.
      */
     uint8_t code() const {
-        return _header.code;
+        return header_.code;
     }
 
     /**
@@ -153,7 +153,7 @@ public:
      *  \return The stored session_id field value.
      */
     uint16_t session_id() const {
-        return Endian::be_to_host(_header.session_id);
+        return Endian::be_to_host(header_.session_id);
     }
 
     /**
@@ -161,7 +161,7 @@ public:
      *  \return The stored payload_length field value.
      */
     uint16_t payload_length() const {
-        return Endian::be_to_host(_header.payload_length);
+        return Endian::be_to_host(header_.payload_length);
     }
     
     /**
@@ -174,18 +174,18 @@ public:
     /**
      * \brief Returns the list of tags.
      */
-    const tags_type &tags() const {
-        return _tags;
+    const tags_type& tags() const {
+        return tags_;
     }
 
     /**
      * \sa PDU::clone
      */
-    PPPoE *clone() const {
+    PPPoE* clone() const {
         return new PPPoE(*this);
     }
     
-    const tag *search_tag(TagTypes identifier) const;
+    const tag* search_tag(TagTypes identifier) const;
     
     /**
      * \brief Getter for the PDU's type.
@@ -230,7 +230,7 @@ public:
      *
      * \param option The option to be added.
      */
-    void add_tag(const tag &option);
+    void add_tag(const tag& option);
     
     #if TINS_IS_CXX11
         /**
@@ -241,8 +241,8 @@ public:
          * \param option The option to be added.
          */
         void add_tag(tag &&option) {
-            _tags_size += static_cast<uint16_t>(option.data_size() + sizeof(uint16_t) * 2);
-            _tags.push_back(std::move(option));
+            tags_size_ += static_cast<uint16_t>(option.data_size() + sizeof(uint16_t) * 2);
+            tags_.push_back(std::move(option));
         }
     #endif
     
@@ -258,63 +258,63 @@ public:
      * 
      * \param value The service name.
      */
-    void service_name(const std::string &value);
+    void service_name(const std::string& value);
     
     /**
      * \brief Adds a AC-name tag.
      * 
      * \param value The AC name.
      */
-    void ac_name(const std::string &value);
+    void ac_name(const std::string& value);
     
     /**
      * \brief Adds a host-uniq tag.
      * 
      * \param value The tag's value.
      */
-    void host_uniq(const byte_array &value);
+    void host_uniq(const byte_array& value);
     
     /**
      * \brief Adds a AC-Cookie tag.
      * 
      * \param value The tag's value.
      */
-    void ac_cookie(const byte_array &value);
+    void ac_cookie(const byte_array& value);
     
     /**
      * \brief Adds a Vendor-Specific tag.
      * 
      * \param value The tag's value.
      */
-    void vendor_specific(const vendor_spec_type &value);
+    void vendor_specific(const vendor_spec_type& value);
     
     /**
      * \brief Adds a Relay-Session-Id tag.
      * 
      * \param value The tag's value.
      */
-    void relay_session_id(const byte_array &value);
+    void relay_session_id(const byte_array& value);
     
     /**
      * \brief Adds a Service-Name-Error tag.
      * 
      * \param value The tag's value.
      */
-    void service_name_error(const std::string &value);
+    void service_name_error(const std::string& value);
     
     /**
      * \brief Adds a AC-System-Error tag.
      * 
      * \param value The tag's value.
      */
-    void ac_system_error(const std::string &value);
+    void ac_system_error(const std::string& value);
     
     /**
      * \brief Adds a Generic-Error tag.
      * 
      * \param value The tag's value.
      */
-    void generic_error(const std::string &value);
+    void generic_error(const std::string& value);
     
     // Option getters
     
@@ -390,10 +390,10 @@ public:
      */
     std::string generic_error() const;
 private:
-    void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU *);
     
     template<typename T>
-    void add_tag_iterable(TagTypes id, const T &data) {
+    void add_tag_iterable(TagTypes id, const T& data) {
         add_tag(
             tag(
                 id,
@@ -405,14 +405,15 @@ private:
     
     template<typename T>
     T search_and_convert(TagTypes id) const {
-        const tag *t = search_tag(id);
-        if(!t)
+        const tag* t = search_tag(id);
+        if (!t) {
             throw option_not_found();
+        }
         return t->to<T>();
     }
 
     TINS_BEGIN_PACK
-    struct pppoe_hdr {
+    struct pppoe_header {
         #if TINS_IS_LITTLE_ENDIAN
             uint8_t version:4,  
                     type:4;
@@ -426,9 +427,9 @@ private:
         uint16_t payload_length;
     } TINS_END_PACK;
 
-    pppoe_hdr _header;
-    tags_type _tags;
-    uint16_t _tags_size;
+    pppoe_header header_;
+    tags_type tags_;
+    uint16_t tags_size_;
 };
 }
 
diff --git a/include/tins/radiotap.h b/include/tins/radiotap.h
index 55d2807..6372235 100644
--- a/include/tins/radiotap.h
+++ b/include/tins/radiotap.h
@@ -137,7 +137,7 @@ public:
      * \param buffer The buffer from which this PDU will be constructed.
      * \param total_sz The total size of the buffer.
      */
-    RadioTap(const uint8_t *buffer, uint32_t total_sz);
+    RadioTap(const uint8_t* buffer, uint32_t total_sz);
     
     /* Setters */
     
@@ -145,7 +145,7 @@ public:
     /**
      * \sa PDU::send()
      */
-    void send(PacketSender &sender, const NetworkInterface &iface);
+    void send(PacketSender& sender, const NetworkInterface& iface);
     #endif
     
     /**
@@ -365,8 +365,8 @@ public:
      * if its corresponding bit flag is set in the present field.
      */
     PresentFlags present() const { 
-        //return (PresentFlags)*(uint32_t*)(&_radio.it_len + 1); 
-        return (PresentFlags)Endian::le_to_host(_radio.flags_32);
+        //return (PresentFlags)*(uint32_t*)(&radio_.it_len + 1); 
+        return (PresentFlags)Endian::le_to_host(radio_.flags_32);
     }
     
     /** \brief Check wether ptr points to a valid response for this PDU.
@@ -375,7 +375,7 @@ public:
      * \param ptr The pointer to the buffer.
      * \param total_sz The size of the buffer.
      */
-    bool matches_response(const uint8_t *ptr, uint32_t total_sz) const;
+    bool matches_response(const uint8_t* ptr, uint32_t total_sz) const;
     
     /**
      * \brief Returns the RadioTap frame's header length.
@@ -394,7 +394,7 @@ public:
     /**
      * \sa PDU::clone
      */
-    RadioTap *clone() const {
+    RadioTap* clone() const {
         return new RadioTap(*this);
     }
     
@@ -402,7 +402,9 @@ public:
      * \brief Getter for the PDU's type.
      * \sa PDU::pdu_type
      */
-    PDUType pdu_type() const { return PDU::RADIOTAP; }
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
 private:
     TINS_BEGIN_PACK
     #if TINS_IS_LITTLE_ENDIAN
@@ -484,13 +486,13 @@ private:
     } TINS_END_PACK;
     
     void init();
-    void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
     uint32_t find_extra_flag_fields_size(const uint8_t* buffer, uint32_t total_sz);
 
     template <size_t n>
     void align_buffer(const uint8_t* buffer_start, const uint8_t*& buffer, uint32_t& size) {
         uint32_t offset = ((buffer - buffer_start) % n);
-        if(offset) {
+        if (offset) {
             offset = n - offset;
             if (offset > size) {
                 throw malformed_packet();
@@ -501,13 +503,13 @@ private:
     }
     
     
-    radiotap_hdr _radio;
+    radiotap_hdr radio_;
     // present fields...
-    uint64_t _tsft;
-    uint16_t _channel_type, _channel_freq, _rx_flags, _signal_quality, _tx_flags;
-    mcs_type _mcs;
-    uint8_t _antenna, _flags, _rate, _channel, _max_power, _db_signal, _data_retries;
-    int8_t _dbm_signal, _dbm_noise;
+    uint64_t tsft_;
+    uint16_t channel_type_, channel_freq_, rx_flags_, signal_quality_, tx_flags_;
+    mcs_type mcs_;
+    uint8_t antenna_, flags_, rate_, channel_, max_power_, db_signal_, data_retries_;
+    int8_t dbm_signal_, dbm_noise_;
 };
 }
 
diff --git a/include/tins/rawpdu.h b/include/tins/rawpdu.h
index ced0e1b..7637e4f 100644
--- a/include/tins/rawpdu.h
+++ b/include/tins/rawpdu.h
@@ -38,168 +38,174 @@
 
 namespace Tins {
 
-    /** 
-     * \class PDU
-     * \brief Represents a PDU which holds raw data.
-     *
-     * This class is a wrapper over a byte array. It can be used to hold
-     * the payload sent over transport layer protocols (such as TCP or UDP).
-     *
-     * While sniffing, this class is the one that will hold transport layer
-     * protocols' payload. You can simply convert a RawPDU into a specific
-     * application layer protocol using the RawPDU::to method:
-     *
-     * \code
-     * // Get a RawPDU from somewhere
-     * RawPDU raw = get_raw_pdu();
-     *
-     * // Parse it as a DHCP PDU.
-     * DHCP dhcp = raw.to<DHCP>();
-     *
-     * // Or parse it as DNS. Of course this will fail if the contents
-     * // don't look like DNS
-     * DNS dns = raw.to<DNS>();
-     * \endcode
+/** 
+ * \class PDU
+ * \brief Represents a PDU which holds raw data.
+ *
+ * This class is a wrapper over a byte array. It can be used to hold
+ * the payload sent over transport layer protocols (such as TCP or UDP).
+ *
+ * While sniffing, this class is the one that will hold transport layer
+ * protocols' payload. You can simply convert a RawPDU into a specific
+ * application layer protocol using the RawPDU::to method:
+ *
+ * \code
+ * // Get a RawPDU from somewhere
+ * RawPDU raw = get_raw_pdu();
+ *
+ * // Parse it as a DHCP PDU.
+ * DHCP dhcp = raw.to<DHCP>();
+ *
+ * // Or parse it as DNS. Of course this will fail if the contents
+ * // don't look like DNS
+ * DNS dns = raw.to<DNS>();
+ * \endcode
+ */
+class TINS_API RawPDU : public PDU {
+public:
+    /**
+     * The type used to store the payload.
      */
-    class TINS_API RawPDU : public PDU {
-    public:
-        /**
-         * The type used to store the payload.
-         */
-        typedef std::vector<uint8_t> payload_type;
-        
-        /**
-         * This PDU's flag.
-         */
-        static const PDU::PDUType pdu_flag = PDU::RAW;
+    typedef std::vector<uint8_t> payload_type;
     
-        /** 
-         * \brief Creates an instance of RawPDU.
-         *
-         * The payload is copied, therefore the original payload's memory
-         * must be freed by the user.
-         * \param pload The payload which the RawPDU will contain.
-         * \param size The size of the payload.
-         */
-        RawPDU(const uint8_t *pload, uint32_t size);
-        
-        /**
-         * \brief Constructs a RawPDU from an iterator range.
-         *
-         * The data in the iterator range is copied into the RawPDU
-         * internal buffer.
-         *
-         * \param start The beginning of the iterator range.
-         * \param end The end of the iterator range.
-         */
-        template<typename ForwardIterator>
-        RawPDU(ForwardIterator start, ForwardIterator end) 
-        : _payload(start, end) { }
+    /**
+     * This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::RAW;
 
-        #if TINS_IS_CXX11
-            /** 
-             * \brief Creates an instance of RawPDU from a payload_type.
-             *
-             * The payload is moved into the RawPDU's internal buffer.
-             * 
-             * \param data The payload to use.
-             */
-            RawPDU(payload_type&& data)
-            : _payload(move(data)) { }
-        #endif // TINS_IS_CXX11
+    /** 
+     * \brief Creates an instance of RawPDU.
+     *
+     * The payload is copied, therefore the original payload's memory
+     * must be freed by the user.
+     * \param pload The payload which the RawPDU will contain.
+     * \param size The size of the payload.
+     */
+    RawPDU(const uint8_t* pload, uint32_t size);
+    
+    /**
+     * \brief Constructs a RawPDU from an iterator range.
+     *
+     * The data in the iterator range is copied into the RawPDU
+     * internal buffer.
+     *
+     * \param start The beginning of the iterator range.
+     * \param end The end of the iterator range.
+     */
+    template<typename ForwardIterator>
+    RawPDU(ForwardIterator start, ForwardIterator end) 
+    : payload_(start, end) { }
 
+    #if TINS_IS_CXX11
         /** 
-         * \brief Creates an instance of RawPDU from an input string.
+         * \brief Creates an instance of RawPDU from a payload_type.
+         *
+         * The payload is moved into the RawPDU's internal buffer.
          * 
-         * \param data The content of the payload.
+         * \param data The payload to use.
          */
-        RawPDU(const std::string &data);
+        RawPDU(payload_type&& data)
+        : payload_(move(data)) { }
+    #endif // TINS_IS_CXX11
 
-        /**
-         * \brief Setter for the payload field
-         * \param pload The payload to be set.
-         */
-        void payload(const payload_type &pload);
+    /** 
+     * \brief Creates an instance of RawPDU from an input string.
+     * 
+     * \param data The content of the payload.
+     */
+    RawPDU(const std::string& data);
 
-        /**
-         * \brief Setter for the payload field
-         * \param start The start of the new payload.
-         * \param end The end of the new payload.
-         */
-        template<typename ForwardIterator>
-        void payload(ForwardIterator start, ForwardIterator end) {
-            _payload.assign(start, end);
-        }
+    /**
+     * \brief Setter for the payload field
+     * \param pload The payload to be set.
+     */
+    void payload(const payload_type& pload);
 
-        /** 
-         * \brief Const getter for the payload.
-         * \return The RawPDU's payload.
-         */
-        const payload_type &payload() const { return _payload; }
-        
-        /** 
-         * \brief Non-const getter for the payload.
-         * \return The RawPDU's payload.
-         */
-        payload_type &payload() { return _payload; }
-        
-        /** 
-         * \brief Returns the header size.
-         * 
-         * This returns the same as RawPDU::payload_size().
-         *
-         * This metod overrides PDU::header_size. \sa PDU::header_size
-         */
-        uint32_t header_size() const;
-        
-        /** 
-         * \brief Returns the payload size.
-         *
-         * \return uint32_t containing the payload size.
-         */
-        uint32_t payload_size() const {
-            return static_cast<uint32_t>(_payload.size());
-        }
+    /**
+     * \brief Setter for the payload field
+     * \param start The start of the new payload.
+     * \param end The end of the new payload.
+     */
+    template<typename ForwardIterator>
+    void payload(ForwardIterator start, ForwardIterator end) {
+        payload_.assign(start, end);
+    }
 
-        /**
-         * \brief Check wether ptr points to a valid response for this PDU.
-         *
-         * This always returns true, since we don't know what this 
-         * RawPDU is holding.
-         * 
-         * \sa PDU::matches_response
-         * \param ptr The pointer to the buffer.
-         * \param total_sz The size of the buffer.
-         */
-        bool matches_response(const uint8_t *ptr, uint32_t total_sz) const;
+    /** 
+     * \brief Const getter for the payload.
+     * \return The RawPDU's payload.
+     */
+    const payload_type& payload() const {
+        return payload_;
+    }
+    
+    /** 
+     * \brief Non-const getter for the payload.
+     * \return The RawPDU's payload.
+     */
+    payload_type& payload() {
+        return payload_;
+    }
+    
+    /** 
+     * \brief Returns the header size.
+     * 
+     * This returns the same as RawPDU::payload_size().
+     *
+     * This metod overrides PDU::header_size. \sa PDU::header_size
+     */
+    uint32_t header_size() const;
+    
+    /** 
+     * \brief Returns the payload size.
+     *
+     * \return uint32_t containing the payload size.
+     */
+    uint32_t payload_size() const {
+        return static_cast<uint32_t>(payload_.size());
+    }
 
-        /**
-         * \brief Getter for the PDU's type.
-         * \sa PDU::pdu_type
-         */
-        PDUType pdu_type() const { return PDU::RAW; }
-        
-        /**
-         * \brief Constructs the given PDU type from the raw data stored
-         * in this RawPDU.
-         */
-        template<typename T>
-        T to() const {
-            return T(&_payload[0], static_cast<uint32_t>(_payload.size()));
-        }
-        
-        /**
-         * \sa PDU::clone
-         */
-        RawPDU *clone() const {
-            return new RawPDU(*this);
-        }
-    private:
-        void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
+    /**
+     * \brief Check wether ptr points to a valid response for this PDU.
+     *
+     * This always returns true, since we don't know what this 
+     * RawPDU is holding.
+     * 
+     * \sa PDU::matches_response
+     * \param ptr The pointer to the buffer.
+     * \param total_sz The size of the buffer.
+     */
+    bool matches_response(const uint8_t* ptr, uint32_t total_sz) const;
 
-        payload_type _payload;
-    };
-}
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
+    
+    /**
+     * \brief Constructs the given PDU type from the raw data stored
+     * in this RawPDU.
+     */
+    template<typename T>
+    T to() const {
+        return T(&payload_[0], static_cast<uint32_t>(payload_.size()));
+    }
+    
+    /**
+     * \sa PDU::clone
+     */
+    RawPDU* clone() const {
+        return new RawPDU(*this);
+    }
+private:
+    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
 
+    payload_type payload_;
+};
+
+} // Tins
 
 #endif // TINS_RAWPDU_H
diff --git a/include/tins/rsn_information.h b/include/tins/rsn_information.h
index a2e1b2c..7ba9fe6 100644
--- a/include/tins/rsn_information.h
+++ b/include/tins/rsn_information.h
@@ -92,7 +92,7 @@ public:
      * 
      * \param buffer The buffer from which to construct this object.
      */
-    RSNInformation(const serialization_type &buffer);
+    RSNInformation(const serialization_type& buffer);
     
     /**
      * \brief Constructs a RSNInformation from a buffer.
@@ -103,7 +103,7 @@ public:
      * \param buffer The buffer from which this object will be constructed.
      * \param total_sz The total size of the buffer.
      */
-    RSNInformation(const uint8_t *buffer, uint32_t total_sz);
+    RSNInformation(const uint8_t* buffer, uint32_t total_sz);
 
     /**
      * \brief Helper function to create a WPA2-PSK RSNInformation
@@ -149,32 +149,40 @@ public:
      * \return The group suite field.
      */
     CypherSuites group_suite() const { 
-        return static_cast<CypherSuites>(Endian::le_to_host<uint32_t>(_group_suite)); 
+        return static_cast<CypherSuites>(Endian::le_to_host<uint32_t>(group_suite_)); 
     }
 
     /**
      * \brief Getter for the version field.
      * \return The version field.
      */
-    uint16_t version() const { return Endian::le_to_host(_version); }
+    uint16_t version() const {
+        return Endian::le_to_host(version_);
+    }
     
     /**
      * \brief Getter for the capabilities field.
      * \return The version field.
      */
-    uint16_t capabilities() const { return Endian::le_to_host(_capabilities); }
+    uint16_t capabilities() const {
+        return Endian::le_to_host(capabilities_);
+    }
 
     /**
      * \brief Getter for the pairwise cypher suite list.
      * \return A list of pairwise cypher suites.
      */
-    const cyphers_type &pairwise_cyphers() const { return _pairwise_cyphers; }
+    const cyphers_type& pairwise_cyphers() const {
+        return pairwise_cyphers_;
+    }
 
     /**
      * \brief Getter for the akm suite list.
      * \return A list of akm suites.
      */
-    const akm_type &akm_cyphers() const { return _akm_cyphers; }
+    const akm_type& akm_cyphers() const {
+        return akm_cyphers_;
+    }
 
     /**
      * \brief Serializes this object.
@@ -185,14 +193,14 @@ public:
      /**
       * Constructs an RSNInformation object from a Dot11 tagged option.
       */
-     static RSNInformation from_option(const PDUOption<uint8_t, Dot11> &opt);
+     static RSNInformation from_option(const PDUOption<uint8_t, Dot11>& opt);
 private:
-    void init(const uint8_t *buffer, uint32_t total_sz);
+    void init(const uint8_t* buffer, uint32_t total_sz);
 
-    uint16_t _version, _capabilities;
-    CypherSuites _group_suite;
-    akm_type _akm_cyphers;
-    cyphers_type _pairwise_cyphers;
+    uint16_t version_, capabilities_;
+    CypherSuites group_suite_;
+    akm_type akm_cyphers_;
+    cyphers_type pairwise_cyphers_;
 };
 } // namespace Tins
 
diff --git a/include/tins/sll.h b/include/tins/sll.h
index 4a9a81a..901882e 100644
--- a/include/tins/sll.h
+++ b/include/tins/sll.h
@@ -37,6 +37,7 @@
 #include "hw_address.h"
 
 namespace Tins {
+
 /**
  * \class SLL
  * \brief Represents a Linux cooked-mode capture (SLL) PDU.
@@ -70,7 +71,7 @@ public:
      * \param buffer The buffer from which this PDU will be constructed.
      * \param total_sz The total size of the buffer.
      */
-    SLL(const uint8_t *buffer, uint32_t total_sz);
+    SLL(const uint8_t* buffer, uint32_t total_sz);
     
     // Getters
 
@@ -79,7 +80,7 @@ public:
      *  \return The stored Packet Type field value.
      */
     uint16_t packet_type() const {
-        return Endian::be_to_host(_header.packet_type);
+        return Endian::be_to_host(header_.packet_type);
     }
 
     /**
@@ -87,7 +88,7 @@ public:
      *  \return The stored LLADDR Type field value.
      */
     uint16_t lladdr_type() const {
-        return Endian::be_to_host(_header.lladdr_type);
+        return Endian::be_to_host(header_.lladdr_type);
     }
 
     /**
@@ -95,7 +96,7 @@ public:
      *  \return The stored LLADDR Length field value.
      */
     uint16_t lladdr_len() const {
-        return Endian::be_to_host(_header.lladdr_len);
+        return Endian::be_to_host(header_.lladdr_len);
     }
 
     /**
@@ -103,7 +104,7 @@ public:
      *  \return The stored Address field value.
      */
     address_type address() const {
-        return _header.address;
+        return header_.address;
     }
 
     /**
@@ -111,7 +112,7 @@ public:
      *  \return The stored Protocol field value.
      */
     uint16_t protocol() const {
-        return Endian::be_to_host(_header.protocol);
+        return Endian::be_to_host(header_.protocol);
     }
     
     /**
@@ -144,7 +145,7 @@ public:
      *  \brief Setter for the Address field.
      *  \param new_address The new Address field value.
      */
-    void address(const address_type &new_address);
+    void address(const address_type& new_address);
 
     /**
      *  \brief Setter for the Protocol field.
@@ -162,20 +163,20 @@ public:
     /**
      * \sa PDU::clone
      */
-    SLL *clone() const {
+    SLL* clone() const {
         return new SLL(*this);
     }
 private:
     TINS_BEGIN_PACK
-    struct sllhdr {
+    struct sll_header {
         uint16_t packet_type, lladdr_type, lladdr_len;
         uint8_t address[8];
         uint16_t protocol;
     } TINS_END_PACK;
     
-    void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU *);
     
-    sllhdr _header;
+    sll_header header_;
 };
 }
 
diff --git a/include/tins/small_uint.h b/include/tins/small_uint.h
index 4927267..a690708 100644
--- a/include/tins/small_uint.h
+++ b/include/tins/small_uint.h
@@ -36,7 +36,7 @@
 namespace Tins {
 class value_too_large : public std::exception {
 public:
-    const char *what() const throw() {
+    const char* what() const throw() {
         return "Value is too large";
     }
 };
@@ -112,8 +112,9 @@ public:
      * \param val The parameter from which to copy construct.
      */
     small_uint(repr_type val) {
-        if(val > max_value)
+        if (val > max_value) {
             throw value_too_large();
+        }
         value = val;
     }
     
@@ -127,5 +128,6 @@ private:
     repr_type value;
 };
 
-} // namespace Tins
+} // Tins
+
 #endif // TINS_SMALL_UINT_H
diff --git a/include/tins/snap.h b/include/tins/snap.h
index 6fdcf65..489bf02 100644
--- a/include/tins/snap.h
+++ b/include/tins/snap.h
@@ -39,140 +39,149 @@
 
 namespace Tins {
 
+/**
+ * \class SNAP
+ * \brief Represents a SNAP frame.
+ * 
+ * Note that this PDU contains the 802.3 LLC structure + SNAP frame.
+ * So far only unnumbered information structure is supported.
+ */
+class TINS_API SNAP : public PDU {
+public:
     /**
-     * \class SNAP
-     * \brief Represents a SNAP frame.
-     * 
-     * Note that this PDU contains the 802.3 LLC structure + SNAP frame.
-     * So far only unnumbered information structure is supported.
+     * \brief This PDU's flag.
      */
-    class TINS_API SNAP : public PDU {
-    public:
-        /**
-         * \brief This PDU's flag.
-         */
-        static const PDU::PDUType pdu_flag = PDU::SNAP;
+    static const PDU::PDUType pdu_flag = PDU::SNAP;
+
+    /**
+     * \brief Creates an instance of SNAP
+     * This constructor sets the dsap and ssap fields to 0xaa, and
+     * the id field to 3.
+     */
+    SNAP();
     
-        /**
-         * \brief Creates an instance of SNAP
-         * This constructor sets the dsap and ssap fields to 0xaa, and
-         * the id field to 3.
-         */
-        SNAP();
-        
-        /**
-         * \brief Constructs a SNAP object from a buffer and adds all 
-         * identifiable PDUs found in the buffer as children of this one.
-         * 
-         * If the next PDU is not recognized, then a RawPDU is used.
-         * 
-         * If there is not enough size for a SNAP header in the 
-         * buffer, a malformed_packet exception is thrown.
-         * 
-         * \param buffer The buffer from which this PDU will be constructed.
-         * \param total_sz The total size of the buffer.
-         */
-        SNAP(const uint8_t *buffer, uint32_t total_sz);
-        
-        /* Setters */
-        
-        /**
-         * \brief Setter for the Control field.
-         * \param new_id The new Control to be set.
-         */
-        void control(uint8_t new_control);
-        
-        /**
-         * \brief Setter for the Organization Code field.
-         * \param new_org The new Organization Code to be set.
-         */
-        void org_code(small_uint<24> new_org);
-        
-        /**
-         * \brief Setter for the Ethernet Type field.
-         * \param new_eth The new Ethernet Type to be set.
-         */
-        void eth_type(uint16_t new_eth);
-        
-        /* Getters */
-        
-        /**
-         * \brief Getter for the DSAP field.
-         * \return The DSAP field.
-         */
-        uint8_t dsap() const { return _snap.dsap; }
-        
-        /**
-         * \brief Getter for the SSAP field.
-         * \return The SSAP field.
-         */
-        uint8_t ssap() const { return _snap.ssap; }
-        
-        /**
-         * \brief Getter for the Control field.
-         * \return The Control field.
-         */
-        uint8_t control() const { 
-            #if TINS_IS_LITTLE_ENDIAN
-            return (_snap.control_org) & 0xff; 
-            #else
-            return (_snap.control_org >> 24) & 0xff; 
-            #endif
-        }
-        
-        /**
-         * \brief Getter for the Organization Code field.
-         * \return The Organization Code field.
-         */        
-        small_uint<24> org_code() const { 
-            #if TINS_IS_LITTLE_ENDIAN
-            return Endian::be_to_host<uint32_t>(_snap.control_org & 0xffffff00);
-            #else
-            return _snap.control_org & 0xffffff;
-            #endif
-        }
-        
-        /**
-         * \brief Getter for the Ethernet Type field.
-         * \return The Ethernet Type field.
-         */
-        uint16_t eth_type() const { return Endian::be_to_host(_snap.eth_type); } 
-        
-        /**
-         * \brief Returns the SNAP frame's header length.
-         *
-         * \return The header's size.
-         * \sa PDU::header_size()
-         */
-        uint32_t header_size() const;
-        
-        /**
-         * \brief Getter for the PDU's type.
-         * \sa PDU::pdu_type
-         */
-        PDUType pdu_type() const { return pdu_flag; }
-        
-        /**
-         * \brief Clones this PDU.
-         * 
-         * \sa PDU::clone
-         */
-        SNAP *clone() const {
-            return new SNAP(*this);
-        }    
-    private:
-        TINS_BEGIN_PACK
-        struct snaphdr {
-            uint8_t dsap;
-            uint8_t ssap;
-            uint32_t control_org;
-            uint16_t eth_type;
-        } TINS_END_PACK;
-        
-        void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
-        
-        snaphdr _snap;
-    };
-}
+    /**
+     * \brief Constructs a SNAP object from a buffer and adds all 
+     * identifiable PDUs found in the buffer as children of this one.
+     * 
+     * If the next PDU is not recognized, then a RawPDU is used.
+     * 
+     * If there is not enough size for a SNAP header in the 
+     * buffer, a malformed_packet exception is thrown.
+     * 
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    SNAP(const uint8_t* buffer, uint32_t total_sz);
+    
+    /* Setters */
+    
+    /**
+     * \brief Setter for the Control field.
+     * \param new_id The new Control to be set.
+     */
+    void control(uint8_t new_control);
+    
+    /**
+     * \brief Setter for the Organization Code field.
+     * \param new_org The new Organization Code to be set.
+     */
+    void org_code(small_uint<24> new_org);
+    
+    /**
+     * \brief Setter for the Ethernet Type field.
+     * \param new_eth The new Ethernet Type to be set.
+     */
+    void eth_type(uint16_t new_eth);
+    
+    /* Getters */
+    
+    /**
+     * \brief Getter for the DSAP field.
+     * \return The DSAP field.
+     */
+    uint8_t dsap() const {
+        return snap_.dsap;
+    }
+    
+    /**
+     * \brief Getter for the SSAP field.
+     * \return The SSAP field.
+     */
+    uint8_t ssap() const {
+        return snap_.ssap;
+    }
+    
+    /**
+     * \brief Getter for the Control field.
+     * \return The Control field.
+     */
+    uint8_t control() const { 
+        #if TINS_IS_LITTLE_ENDIAN
+        return (snap_.control_org) & 0xff; 
+        #else
+        return (snap_.control_org >> 24) & 0xff; 
+        #endif
+    }
+    
+    /**
+     * \brief Getter for the Organization Code field.
+     * \return The Organization Code field.
+     */        
+    small_uint<24> org_code() const { 
+        #if TINS_IS_LITTLE_ENDIAN
+        return Endian::be_to_host<uint32_t>(snap_.control_org & 0xffffff00);
+        #else
+        return snap_.control_org & 0xffffff;
+        #endif
+    }
+    
+    /**
+     * \brief Getter for the Ethernet Type field.
+     * \return The Ethernet Type field.
+     */
+    uint16_t eth_type() const {
+        return Endian::be_to_host(snap_.eth_type);
+    }
+    
+    /**
+     * \brief Returns the SNAP frame's header length.
+     *
+     * \return The header's size.
+     * \sa PDU::header_size()
+     */
+    uint32_t header_size() const;
+    
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
+    
+    /**
+     * \brief Clones this PDU.
+     * 
+     * \sa PDU::clone
+     */
+    SNAP* clone() const {
+        return new SNAP(*this);
+    }    
+private:
+    TINS_BEGIN_PACK
+    struct snap_header {
+        uint8_t dsap;
+        uint8_t ssap;
+        uint32_t control_org;
+        uint16_t eth_type;
+    } TINS_END_PACK;
+    
+    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
+    
+    snap_header snap_;
+};
+
+} // Tins
 
 #endif // TINS_SNAP_H
diff --git a/include/tins/sniffer.h b/include/tins/sniffer.h
index b87a403..d336c00 100644
--- a/include/tins/sniffer.h
+++ b/include/tins/sniffer.h
@@ -45,579 +45,583 @@
 #include "internals.h"
 
 namespace Tins {
-    class SnifferIterator;
-    class SnifferConfiguration;
+class SnifferIterator;
+class SnifferConfiguration;
 
+/**
+ * \class BaseSniffer
+ * \brief Base class for sniffers.
+ *
+ * This class implements the basic sniffing operations. Subclasses
+ * should only initialize this object using a pcap_t pointer, which
+ * will be used to extract packets.
+ *
+ * Initialization must be done using the BaseSniffer::init method.
+ */
+class TINS_API BaseSniffer {
+public:
     /**
-     * \class BaseSniffer
-     * \brief Base class for sniffers.
-     *
-     * This class implements the basic sniffing operations. Subclasses
-     * should only initialize this object using a pcap_t pointer, which
-     * will be used to extract packets.
-     *
-     * Initialization must be done using the BaseSniffer::init method.
+     * The iterator type.
      */
-    class TINS_API BaseSniffer {
-    public:
+    typedef SnifferIterator iterator;
+
+    #if TINS_IS_CXX11
         /**
-         * The iterator type.
+         * \brief Move constructor.
+         * This constructor is available only in C++11.
          */
-        typedef SnifferIterator iterator;
-
-        #if TINS_IS_CXX11
-            /**
-             * \brief Move constructor.
-             * This constructor is available only in C++11.
-             */
-            BaseSniffer(BaseSniffer &&rhs) TINS_NOEXCEPT
-            : handle(nullptr), mask()
-            {
-                *this = std::move(rhs);
-            }
-
-            /**
-             * \brief Move assignment operator.
-             * This operator is available only in C++11.
-             */
-            BaseSniffer& operator=(BaseSniffer &&rhs) TINS_NOEXCEPT
-            {
-                using std::swap;
-                swap(handle, rhs.handle);
-                swap(mask, rhs.mask);
-                return *this;
-            }
-        #endif
-
-        /**
-         * \brief Sniffer destructor.
-         * This frees all memory used by the pcap handle.
-         */
-        virtual ~BaseSniffer();
-
-        /**
-         * \brief Compiles a filter and uses it to capture one packet.
-         *
-         * This method returns the first valid sniffed packet that matches the
-         * sniffer's filter, or the first sniffed packet if no filter has
-         * been set.
-         *
-         * The return type is a thin wrapper over a PDU* and a Timestamp
-         * object. This wrapper can be both implicitly converted to a
-         * PDU* and a Packet object. So doing this:
-         *
-         * \code
-         * Sniffer s(...);
-         * std::unique_ptr<PDU> pdu(s.next_packet());
-         * // Packet takes care of the PDU*.
-         * Packet packet(s.next_packet());
-         * \endcode
-         *
-         * Is fine, but this:
-         *
-         * \code
-         * // bad!!
-         * PtrPacket p = s.next_packet();
-         * \endcode
-         *
-         * Is not, since PtrPacket can't be copy constructed.
-         *
-         * \sa Packet::release_pdu
-         *
-         * \return A captured packet. If an error occured, PtrPacket::pdu
-         * will return 0. Caller takes ownership of the PDU pointer stored in
-         * the PtrPacket.
-         */
-        PtrPacket next_packet();
-
-        /**
-         * \brief Starts a sniffing loop, using a callback functor for every
-         * sniffed packet.
-         *
-         * The functor must implement an operator with one of the
-         * following signatures:
-         *
-         * \code
-         * bool(PDU&);
-         * bool(const PDU&);
-         *
-         * // These two are only allowed when compiling in C++11 mode
-         * bool(Packet&);
-         * bool(const Packet&);
-         * \endcode
-         *
-         * This functor will be called using the each of the sniffed packets
-         * as its argument. Using PDU member functions that modify the PDU,
-         * such as PDU::release_inner_pdu, is perfectly valid.
-         *
-         * Note that if you're using a functor object, it will be copied using
-         * its copy constructor, so it should be some kind of proxy to
-         * another object which will process the packets(e.g. std::bind).
-         *
-         * Sniffing will stop when either max_packets are sniffed(if it is != 0),
-         * or when the functor returns false.
-         *
-         * Note that the pcap handle stored in a BaseSniffer will always be the
-         * same. This means that if you start sniffing using sniff_loop, then stop
-         * and at some point in the future you call sniff_loop again, you will keep 
-         * iterating over the same handle. If the handle points to a pcap file, then
-         * you will continue processing packets from it. If the handle points to 
-         * a network device, you will keep sniffing from it.
-         *
-         * This method catches both malformed_packet and pdu_not_found exceptions,
-         * which allows writing much cleaner code, since you can call PDU::rfind_pdu
-         * without worrying about catching the exception that can be thrown. This
-         * allows writing code such as the following:
-         *
-        * \code
-         * bool callback(const PDU& pdu) {
-         *     // If either RawPDU is not found, or construction of the DNS
-         *     // object fails, the BaseSniffer object will trap the exceptions,
-         *     // so we don't need to worry about it.
-         *     DNS dns = pdu.rfind_pdu<RawPDU>().to<DNS>();
-         *     return true;
-         * }
-         * \endcode
-         *
-         * \param function The callback handler object which should process packets.
-         * \param max_packets The maximum amount of packets to sniff. 0 == infinite.
-         */
-        template<class Functor>
-        void sniff_loop(Functor function, uint32_t max_packets = 0);
-
-        /**
-         * \brief Sets a filter on this sniffer.
-         * \param filter The filter to be set.
-         * \return True iif it was possible to apply the filter.
-         */
-        bool set_filter(const std::string &filter);
-
-        /**
-         * \brief Stops sniffing loops.
-         *
-         * This method must be called from the same thread from which
-         * BaseSniffer::sniff_loop was called.
-         */
-        void stop_sniff();
-
-        /**
-         * \brief Gets the file descriptor associated with the sniffer.
-         */
-        int get_fd();
-
-        /**
-         * \brief Sets the read timeout for this sniffer.
-         *
-         * This calls pcap_set_timeout using the provided parameter.
-         * \param ms The amount of milliseconds.
-         */
-        void set_timeout(int ms);
-
-        /**
-         * \brief Sets whether to extract RawPDUs or fully parsed packets.
-         *
-         * By default, packets will be parsed starting from link layer.
-         * However, if you're parsing a lot of traffic, then you might
-         * want to extract packets and push them into a queue,
-         * so a consumer can parse them when they're popped.
-         *
-         * This method allows doing that. If the parameter is true,
-         * then packets taken from this BaseSniffer will only contain
-         * a RawPDU which will have to entire contents of the packet.
-         *
-         * \param value Whether to extract RawPDUs or not.
-         */
-        void set_extract_raw_pdus(bool value);
-
-        /**
-         * \brief Retrieves this sniffer's link type.
-         *
-         * This calls pcap_datalink on the stored pcap handle and
-         * returns its result.
-         */
-        int link_type() const;
-
-        /**
-         * Retrieves an iterator to the next packet in this sniffer.
-         */
-        iterator begin();
-
-        /**
-         * Retrieves an end iterator.
-         */
-        iterator end();
-
-        /**
-         * Retrieves the pcap handle used by this sniffer.
-         */
-        pcap_t* get_pcap_handle();
-
-        /**
-         * Retrieves the pcap handle used by this sniffer.
-         */
-        const pcap_t* get_pcap_handle() const;
-    protected:
-        /**
-         * Default constructor.
-         */
-        BaseSniffer();
-
-        void set_pcap_handle(pcap_t* const pcap_handle);
-
-        void set_if_mask(bpf_u_int32 if_mask);
-
-        bpf_u_int32 get_if_mask() const;
-    private:
-        BaseSniffer(const BaseSniffer&);
-        BaseSniffer &operator=(const BaseSniffer&);
-
-        pcap_t *handle;
-        bpf_u_int32 mask;
-        bool extract_raw;
-    };
-
-    /**
-     * \class Sniffer
-     * \brief Sniffs packets from a network interface.
-     */
-    class TINS_API Sniffer : public BaseSniffer {
-    public:
-        /**
-         * \deprecated This enum is no longer necessary. You should use the
-         * Sniffer(const std::string&, const SnifferConfiguration&) constructor.
-         */
-        enum promisc_type {
-            NON_PROMISC,
-            PROMISC
-        };
-
-        /**
-         * \brief Constructs an instance of Sniffer using the provided configuration.
-         *
-         * This constructor was added as a way to improve the parameter bloat
-         * introduced by the other ones available. You should create an instance
-         * of SnifferConfiguration, set the desired parameters, and then use it
-         * when constructing a Sniffer object.
-         *
-         * \sa SnifferConfiguration
-         *
-         * \param device The device which will be sniffed.
-         * \param configuration The configuration object to use to setup the sniffer.
-         */
-        Sniffer(const std::string &device, const SnifferConfiguration& configuration);
-
-        /**
-         * \brief Constructs an instance of Sniffer.
-         *
-         * By default the interface won't be put into promiscuous mode, and won't
-         * be put into monitor mode.
-         *
-         * \deprecated Use the Sniffer(const std::string&, const SnifferConfiguration&)
-         * constructor.
-         * \param device The device which will be sniffed.
-         * \param max_packet_size The maximum packet size to be read.
-         * \param promisc bool indicating wether to put the interface in promiscuous mode.(optional)
-         * \param filter A capture filter to be used on the sniffing session.(optional);
-         * \param rfmon Indicates if the interface should be put in monitor mode.(optional);
-         */
-        Sniffer(const std::string &device, unsigned max_packet_size,
-          bool promisc = false, const std::string &filter = "", bool rfmon = false);
-
-        /**
-         * \brief Constructs an instance of Sniffer.
-         *
-         * The maximum capture size is set to 65535. By default the interface won't
-         * be put into promiscuous mode, and won't be put into monitor mode.
-         *
-         * \deprecated Use the Sniffer(const std::string&, const SnifferConfiguration&)
-         * constructor.
-         * \param device The device which will be sniffed.
-         * \param promisc Indicates if the interface should be put in promiscuous mode.
-         * \param filter A capture filter to be used on the sniffing session.(optional);
-         * \param rfmon Indicates if the interface should be put in monitor mode.(optional);
-         */
-        Sniffer(const std::string &device, promisc_type promisc = NON_PROMISC,
-          const std::string &filter = "", bool rfmon = false);
-
-    private:
-        friend class SnifferConfiguration;
-
-        void set_snap_len(unsigned snap_len);
-
-        void set_buffer_size(unsigned buffer_size);
-
-        void set_promisc_mode(bool promisc_enabled);
-
-        void set_rfmon(bool rfmon_enabled);
-
-        void set_immediate_mode(bool enabled);
-    };
-
-    /**
-     * \class FileSniffer
-     * \brief Reads pcap files and interprets the packets in it.
-     *
-     * This class acts exactly in the same way that Sniffer, but reads
-     * packets from a pcap file instead of an interface.
-     */
-    class TINS_API FileSniffer : public BaseSniffer {
-    public:
-        /**
-         * \brief Constructs an instance of FileSniffer.
-         * \param file_name The pcap file which will be parsed.
-         * \param filter A capture filter to be used on the file.(optional);
-         */
-        FileSniffer(const std::string &file_name, const SnifferConfiguration& configuration);
-
-        /**
-         * \deprecated Use the constructor that takes a SnifferConfiguration instead.
-         *
-         * \brief Constructs an instance of FileSniffer.
-         * \param file_name The pcap file which will be parsed.
-         * \param filter A capture filter to be used on the file.(optional);
-         */
-        FileSniffer(const std::string &file_name, const std::string &filter = "");
-    };
-
-    template<class T>
-    class HandlerProxy {
-    public:
-        typedef T* ptr_type;
-        typedef bool (T::*fun_type)(PDU&) ;
-
-        HandlerProxy(ptr_type ptr, fun_type function)
-        : object(ptr), fun(function) {}
-
-        bool operator()(PDU &pdu) {
-            return (object->*fun)(pdu);
+        BaseSniffer(BaseSniffer &&rhs) TINS_NOEXCEPT
+        : handle_(nullptr), mask_(), extract_raw_(false) {
+            *this = std::move(rhs);
         }
-    private:
-        ptr_type object;
-        fun_type fun;
+
+        /**
+         * \brief Move assignment operator.
+         * This operator is available only in C++11.
+         */
+        BaseSniffer& operator=(BaseSniffer &&rhs) TINS_NOEXCEPT {
+            using std::swap;
+            swap(handle_, rhs.handle_);
+            swap(mask_, rhs.mask_);
+            swap(extract_raw_, rhs.extract_raw_);
+            return* this;
+        }
+    #endif
+
+    /**
+     * \brief Sniffer destructor.
+     * This frees all memory used by the pcap handle.
+     */
+    virtual ~BaseSniffer();
+
+    /**
+     * \brief Compiles a filter and uses it to capture one packet.
+     *
+     * This method returns the first valid sniffed packet that matches the
+     * sniffer's filter, or the first sniffed packet if no filter has
+     * been set.
+     *
+     * The return type is a thin wrapper over a PDU* and a Timestamp
+     * object. This wrapper can be both implicitly converted to a
+     * PDU* and a Packet object. So doing this:
+     *
+     * \code
+     * Sniffer s(...);
+     * std::unique_ptr<PDU> pdu(s.next_packet());
+     * // Packet takes care of the PDU*.
+     * Packet packet(s.next_packet());
+     * \endcode
+     *
+     * Is fine, but this:
+     *
+     * \code
+     * // bad!!
+     * PtrPacket p = s.next_packet();
+     * \endcode
+     *
+     * Is not, since PtrPacket can't be copy constructed.
+     *
+     * \sa Packet::release_pdu
+     *
+     * \return A captured packet. If an error occured, PtrPacket::pdu
+     * will return 0. Caller takes ownership of the PDU pointer stored in
+     * the PtrPacket.
+     */
+    PtrPacket next_packet();
+
+    /**
+     * \brief Starts a sniffing loop, using a callback functor for every
+     * sniffed packet.
+     *
+     * The functor must implement an operator with one of the
+     * following signatures:
+     *
+     * \code
+     * bool(PDU&);
+     * bool(const PDU&);
+     *
+     * // These two are only allowed when compiling in C++11 mode
+     * bool(Packet&);
+     * bool(const Packet&);
+     * \endcode
+     *
+     * This functor will be called using the each of the sniffed packets
+     * as its argument. Using PDU member functions that modify the PDU,
+     * such as PDU::release_inner_pdu, is perfectly valid.
+     *
+     * Note that if you're using a functor object, it will be copied using
+     * its copy constructor, so it should be some kind of proxy to
+     * another object which will process the packets(e.g. std::bind).
+     *
+     * Sniffing will stop when either max_packets are sniffed(if it is != 0),
+     * or when the functor returns false.
+     *
+     * Note that the pcap handle stored in a BaseSniffer will always be the
+     * same. This means that if you start sniffing using sniff_loop, then stop
+     * and at some point in the future you call sniff_loop again, you will keep 
+     * iterating over the same handle. If the handle points to a pcap file, then
+     * you will continue processing packets from it. If the handle points to 
+     * a network device, you will keep sniffing from it.
+     *
+     * This method catches both malformed_packet and pdu_not_found exceptions,
+     * which allows writing much cleaner code, since you can call PDU::rfind_pdu
+     * without worrying about catching the exception that can be thrown. This
+     * allows writing code such as the following:
+     *
+    * \code
+     * bool callback(const PDU& pdu) {
+     *     // If either RawPDU is not found, or construction of the DNS
+     *     // object fails, the BaseSniffer object will trap the exceptions,
+     *     // so we don't need to worry about it.
+     *     DNS dns = pdu.rfind_pdu<RawPDU>().to<DNS>();
+     *     return true;
+     * }
+     * \endcode
+     *
+     * \param function The callback handler object which should process packets.
+     * \param max_packets The maximum amount of packets to sniff. 0 == infinite.
+     */
+    template<class Functor>
+    void sniff_loop(Functor function, uint32_t max_packets = 0);
+
+    /**
+     * \brief Sets a filter on this sniffer.
+     * \param filter The filter to be set.
+     * \return True iif it was possible to apply the filter.
+     */
+    bool set_filter(const std::string& filter);
+
+    /**
+     * \brief Stops sniffing loops.
+     *
+     * This method must be called from the same thread from which
+     * BaseSniffer::sniff_loop was called.
+     */
+    void stop_sniff();
+
+    /**
+     * \brief Gets the file descriptor associated with the sniffer.
+     */
+    int get_fd();
+
+    /**
+     * \brief Sets the read timeout for this sniffer.
+     *
+     * This calls pcap_set_timeout using the provided parameter.
+     * \param ms The amount of milliseconds.
+     */
+    void set_timeout(int ms);
+
+    /**
+     * \brief Sets whether to extract RawPDUs or fully parsed packets.
+     *
+     * By default, packets will be parsed starting from link layer.
+     * However, if you're parsing a lot of traffic, then you might
+     * want to extract packets and push them into a queue,
+     * so a consumer can parse them when they're popped.
+     *
+     * This method allows doing that. If the parameter is true,
+     * then packets taken from this BaseSniffer will only contain
+     * a RawPDU which will have to entire contents of the packet.
+     *
+     * \param value Whether to extract RawPDUs or not.
+     */
+    void set_extract_raw_pdus(bool value);
+
+    /**
+     * \brief Retrieves this sniffer's link type.
+     *
+     * This calls pcap_datalink on the stored pcap handle and
+     * returns its result.
+     */
+    int link_type() const;
+
+    /**
+     * Retrieves an iterator to the next packet in this sniffer.
+     */
+    iterator begin();
+
+    /**
+     * Retrieves an end iterator.
+     */
+    iterator end();
+
+    /**
+     * Retrieves the pcap handle used by this sniffer.
+     */
+    pcap_t* get_pcap_handle();
+
+    /**
+     * Retrieves the pcap handle used by this sniffer.
+     */
+    const pcap_t* get_pcap_handle() const;
+protected:
+    /**
+     * Default constructor.
+     */
+    BaseSniffer();
+
+    void set_pcap_handle(pcap_t* pcap_handle);
+
+    void set_if_mask(bpf_u_int32 if_mask);
+
+    bpf_u_int32 get_if_mask() const;
+private:
+    BaseSniffer(const BaseSniffer&);
+    BaseSniffer& operator=(const BaseSniffer&);
+
+    pcap_t* handle_;
+    bpf_u_int32 mask_;
+    bool extract_raw_;
+};
+
+/**
+ * \class Sniffer
+ * \brief Sniffs packets from a network interface.
+ */
+class TINS_API Sniffer : public BaseSniffer {
+public:
+    /**
+     * \deprecated This enum is no longer necessary. You should use the
+     * Sniffer(const std::string&, const SnifferConfiguration&) constructor.
+     */
+    enum promisc_type {
+        NON_PROMISC,
+        PROMISC
     };
 
-    template<class T>
-    HandlerProxy<T> make_sniffer_handler(T *ptr, typename HandlerProxy<T>::fun_type function)
-    {
-        return HandlerProxy<T>(ptr, function);
+    /**
+     * \brief Constructs an instance of Sniffer using the provided configuration.
+     *
+     * This constructor was added as a way to improve the parameter bloat
+     * introduced by the other ones available. You should create an instance
+     * of SnifferConfiguration, set the desired parameters, and then use it
+     * when constructing a Sniffer object.
+     *
+     * \sa SnifferConfiguration
+     *
+     * \param device The device which will be sniffed.
+     * \param configuration The configuration object to use to setup the sniffer.
+     */
+    Sniffer(const std::string& device, const SnifferConfiguration& configuration);
+
+    /**
+     * \brief Constructs an instance of Sniffer.
+     *
+     * By default the interface won't be put into promiscuous mode, and won't
+     * be put into monitor mode.
+     *
+     * \deprecated Use the Sniffer(const std::string&, const SnifferConfiguration&)
+     * constructor.
+     * \param device The device which will be sniffed.
+     * \param max_packet_size The maximum packet size to be read.
+     * \param promisc bool indicating wether to put the interface in promiscuous mode.(optional)
+     * \param filter A capture filter to be used on the sniffing session.(optional);
+     * \param rfmon Indicates if the interface should be put in monitor mode.(optional);
+     */
+    Sniffer(const std::string& device, unsigned max_packet_size,
+      bool promisc = false, const std::string& filter = "", bool rfmon = false);
+
+    /**
+     * \brief Constructs an instance of Sniffer.
+     *
+     * The maximum capture size is set to 65535. By default the interface won't
+     * be put into promiscuous mode, and won't be put into monitor mode.
+     *
+     * \deprecated Use the Sniffer(const std::string&, const SnifferConfiguration&)
+     * constructor.
+     * \param device The device which will be sniffed.
+     * \param promisc Indicates if the interface should be put in promiscuous mode.
+     * \param filter A capture filter to be used on the sniffing session.(optional);
+     * \param rfmon Indicates if the interface should be put in monitor mode.(optional);
+     */
+    Sniffer(const std::string& device, promisc_type promisc = NON_PROMISC,
+      const std::string& filter = "", bool rfmon = false);
+
+private:
+    friend class SnifferConfiguration;
+
+    void set_snap_len(unsigned snap_len);
+
+    void set_buffer_size(unsigned buffer_size);
+
+    void set_promisc_mode(bool promisc_enabled);
+
+    void set_rfmon(bool rfmon_enabled);
+
+    void set_immediate_mode(bool enabled);
+};
+
+/**
+ * \class FileSniffer
+ * \brief Reads pcap files and interprets the packets in it.
+ *
+ * This class acts exactly in the same way that Sniffer, but reads
+ * packets from a pcap file instead of an interface.
+ */
+class TINS_API FileSniffer : public BaseSniffer {
+public:
+    /**
+     * \brief Constructs an instance of FileSniffer.
+     * \param file_name The pcap file which will be parsed.
+     * \param filter A capture filter to be used on the file.(optional);
+     */
+    FileSniffer(const std::string& file_name, const SnifferConfiguration& configuration);
+
+    /**
+     * \deprecated Use the constructor that takes a SnifferConfiguration instead.
+     *
+     * \brief Constructs an instance of FileSniffer.
+     * \param file_name The pcap file which will be parsed.
+     * \param filter A capture filter to be used on the file.(optional);
+     */
+    FileSniffer(const std::string& file_name, const std::string& filter = "");
+};
+
+template<class T>
+class HandlerProxy {
+public:
+    typedef T* ptr_type;
+    typedef bool (T::*fun_type)(PDU&) ;
+
+    HandlerProxy(ptr_type ptr, fun_type function)
+    : object_(ptr), fun_(function) {}
+
+    bool operator()(PDU& pdu) {
+        return (object_->*fun_)(pdu);
+    }
+private:
+    ptr_type object_;
+    fun_type fun_;
+};
+
+template<class T>
+HandlerProxy<T> make_sniffer_handler(T* ptr, 
+                                     typename HandlerProxy<T>::fun_type function) {
+    return HandlerProxy<T>(ptr, function);
+}
+
+/**
+ * \brief Iterates over packets sniffed by a BaseSniffer.
+ */
+class SnifferIterator : public std::iterator<std::forward_iterator_tag, Packet> {
+public:
+    /**
+     * Constructs a SnifferIterator.
+     * \param sniffer The sniffer to iterate.
+     */
+    SnifferIterator(BaseSniffer* sniffer = 0)
+    : sniffer_(sniffer) {
+        if (sniffer_) {
+            advance();
+        }
     }
 
     /**
-     * \brief Iterates over packets sniffed by a BaseSniffer.
+     * Advances the iterator.
      */
-    class SnifferIterator : public std::iterator<std::forward_iterator_tag, Packet> {
-    public:
-        /**
-         * Constructs a SnifferIterator.
-         * \param sniffer The sniffer to iterate.
-         */
-        SnifferIterator(BaseSniffer *sniffer = 0)
-        : sniffer(sniffer)
-        {
-            if(sniffer)
-                advance();
-        }
-
-        /**
-         * Advances the iterator.
-         */
-        SnifferIterator& operator++() {
-            advance();
-            return *this;
-        }
-
-        /**
-         * Advances the iterator.
-         */
-        SnifferIterator operator++(int) {
-            SnifferIterator other(*this);
-            advance();
-            return other;
-        }
-
-        /**
-         * Dereferences the iterator.
-         * \return reference to the current packet.
-         */
-        Packet &operator*() {
-            return pkt;
-        }
-
-        /**
-         * Dereferences the iterator.
-         * \return pointer to the current packet.
-         */
-        Packet *operator->() {
-            return &(**this);
-        }
-
-        /**
-         * Compares this iterator for equality.
-         * \param rhs The iterator to be compared to.
-         */
-        bool operator==(const SnifferIterator &rhs) const {
-            return sniffer == rhs.sniffer;
-        }
-
-        /**
-         * Compares this iterator for in-equality.
-         * \param rhs The iterator to be compared to.
-         */
-        bool operator!=(const SnifferIterator &rhs) const {
-            return !(*this == rhs);
-        }
-    private:
-        void advance() {
-            pkt = sniffer->next_packet();
-            if(!pkt)
-                sniffer = 0;
-        }
-
-        BaseSniffer *sniffer;
-        Packet pkt;
-    };
+    SnifferIterator& operator++() {
+        advance();
+        return* this;
+    }
 
     /**
-     * \class SnifferConfiguration
-     * \brief Represents the configuration of a BaseSniffer object.
-     *
-     * This class can be used as an easy way to configure a Sniffer
-     * or FileSniffer object.
-     *
-     * It can be used by constructing an object of this type,
-     * setting the desired values and then passing it to the
-     * Sniffer or FileSniffer object's constructor. This sets
-     * default values for some attributes:
-     *
-     * - Snapshot length: 65535 bytes (64 KB).
-     * - Timeout: 1000 milliseconds.
-     * - Promiscuous mode: false.
-     *
-     * For any of the attributes not listed above, the associated
-     * pcap function which is used to set them on a pcap handle
-     * won't be called at all.
-     *
-     * This class can be used to configure a Sniffer object,
-     * like this:
-     *
-     * \code
-     * // Initialize the configuration.
-     * SnifferConfiguration config;
-     * config.set_filter("ip and port 80");
-     * config.set_promisc_mode(true);
-     *
-     * // Use it on a Sniffer object.
-     * Sniffer sniffer("eth0", config);
-     * \endcode
+     * Advances the iterator.
      */
-    class TINS_API SnifferConfiguration {
-    public:
-        /**
-         * \brief The default snapshot length.
-         *
-         * This is 65535 by default.
-         */
-        static const unsigned DEFAULT_SNAP_LEN;
+    SnifferIterator operator++(int) {
+        SnifferIterator other(*this);
+        advance();
+        return other;
+    }
 
-        /**
-         * \brief The default timeout.
-         *
-         * This is 1000 by default.
-         */
-        static const unsigned DEFAULT_TIMEOUT;
+    /**
+     * Dereferences the iterator.
+     * \return reference to the current packet.
+     */
+    Packet& operator*() {
+        return pkt_;
+    }
 
-        /**
-         * Default constructs a SnifferConfiguration.
-         */
-        SnifferConfiguration();
+    /**
+     * Dereferences the iterator.
+     * \return pointer to the current packet.
+     */
+    Packet* operator->() {
+        return &(**this);
+    }
 
-        /**
-         * Sets the snapshot length option.
-         * \param snap_len The snapshot length to be set.
-         */
-        void set_snap_len(unsigned snap_len);
+    /**
+     * Compares this iterator for equality.
+     * \param rhs The iterator to be compared to.
+     */
+    bool operator==(const SnifferIterator& rhs) const {
+        return sniffer_ == rhs.sniffer_;
+    }
 
-        /**
-         * Sets the buffer size option.
-         * \param buffer_size The buffer size to be set.
-         */
-        void set_buffer_size(unsigned buffer_size);
+    /**
+     * Compares this iterator for in-equality.
+     * \param rhs The iterator to be compared to.
+     */
+    bool operator!=(const SnifferIterator& rhs) const {
+        return !(*this == rhs);
+    }
+private:
+    void advance() {
+        pkt_ = sniffer_->next_packet();
+        if (!pkt_) {
+            sniffer_ = 0;
+        }
+    }
 
-        /**
-         * Sets the promiscuous mode option.
-         * \param enabled The promiscuous mode value.
-         */
-        void set_promisc_mode(bool enabled);
+    BaseSniffer* sniffer_;
+    Packet pkt_;
+};
 
-        /**
-         * Sets a pcap filter to use on the sniffer.
-         * \param filter The pcap filter to be used.
-         */
-        void set_filter(const std::string& filter);
+/**
+ * \class SnifferConfiguration
+ * \brief Represents the configuration of a BaseSniffer object.
+ *
+ * This class can be used as an easy way to configure a Sniffer
+ * or FileSniffer object.
+ *
+ * It can be used by constructing an object of this type,
+ * setting the desired values and then passing it to the
+ * Sniffer or FileSniffer object's constructor. This sets
+ * default values for some attributes:
+ *
+ * - Snapshot length: 65535 bytes (64 KB).
+ * - Timeout: 1000 milliseconds.
+ * - Promiscuous mode: false.
+ *
+ * For any of the attributes not listed above, the associated
+ * pcap function which is used to set them on a pcap handle
+ * won't be called at all.
+ *
+ * This class can be used to configure a Sniffer object,
+ * like this:
+ *
+ * \code
+ * // Initialize the configuration.
+ * SnifferConfiguration config;
+ * config.set_filter("ip and port 80");
+ * config.set_promisc_mode(true);
+ *
+ * // Use it on a Sniffer object.
+ * Sniffer sniffer("eth0", config);
+ * \endcode
+ */
+class TINS_API SnifferConfiguration {
+public:
+    /**
+     * \brief The default snapshot length.
+     *
+     * This is 65535 by default.
+     */
+    static const unsigned DEFAULT_SNAP_LEN;
 
-        /**
-         * Sets the rfmon option.
-         * \param enabled The rfmon option value.
-         */
-        void set_rfmon(bool enabled);
+    /**
+     * \brief The default timeout.
+     *
+     * This is 1000 by default.
+     */
+    static const unsigned DEFAULT_TIMEOUT;
 
-        /**
-         * Sets the timeout option.
-         * \param timeout The timeout to be set.
-         */
-        void set_timeout(unsigned timeout);
+    /**
+     * Default constructs a SnifferConfiguration.
+     */
+    SnifferConfiguration();
 
-        /**
-         * Sets the immediate mode option.
-         * \param enabled The immediate mode option value.
-         */
-        void set_immediate_mode(bool enabled);
-    protected:
-        friend class Sniffer;
-        friend class FileSniffer;
+    /**
+     * Sets the snapshot length option.
+     * \param snap_len The snapshot length to be set.
+     */
+    void set_snap_len(unsigned snap_len);
 
-        enum Flags {
-            BUFFER_SIZE = 1,
-            PROMISCUOUS = 2,
-            RFMON = 4,
-            PACKET_FILTER = 8,
-            IMMEDIATE_MODE = 16
-        };
+    /**
+     * Sets the buffer size option.
+     * \param buffer_size The buffer size to be set.
+     */
+    void set_buffer_size(unsigned buffer_size);
 
-        void configure_sniffer_pre_activation(Sniffer& sniffer) const;
-        void configure_sniffer_pre_activation(FileSniffer& sniffer) const;
+    /**
+     * Sets the promiscuous mode option.
+     * \param enabled The promiscuous mode value.
+     */
+    void set_promisc_mode(bool enabled);
 
-        void configure_sniffer_post_activation(Sniffer& sniffer) const;
+    /**
+     * Sets a pcap filter to use on the sniffer.
+     * \param filter The pcap filter to be used.
+     */
+    void set_filter(const std::string& filter);
 
-        uint32_t _flags;
-        unsigned _snap_len;
-        unsigned _buffer_size;
-        std::string _filter;
-        unsigned _timeout;
-        bool _promisc;
-        bool _rfmon;
-        bool _immediate_mode;
+    /**
+     * Sets the rfmon option.
+     * \param enabled The rfmon option value.
+     */
+    void set_rfmon(bool enabled);
+
+    /**
+     * Sets the timeout option.
+     * \param timeout The timeout to be set.
+     */
+    void set_timeout(unsigned timeout);
+
+    /**
+     * Sets the immediate mode option.
+     * \param enabled The immediate mode option value.
+     */
+    void set_immediate_mode(bool enabled);
+protected:
+    friend class Sniffer;
+    friend class FileSniffer;
+
+    enum Flags {
+        BUFFER_SIZE = 1,
+        PROMISCUOUS = 2,
+        RFMON = 4,
+        PACKET_FILTER = 8,
+        IMMEDIATE_MODE = 16
     };
 
-    template<class Functor>
-    void Tins::BaseSniffer::sniff_loop(Functor function, uint32_t max_packets) {
-        for(iterator it = begin(); it != end(); ++it) {
-            try {
-                // If the functor returns false, we're done
-                #if TINS_IS_CXX11 && !defined(_MSC_VER)
-                if (!Tins::Internals::invoke_loop_cb(function, *it))
-                    return;
-                #else
-                if(!function(*it->pdu()))
-                    return;
-                #endif
-            }
-            catch(malformed_packet&) { }
-            catch(pdu_not_found&) { }
-            if(max_packets && --max_packets == 0)
+    void configure_sniffer_pre_activation(Sniffer& sniffer) const;
+    void configure_sniffer_pre_activation(FileSniffer& sniffer) const;
+
+    void configure_sniffer_post_activation(Sniffer& sniffer) const;
+
+    uint32_t flags_;
+    unsigned snap_len_;
+    unsigned buffer_size_;
+    std::string filter_;
+    unsigned timeout_;
+    bool promisc_;
+    bool rfmon_;
+    bool immediate_mode_;
+};
+
+template<class Functor>
+void Tins::BaseSniffer::sniff_loop(Functor function, uint32_t max_packets) {
+    for(iterator it = begin(); it != end(); ++it) {
+        try {
+            // If the functor returns false, we're done
+            #if TINS_IS_CXX11 && !defined(_MSC_VER)
+            if (!Tins::Internals::invoke_loop_cb(function, *it)) {
                 return;
+            }
+            #else
+            if (!function(*it->pdu())) {
+                return;
+            }
+            #endif
+        }
+        catch(malformed_packet&) { }
+        catch(pdu_not_found&) { }
+        if (max_packets && --max_packets == 0) {
+            return;
         }
     }
 }
 
+} // Tins
+
 #endif // TINS_SNIFFER_H
diff --git a/include/tins/stp.h b/include/tins/stp.h
index 514b087..eaaf634 100644
--- a/include/tins/stp.h
+++ b/include/tins/stp.h
@@ -80,7 +80,7 @@ public:
      * \param buffer The buffer from which this PDU will be constructed.
      * \param total_sz The total size of the buffer.
      */
-    STP(const uint8_t *buffer, uint32_t total_sz);
+    STP(const uint8_t* buffer, uint32_t total_sz);
 
     // Getters
 
@@ -89,7 +89,7 @@ public:
      *  \return The stored Protocol ID field value.
      */
     uint16_t proto_id() const {
-        return Endian::be_to_host(_header.proto_id);
+        return Endian::be_to_host(header_.proto_id);
     }
 
     /**
@@ -97,7 +97,7 @@ public:
      *  \return The stored Protocol Version field value.
      */
     uint8_t proto_version() const {
-        return _header.proto_version;
+        return header_.proto_version;
     }
 
     /**
@@ -105,7 +105,7 @@ public:
      *  \return The stored BDU Type field value.
      */
     uint8_t bpdu_type() const {
-        return _header.bpdu_type;
+        return header_.bpdu_type;
     }
 
     /**
@@ -113,7 +113,7 @@ public:
      *  \return The stored BDU Flags field value.
      */
     uint8_t bpdu_flags() const {
-        return _header.bpdu_flags;
+        return header_.bpdu_flags;
     }
 
     /**
@@ -121,7 +121,7 @@ public:
      *  \return The stored Root Path Cost field value.
      */
     uint32_t root_path_cost() const {
-        return Endian::be_to_host(_header.root_path_cost);
+        return Endian::be_to_host(header_.root_path_cost);
     }
 
     /**
@@ -129,7 +129,7 @@ public:
      *  \return The stored Port ID field value.
      */
     uint16_t port_id() const {
-        return Endian::be_to_host(_header.port_id);
+        return Endian::be_to_host(header_.port_id);
     }
 
     /**
@@ -137,7 +137,7 @@ public:
      *  \return The stored Message Age field value.
      */
     uint16_t msg_age() const {
-        return Endian::be_to_host(_header.msg_age) / 256;
+        return Endian::be_to_host(header_.msg_age) / 256;
     }
 
     /**
@@ -145,7 +145,7 @@ public:
      *  \return The stored Maximum Age field value.
      */
     uint16_t max_age() const {
-        return Endian::be_to_host(_header.max_age) / 256;
+        return Endian::be_to_host(header_.max_age) / 256;
     }
 
     /**
@@ -153,7 +153,7 @@ public:
      *  \return The stored Hello Time field value.
      */
     uint16_t hello_time() const {
-        return Endian::be_to_host(_header.hello_time) / 256;
+        return Endian::be_to_host(header_.hello_time) / 256;
     }
 
     /**
@@ -161,7 +161,7 @@ public:
      *  \return The stored Forward Delay field value.
      */
     uint16_t fwd_delay() const {
-        return Endian::be_to_host(_header.fwd_delay) / 256;
+        return Endian::be_to_host(header_.fwd_delay) / 256;
     }
     
     /**
@@ -180,12 +180,14 @@ public:
      * \brief Getter for the PDU's type.
      * \sa PDU::pdu_type
      */
-    PDUType pdu_type() const { return pdu_flag; }
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
 
     /**
      * \sa PDU::clone
      */
-    STP *clone() const {
+    STP* clone() const {
         return new STP(*this);
     }
     
@@ -262,13 +264,13 @@ public:
      *  \brief Setter for the Root ID field.
      *  \param new_fwd_delay The new Root ID field value.
      */
-    void root_id(const bpdu_id_type &id);
+    void root_id(const bpdu_id_type& id);
     
     /**
      *  \brief Setter for the Bridge ID field.
      *  \param new_fwd_delay The new Bridge ID field value.
      */
-    void bridge_id(const bpdu_id_type &id);
+    void bridge_id(const bpdu_id_type& id);
 private:
     TINS_BEGIN_PACK
     struct pvt_bpdu_id {
@@ -285,7 +287,7 @@ private:
     } TINS_END_PACK;
 
     TINS_BEGIN_PACK
-    struct stphdr {
+    struct stp_header {
         uint16_t proto_id;
         uint8_t proto_version;
         uint8_t bpdu_type;
@@ -300,12 +302,12 @@ private:
         uint16_t fwd_delay;
     } TINS_END_PACK;
     
-    static bpdu_id_type convert(const pvt_bpdu_id &id);
-    static pvt_bpdu_id convert(const bpdu_id_type &id);
+    static bpdu_id_type convert(const pvt_bpdu_id& id);
+    static pvt_bpdu_id convert(const bpdu_id_type& id);
     
-    void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
     
-    stphdr _header;
+    stp_header header_;
 };
 }
 
diff --git a/include/tins/tcp.h b/include/tins/tcp.h
index afb594d..416c0ea 100644
--- a/include/tins/tcp.h
+++ b/include/tins/tcp.h
@@ -48,551 +48,573 @@ namespace Memory {
 class OutputMemoryStream;
 } // Memory
 
+/**
+ * \class TCP
+ * \brief Represents a TCP PDU.
+ *
+ * This class represents a TCP PDU. 
+ *
+ * When sending TCP PDUs, the checksum is calculated automatically
+ * every time you send the packet.
+ * 
+ * While sniffing, the payload sent in each packet will be wrapped
+ * in a RawPDU, which is set as the TCP object's inner_pdu. Therefore,
+ * if you are sniffing and want to see the TCP packet's payload,
+ * you need to do the following:
+ *
+ * \code
+ * // Get a packet from somewhere.
+ * TCP tcp = ...;
+ *
+ * // Extract the RawPDU object.
+ * const RawPDU& raw = tcp.rfind_pdu<RawPDU>();
+ *
+ * // Finally, take the payload (this is a vector<uint8_t>)
+ * const RawPDU::payload_type& payload = raw.payload();
+ * \endcode
+ *
+ * \sa RawPDU
+ */
+
+class TINS_API TCP : public PDU {
+public:
     /**
-     * \class TCP
-     * \brief Represents a TCP PDU.
+     * This PDU's flag.
+     */
+    static const PDU::PDUType pdu_flag = PDU::TCP;
+
+    /**
+     * \brief TCP flags enum.
      *
-     * This class represents a TCP PDU. 
+     * These flags identify those supported by the TCP PDU.
+     */
+    enum Flags {
+        FIN = 1,
+        SYN = 2,
+        RST = 4,
+        PSH = 8,
+        ACK = 16,
+        URG = 32,
+        ECE = 64,
+        CWR = 128
+    };
+
+    /**
+     * \brief TCP options enum.
      *
-     * When sending TCP PDUs, the checksum is calculated automatically
-     * every time you send the packet.
+     * This enum defines option types supported by TCP PDU.
+     */
+    enum OptionTypes {
+        EOL     = 0,
+        NOP     = 1,
+        MSS     = 2,
+        WSCALE  = 3,
+        SACK_OK = 4,
+        SACK    = 5,
+        TSOPT   = 8,
+        ALTCHK  = 14
+    };
+    
+    /**
+     * \brief Alternate checksum enum.
+     */
+    enum AltChecksums {
+        CHK_TCP,
+        CHK_8FLETCHER,
+        CHK_16FLETCHER
+    };
+    
+    /**
+     * The type used to store TCP options.
+     */
+    typedef PDUOption<uint8_t, TCP> option;
+
+    /**
+     * The type used to store the options.
+     */
+    typedef std::list<option> options_type;
+    
+    /**
+     * The type used to store the sack option.
+     */
+    typedef std::vector<uint32_t> sack_type;
+
+    /**
+     * \brief TCP constructor.
+     *
+     * Creates an instance of TCP. Destination and source port can
+     * be provided, otherwise both will be 0.
      * 
-     * While sniffing, the payload sent in each packet will be wrapped
-     * in a RawPDU, which is set as the TCP object's inner_pdu. Therefore,
-     * if you are sniffing and want to see the TCP packet's payload,
-     * you need to do the following:
+     * \param dport Destination port.
+     * \param sport Source port.
+     * */
+    TCP(uint16_t dport = 0, uint16_t sport = 0);
+
+    /**
+     * \brief Constructs TCP object from a buffer.
+     * 
+     * If there is not enough size for a TCP header, or any of the
+     * TLV options are malformed, a malformed_packet exception is 
+     * thrown.
+     * 
+     * Any extra data will be stored in a RawPDU.
+     * 
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    TCP(const uint8_t* buffer, uint32_t total_sz);
+
+    /**
+     * \brief Getter for the destination port field.
+     *
+     * \return The destination port field value.
+     */
+    uint16_t dport() const {
+        return Endian::be_to_host(header_.dport);
+    }
+
+    /**
+     * \brief Getter for the source port field.
+     *
+     * \return The source port field value.
+     */
+    uint16_t sport() const {
+        return Endian::be_to_host(header_.sport);
+    }
+
+    /**
+     * \brief Getter for the sequence number field.
+     *
+     * \return The sequence number field value.
+     */
+    uint32_t seq() const {
+        return Endian::be_to_host(header_.seq);
+    }
+
+    /**
+     * \brief Getter for the acknowledge number field.
+     *
+     * \return The acknowledge number field value.
+     */
+    uint32_t ack_seq() const {
+        return Endian::be_to_host(header_.ack_seq);
+    }
+
+    /**
+     * \brief Getter for the window size field.
+     *
+     * \return The window size field value.
+     */
+    uint16_t window() const {
+        return Endian::be_to_host(header_.window);
+    }
+
+    /**
+     * \brief Getter for the checksum field.
+     *
+     * \return The checksum field value.
+     */
+    uint16_t checksum() const {
+        return Endian::be_to_host(header_.check);
+    }
+
+    /**
+     * \brief Getter for the urgent pointer field.
+     *
+     * \return The urgent pointer field value.
+     */
+    uint16_t urg_ptr() const {
+        return Endian::be_to_host(header_.urg_ptr);
+    }
+
+    /**
+     * \brief Getter for the data offset field.
+     *
+     * \return The data offset field value.
+     */
+    small_uint<4> data_offset() const {
+        return this->header_.doff;
+    }
+
+    /**
+     * \brief Getter for the option list.
+     * 
+     * \return The options list.
+     */
+    const options_type& options() const {
+        return options_;
+    }
+
+    /**
+     * \brief Gets the value of a flag.
+     *
+     * This method gets the value of a specific flag. If you 
+     * want to check for multiple flags at the same time,
+     * use TCP::flags.
+     *
+     * If you want to check if this PDU has the SYN flag on,
+     * you can do it like this:
      *
      * \code
-     * // Get a packet from somewhere.
+     * // Get a TCP packet from somewhere.
      * TCP tcp = ...;
      *
-     * // Extract the RawPDU object.
-     * const RawPDU& raw = tcp.rfind_pdu<RawPDU>();
-     *
-     * // Finally, take the payload (this is a vector<uint8_t>)
-     * const RawPDU::payload_type& payload = raw.payload();
+     * if(tcp.get_flag(TCP::SYN)) {
+     *     // The SYN flag is on!
+     * }
      * \endcode
-     *
-     * \sa RawPDU
+     * 
+     * \sa TCP::flags
+     * \param tcp_flag The polled flag.
+     * \return The value of the flag.
      */
+    small_uint<1> get_flag(Flags tcp_flag) const;
 
-    class TINS_API TCP : public PDU {
-    public:
-        /**
-         * This PDU's flag.
-         */
-        static const PDU::PDUType pdu_flag = PDU::TCP;
+    /**
+     * 
+     * \brief Gets the flags' values.
+     *
+     * All of the set flags will be joined together into
+     * a 12 bit value. This way, you can check for multiple
+     * flags at the same time:
+     * 
+     * \code
+     * TCP tcp = ...;
+     * if(tcp.flags() == (TCP::SYN | TCP::ACK)) {
+     *     // It's a SYN+ACK!
+     * }
+     * \endcode
+     * 
+     * \return The value of the flags field.
+     */
+    small_uint<12> flags() const;
     
-        /**
-         * \brief TCP flags enum.
-         *
-         * These flags identify those supported by the TCP PDU.
-         */
-        enum Flags {
-            FIN = 1,
-            SYN = 2,
-            RST = 4,
-            PSH = 8,
-            ACK = 16,
-            URG = 32,
-            ECE = 64,
-            CWR = 128
-        };
+    /* Setters */
 
-        /**
-         * \brief TCP options enum.
-         *
-         * This enum defines option types supported by TCP PDU.
-         */
-        enum OptionTypes {
-            EOL     = 0,
-            NOP     = 1,
-            MSS     = 2,
-            WSCALE  = 3,
-            SACK_OK = 4,
-            SACK    = 5,
-            TSOPT   = 8,
-            ALTCHK  = 14
-        };
-        
-        /**
-         * \brief Alternate checksum enum.
-         */
-        enum AltChecksums {
-            CHK_TCP,
-            CHK_8FLETCHER,
-            CHK_16FLETCHER
-        };
-        
-        /**
-         * The type used to store TCP options.
-         */
-        typedef PDUOption<uint8_t, TCP> option;
+    /**
+     * \brief Setter for the destination port field.
+     *
+     * \param new_dport The new destination port.
+     */
+    void dport(uint16_t new_dport);
 
-        /**
-         * The type used to store the options.
-         */
-        typedef std::list<option> options_type;
-        
-        /**
-         * The type used to store the sack option.
-         */
-        typedef std::vector<uint32_t> sack_type;
+    /**
+     * \brief Setter for the source port field.
+     *
+     * \param new_sport The new source port.
+     */
+    void sport(uint16_t new_sport);
 
-        /**
-         * \brief TCP constructor.
-         *
-         * Creates an instance of TCP. Destination and source port can
-         * be provided, otherwise both will be 0.
-         * 
-         * \param dport Destination port.
-         * \param sport Source port.
-         * */
-        TCP(uint16_t dport = 0, uint16_t sport = 0);
+    /**
+     * \brief Setter for the sequence number.
+     *
+     * \param new_seq The new sequence number.
+     */
+    void seq(uint32_t new_seq);
 
-        /**
-         * \brief Constructs TCP object from a buffer.
-         * 
-         * If there is not enough size for a TCP header, or any of the
-         * TLV options are malformed, a malformed_packet exception is 
-         * thrown.
-         * 
-         * Any extra data will be stored in a RawPDU.
-         * 
-         * \param buffer The buffer from which this PDU will be constructed.
-         * \param total_sz The total size of the buffer.
-         */
-        TCP(const uint8_t *buffer, uint32_t total_sz);
+    /**
+     * \brief Setter for the acknowledge number.
+     *
+     * \param new_ack_seq The new acknowledge number.
+     */
+    void ack_seq(uint32_t new_ack_seq);
 
-        /**
-         * \brief Getter for the destination port field.
-         *
-         * \return The destination port field value.
-         */
-        uint16_t dport() const { return Endian::be_to_host(_tcp.dport); }
+    /**
+     * \brief Setter for the window size.
+     *
+     * \param new_window The new window size.
+     */
+    void window(uint16_t new_window);
 
-        /**
-         * \brief Getter for the source port field.
-         *
-         * \return The source port field value.
-         */
-        uint16_t sport() const { return Endian::be_to_host(_tcp.sport); }
+    /**
+     * \brief Setter for the urgent pointer field.
+     *
+     * \param new_urg_ptr The new urgent pointer.
+     */
+    void urg_ptr(uint16_t new_urg_ptr);
 
-        /**
-         * \brief Getter for the sequence number field.
-         *
-         * \return The sequence number field value.
-         */
-        uint32_t seq() const { return Endian::be_to_host(_tcp.seq); }
+    /**
+     * \brief Setter for the data offset pointer field.
+     *
+     * \param new_doff The new data offset pointer.
+     */
+    void data_offset(small_uint<4> new_doff);
 
-        /**
-         * \brief Getter for the acknowledge number field.
-         *
-         * \return The acknowledge number field value.
-         */
-        uint32_t ack_seq() const { return Endian::be_to_host(_tcp.ack_seq); }
+    // Options
 
-        /**
-         * \brief Getter for the window size field.
-         *
-         * \return The window size field value.
-         */
-        uint16_t window() const { return Endian::be_to_host(_tcp.window); }
+    /**
+     * \brief Add a maximum segment size option.
+     *
+     * \param value The new maximum segment size.
+     */
+    void mss(uint16_t value);
 
-        /**
-         * \brief Getter for the checksum field.
-         *
-         * \return The checksum field value.
-         */
-        uint16_t checksum() const { return Endian::be_to_host(_tcp.check); }
+    /**
+     * \brief Searchs for a maximum segment size option.
+     * \param value A pointer in which the option's value will be stored.
+     * \return True if the option was found, false otherwise.
+     */
+    uint16_t mss() const;
 
-        /**
-         * \brief Getter for the urgent pointer field.
-         *
-         * \return The urgent pointer field value.
-         */
-        uint16_t urg_ptr() const { return Endian::be_to_host(_tcp.urg_ptr); }
+    /**
+     * \brief Add a window scale option.
+     *
+     * \param value The new window scale.
+     */
+    void winscale(uint8_t value);
+    
+    /**
+     * \brief Searchs for a window scale option.
+     * \param value A pointer in which the option's value will be stored.
+     * \return True if the option was found, false otherwise.
+     */
+    uint8_t winscale() const;
 
-        /**
-         * \brief Getter for the data offset field.
-         *
-         * \return The data offset field value.
-         */
-        small_uint<4> data_offset() const { return this->_tcp.doff; }
+    /**
+     * \brief Add a sack permitted option.
+     */
+    void sack_permitted();
+    
+    /**
+     * \brief Searchs for a sack permitted option.
+     * \return True if the option was found, false otherwise.
+     */
+    bool has_sack_permitted() const;
+    
+    /**
+     * \brief Add a sack option.
+     *
+     * \param value The new window scale.
+     */
+    void sack(const sack_type& edges);
+    
+    /**
+     * \brief Searchs for a sack option.
+     * \param value A pointer in which the option's value will be stored.
+     * \return True if the option was found, false otherwise.
+     */
+    sack_type sack() const;
 
-        /**
-         * \brief Getter for the option list.
-         * 
-         * \return The options list.
-         */
-        const options_type &options() const { return _options; }
+    /**
+     * \brief Add a timestamp option.
+     *
+     * \param value The current value of the timestamp clock.
+     * \param reply The echo reply field.
+     */
+    void timestamp(uint32_t value, uint32_t reply);
 
-        /**
-         * \brief Gets the value of a flag.
-         *
-         * This method gets the value of a specific flag. If you 
-         * want to check for multiple flags at the same time,
-         * use TCP::flags.
-         *
-         * If you want to check if this PDU has the SYN flag on,
-         * you can do it like this:
-         *
-         * \code
-         * // Get a TCP packet from somewhere.
-         * TCP tcp = ...;
-         *
-         * if(tcp.get_flag(TCP::SYN)) {
-         *     // The SYN flag is on!
-         * }
-         * \endcode
-         * 
-         * \sa TCP::flags
-         * \param tcp_flag The polled flag.
-         * \return The value of the flag.
-         */
-        small_uint<1> get_flag(Flags tcp_flag) const;
+    /**
+     * \brief Searchs for a timestamp option.
+     * \param value A pointer in which the option's value will be stored.
+     * \param reply A pointer in which the option's reply value will be stored.
+     * \return True if the option was found, false otherwise.
+     */
+    std::pair<uint32_t, uint32_t> timestamp() const;
 
-        /**
-         * 
-         * \brief Gets the flags' values.
-         *
-         * All of the set flags will be joined together into
-         * a 12 bit value. This way, you can check for multiple
-         * flags at the same time:
-         * 
-         * \code
-         * TCP tcp = ...;
-         * if(tcp.flags() == (TCP::SYN | TCP::ACK)) {
-         *     // It's a SYN+ACK!
-         * }
-         * \endcode
-         * 
-         * \return The value of the flags field.
-         */
-        small_uint<12> flags() const;
-        
-        /* Setters */
+    /**
+     * \brief Add a alternate checksum option.
+     *
+     * \param value The new alternate checksum scale.
+     */
+    void altchecksum(AltChecksums value);
+    
+    /**
+     * \brief Searchs for a alternate checksum option.
+     * \param value A pointer in which the option's value will be stored.
+     * \return True if the option was found, false otherwise.
+     */
+    AltChecksums altchecksum() const;
 
-        /**
-         * \brief Setter for the destination port field.
-         *
-         * \param new_dport The new destination port.
-         */
-        void dport(uint16_t new_dport);
-
-        /**
-         * \brief Setter for the source port field.
-         *
-         * \param new_sport The new source port.
-         */
-        void sport(uint16_t new_sport);
-
-        /**
-         * \brief Setter for the sequence number.
-         *
-         * \param new_seq The new sequence number.
-         */
-        void seq(uint32_t new_seq);
-
-        /**
-         * \brief Setter for the acknowledge number.
-         *
-         * \param new_ack_seq The new acknowledge number.
-         */
-        void ack_seq(uint32_t new_ack_seq);
-
-        /**
-         * \brief Setter for the window size.
-         *
-         * \param new_window The new window size.
-         */
-        void window(uint16_t new_window);
-
-        /**
-         * \brief Setter for the urgent pointer field.
-         *
-         * \param new_urg_ptr The new urgent pointer.
-         */
-        void urg_ptr(uint16_t new_urg_ptr);
-
-        /**
-         * \brief Setter for the data offset pointer field.
-         *
-         * \param new_doff The new data offset pointer.
-         */
-        void data_offset(small_uint<4> new_doff);
-
-        // Options
-
-        /**
-         * \brief Add a maximum segment size option.
-         *
-         * \param value The new maximum segment size.
-         */
-        void mss(uint16_t value);
-
-        /**
-         * \brief Searchs for a maximum segment size option.
-         * \param value A pointer in which the option's value will be stored.
-         * \return True if the option was found, false otherwise.
-         */
-        uint16_t mss() const;
-
-        /**
-         * \brief Add a window scale option.
-         *
-         * \param value The new window scale.
-         */
-        void winscale(uint8_t value);
-        
-        /**
-         * \brief Searchs for a window scale option.
-         * \param value A pointer in which the option's value will be stored.
-         * \return True if the option was found, false otherwise.
-         */
-        uint8_t winscale() const;
-
-        /**
-         * \brief Add a sack permitted option.
-         */
-        void sack_permitted();
-        
-        /**
-         * \brief Searchs for a sack permitted option.
-         * \return True if the option was found, false otherwise.
-         */
-        bool has_sack_permitted() const;
-        
-        /**
-         * \brief Add a sack option.
-         *
-         * \param value The new window scale.
-         */
-        void sack(const sack_type &edges);
-        
-        /**
-         * \brief Searchs for a sack option.
-         * \param value A pointer in which the option's value will be stored.
-         * \return True if the option was found, false otherwise.
-         */
-        sack_type sack() const;
-
-        /**
-         * \brief Add a timestamp option.
-         *
-         * \param value The current value of the timestamp clock.
-         * \param reply The echo reply field.
-         */
-        void timestamp(uint32_t value, uint32_t reply);
-
-        /**
-         * \brief Searchs for a timestamp option.
-         * \param value A pointer in which the option's value will be stored.
-         * \param reply A pointer in which the option's reply value will be stored.
-         * \return True if the option was found, false otherwise.
-         */
-        std::pair<uint32_t, uint32_t> timestamp() const;
-
-        /**
-         * \brief Add a alternate checksum option.
-         *
-         * \param value The new alternate checksum scale.
-         */
-        void altchecksum(AltChecksums value);
-        
-        /**
-         * \brief Searchs for a alternate checksum option.
-         * \param value A pointer in which the option's value will be stored.
-         * \return True if the option was found, false otherwise.
-         */
-        AltChecksums altchecksum() const;
-
-        /**
-         * \brief Set a TCP flag value.
-         *
-         * \param tcp_flag The flag to be set.
-         * \param value The new value for this flag. Must be 0 or 1.
-         */
-        void set_flag(Flags tcp_flag, small_uint<1> value);
-        
-        /**
-         * \brief Sets the value of the flag fields.
-         *
-         * This method can be used to set several flags at the 
-         * same time.
-         * 
-         * \code
-         * // Get a TCP packet from somewhere and set the flags to SYN && ACK
-         * TCP tcp = ...;
-         * tcp.flags(TCP::SYN | TCP::ACK);
-         * 
-         * // Now also set the PSH flag, without modifying 
-         * // the rest of the flags.
-         * tcp.flags(tcp.flags() | TCP::PSH);
-         * \endcode
-         * 
-         * \param value The new value of the flags.
-         */
-        void flags(small_uint<12> value);
-        
+    /**
+     * \brief Set a TCP flag value.
+     *
+     * \param tcp_flag The flag to be set.
+     * \param value The new value for this flag. Must be 0 or 1.
+     */
+    void set_flag(Flags tcp_flag, small_uint<1> value);
+    
+    /**
+     * \brief Sets the value of the flag fields.
+     *
+     * This method can be used to set several flags at the 
+     * same time.
+     * 
+     * \code
+     * // Get a TCP packet from somewhere and set the flags to SYN && ACK
+     * TCP tcp = ...;
+     * tcp.flags(TCP::SYN | TCP::ACK);
+     * 
+     * // Now also set the PSH flag, without modifying 
+     * // the rest of the flags.
+     * tcp.flags(tcp.flags() | TCP::PSH);
+     * \endcode
+     * 
+     * \param value The new value of the flags.
+     */
+    void flags(small_uint<12> value);
+    
 
+    /**
+     * \brief Adds a TCP option.
+     *
+     * \param option The option to be added.
+     */
+    void add_option(const option& opt);
+    
+    #if TINS_IS_CXX11
         /**
          * \brief Adds a TCP option.
          *
+         * This move-constructs the option.
+         * 
          * \param option The option to be added.
          */
-        void add_option(const option &opt);
-        
-        #if TINS_IS_CXX11
-            /**
-             * \brief Adds a TCP option.
-             *
-             * This move-constructs the option.
-             * 
-             * \param option The option to be added.
-             */
-            void add_option(option &&opt) {
-                internal_add_option(opt);
-                _options.push_back(std::move(opt));
-            }
-
-            /**
-             * \brief Adds a TCP option using the provided arguments.
-             *
-             * The option is constructed from the provided parameters.
-             * 
-             * \param args The arguments to be used in the option's 
-             * constructor.
-             */
-            template<typename... Args>
-            void add_option(Args&&... args) {
-                _options.emplace_back(std::forward<Args>(args)...);
-                internal_add_option(_options.back());
-            }
-        #endif
+        void add_option(option &&opt) {
+            internal_add_option(opt);
+            options_.push_back(std::move(opt));
+        }
 
         /**
-         * \brief Removes a TCP option.
+         * \brief Adds a TCP option using the provided arguments.
+         *
+         * The option is constructed from the provided parameters.
          * 
-         * If there are multiple options of the given type, only the first one
-         * will be removed.
-         *
-         * \param type The type of the option to be removed.
-         * \return true if the option was removed, false otherwise.
+         * \param args The arguments to be used in the option's 
+         * constructor.
          */
-        bool remove_option(OptionTypes type);
-
-        /**
-         * \brief Returns the header size.
-         *
-         * This metod overrides PDU::header_size. This size includes the
-         * payload and options size.
-         *
-         * \sa PDU::header_size
-         */
-        uint32_t header_size() const;
-        
-        /**
-         * \brief Check wether ptr points to a valid response for this PDU.
-         *
-         * \sa PDU::matches_response
-         * \param ptr The pointer to the buffer.
-         * \param total_sz The size of the buffer.
-         */
-        bool matches_response(const uint8_t *ptr, uint32_t total_sz) const;
-
-        /**
-         * \brief Getter for the PDU's type.
-         *
-         * \sa PDU::pdu_type
-         */
-        PDUType pdu_type() const { return PDU::TCP; }
-
-        /**
-         * \brief Searchs for an option that matchs the given type.
-         * \param type The option type to be searched.
-         * \return A pointer to the option, or 0 if it was not found.
-         */
-        const option *search_option(OptionTypes type) const;
-        
-        /**
-         * \sa PDU::clone
-         */
-        TCP *clone() const {
-            return new TCP(*this);
+        template<typename... Args>
+        void add_option(Args&&... args) {
+            options_.emplace_back(std::forward<Args>(args)...);
+            internal_add_option(options_.back());
         }
-    private:
-        #if TINS_IS_LITTLE_ENDIAN
-            TINS_BEGIN_PACK
-            struct flags_type {
-                uint8_t fin:1,
-                    syn:1,
-                    rst:1,
-                    psh:1,
-                    ack:1,
-                    urg:1,
-                    ece:1,
-                    cwr:1;
-            } TINS_END_PACK;
-        #else
-            TINS_BEGIN_PACK
-            struct flags_type {
-                uint8_t cwr:1,
-                    ece:1,
-                    urg:1,
-                    ack:1,
-                    psh:1,
-                    rst:1,
-                    syn:1,
-                    fin:1;
-            } TINS_END_PACK;
-        #endif
+    #endif
 
+    /**
+     * \brief Removes a TCP option.
+     * 
+     * If there are multiple options of the given type, only the first one
+     * will be removed.
+     *
+     * \param type The type of the option to be removed.
+     * \return true if the option was removed, false otherwise.
+     */
+    bool remove_option(OptionTypes type);
+
+    /**
+     * \brief Returns the header size.
+     *
+     * This metod overrides PDU::header_size. This size includes the
+     * payload and options size.
+     *
+     * \sa PDU::header_size
+     */
+    uint32_t header_size() const;
+    
+    /**
+     * \brief Check wether ptr points to a valid response for this PDU.
+     *
+     * \sa PDU::matches_response
+     * \param ptr The pointer to the buffer.
+     * \param total_sz The size of the buffer.
+     */
+    bool matches_response(const uint8_t* ptr, uint32_t total_sz) const;
+
+    /**
+     * \brief Getter for the PDU's type.
+     *
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const {
+        return pdu_flag;
+    }
+
+    /**
+     * \brief Searchs for an option that matchs the given type.
+     * \param type The option type to be searched.
+     * \return A pointer to the option, or 0 if it was not found.
+     */
+    const option* search_option(OptionTypes type) const;
+    
+    /**
+     * \sa PDU::clone
+     */
+    TCP* clone() const {
+        return new TCP(*this);
+    }
+private:
+    #if TINS_IS_LITTLE_ENDIAN
         TINS_BEGIN_PACK
-        struct tcphdr {
-            uint16_t sport;
-            uint16_t dport;
-            uint32_t seq;
-            uint32_t ack_seq;
-        #if TINS_IS_LITTLE_ENDIAN
-            uint8_t res1:4,
-                doff:4;
-        #else
-            uint8_t doff:4,
-                res1:4;
-        #endif
-            union {
-                flags_type flags;
-                uint8_t flags_8;
-            };
-            uint16_t	window;
-            uint16_t	check;
-            uint16_t	urg_ptr;
+        struct flags_type {
+            uint8_t fin:1,
+                syn:1,
+                rst:1,
+                psh:1,
+                ack:1,
+                urg:1,
+                ece:1,
+                cwr:1;
         } TINS_END_PACK;
+    #else
+        TINS_BEGIN_PACK
+        struct flags_type {
+            uint8_t cwr:1,
+                ece:1,
+                urg:1,
+                ack:1,
+                psh:1,
+                rst:1,
+                syn:1,
+                fin:1;
+        } TINS_END_PACK;
+    #endif
 
-        static const uint16_t DEFAULT_WINDOW;
-        
-        template<class T> 
-        T generic_search(OptionTypes opt_type) const {
-            const option *opt = search_option(opt_type);
-            if(!opt)
-                throw option_not_found();
-            return opt->to<T>();
+    TINS_BEGIN_PACK
+    struct tcp_header {
+        uint16_t sport;
+        uint16_t dport;
+        uint32_t seq;
+        uint32_t ack_seq;
+    #if TINS_IS_LITTLE_ENDIAN
+        uint8_t res1:4,
+            doff:4;
+    #else
+        uint8_t doff:4,
+            res1:4;
+    #endif
+        union {
+            flags_type flags;
+            uint8_t flags_8;
+        };
+        uint16_t	window;
+        uint16_t	check;
+        uint16_t	urg_ptr;
+    } TINS_END_PACK;
+
+    static const uint16_t DEFAULT_WINDOW;
+    
+    template<class T> 
+    T generic_search(OptionTypes opt_type) const {
+        const option* opt = search_option(opt_type);
+        if (!opt) {
+            throw option_not_found();
         }
-        
-        void internal_add_option(const option &option);
-        void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
-        void checksum(uint16_t new_check);
-        void update_options_size();
-        options_type::const_iterator search_option_iterator(OptionTypes type) const;
-        options_type::iterator search_option_iterator(OptionTypes type);
-        
-        void write_option(const option &opt, Memory::OutputMemoryStream& stream);
+        return opt->to<T>();
+    }
+    
+    void internal_add_option(const option& option);
+    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
+    void checksum(uint16_t new_check);
+    void update_options_size();
+    options_type::const_iterator search_option_iterator(OptionTypes type) const;
+    options_type::iterator search_option_iterator(OptionTypes type);
+    
+    void write_option(const option& opt, Memory::OutputMemoryStream& stream);
+
+    tcp_header header_;
+    uint16_t options_size_, total_options_size_;
+    options_type options_;
+};
 
-        tcphdr _tcp;
-        uint16_t _options_size, _total_options_size;
-        options_type _options;
-    };
 } // Tins
 
 #endif // TINS_TCP_H
diff --git a/include/tins/tcp_stream.h b/include/tins/tcp_stream.h
index 9110ff3..5109889 100644
--- a/include/tins/tcp_stream.h
+++ b/include/tins/tcp_stream.h
@@ -65,7 +65,7 @@ public:
         StreamInfo(IPv4Address client, IPv4Address server,
             uint16_t cport, uint16_t sport);
         
-        bool operator<(const StreamInfo &rhs) const;
+        bool operator<(const StreamInfo& rhs) const;
     };
     
     /**
@@ -79,17 +79,17 @@ public:
      * \param tcp The TCP PDU from which to take the initial parameters.
      * \param identifier This stream's identifier number
      */
-    TCPStream(IP *ip, TCP *tcp, uint64_t identifier);
+    TCPStream(IP* ip, TCP* tcp, uint64_t identifier);
     
     /**
      * Copy constructor.
      */
-    TCPStream(const TCPStream &rhs);
+    TCPStream(const TCPStream& rhs);
     
     /**
      * Copy assignment operator.
      */
-    TCPStream& operator=(const TCPStream &rhs);
+    TCPStream& operator=(const TCPStream& rhs);
     
     /**
      * Destructor.
@@ -103,7 +103,7 @@ public:
      * 
      * \return const payload_type& containing the payload.
      */
-    const payload_type &client_payload() const {
+    const payload_type& client_payload() const {
         return client_payload_;
     }
     
@@ -114,7 +114,7 @@ public:
      * 
      * \return payload_type& containing the payload.
      */
-    payload_type &client_payload() {
+    payload_type& client_payload() {
         return client_payload_;
     }
     
@@ -125,7 +125,7 @@ public:
      * 
      * \return const payload_type& containing the payload.
      */
-    const payload_type &server_payload() const {
+    const payload_type& server_payload() const {
         return server_payload_;
     }
     
@@ -136,7 +136,7 @@ public:
      * 
      * \return payload_type& containing the payload.
      */
-    payload_type &server_payload() {
+    payload_type& server_payload() {
         return server_payload_;
     }
 
@@ -145,15 +145,15 @@ public:
      * \return uint64_t containing the identification number.
      */
     uint64_t id() const {
-        return identifier;
+        return identifier_;
     }
     
     /**
      * \brief Retrieves the stream information.
      * \return const StreamInfo& containing the stream information.
      */
-    const StreamInfo &stream_info() const {
-        return info;
+    const StreamInfo& stream_info() const {
+        return info_;
     }
 
     /**
@@ -165,7 +165,7 @@ public:
      * \return bool indicating whether the stream is finished.
      */
     bool is_finished() const {
-        return fin_sent;
+        return fin_sent_;
     }
     
     /**
@@ -178,25 +178,25 @@ public:
      * \return bool indicating whether any changes have been done to 
      * any of the stored payloads.
      */
-    bool update(IP *ip, TCP *tcp);
+    bool update(IP* ip, TCP* tcp);
 private:
     typedef std::map<uint32_t, RawPDU*> fragments_type;
     
-    static void free_fragments(fragments_type &frags);
-    static fragments_type clone_fragments(const fragments_type &frags);
+    static void free_fragments(fragments_type& frags);
+    static fragments_type clone_fragments(const fragments_type& frags);
     
-    bool generic_process(uint32_t &my_seq, uint32_t &other_seq, 
-      payload_type &pload, fragments_type &frags, TCP *tcp);
+    bool generic_process(uint32_t& my_seq, uint32_t& other_seq, 
+      payload_type& pload, fragments_type& frags, TCP* tcp);
 
-    void safe_insert(fragments_type &frags, uint32_t seq, RawPDU *raw);
+    void safe_insert(fragments_type& frags, uint32_t seq, RawPDU* raw);
 
 
-    uint32_t client_seq, server_seq;
-    StreamInfo info;
-    uint64_t identifier;
+    uint32_t client_seq_, server_seq_;
+    StreamInfo info_;
+    uint64_t identifier_;
     payload_type client_payload_, server_payload_;
-    fragments_type client_frags, server_frags;
-    bool syn_ack_sent, fin_sent;
+    fragments_type client_frags_, server_frags_;
+    bool syn_ack_sent_, fin_sent_;
 };
 
 
@@ -224,7 +224,7 @@ public:
      * closed.
      */
     template<typename DataFunctor, typename EndFunctor>
-    void follow_streams(BaseSniffer &sniffer, DataFunctor data_fun, EndFunctor end_fun);
+    void follow_streams(BaseSniffer& sniffer, DataFunctor data_fun, EndFunctor end_fun);
     
     /**
      * \brief Starts following TCP streams.
@@ -263,7 +263,7 @@ public:
      * closed.
      */
     template<typename DataFunctor>
-    void follow_streams(BaseSniffer &sniffer, DataFunctor data_fun);
+    void follow_streams(BaseSniffer& sniffer, DataFunctor data_fun);
     
     /**
      * \brief Starts following TCP streams.
@@ -292,89 +292,97 @@ private:
     
     template<typename DataFunctor, typename EndFunctor>
     struct proxy_caller {
-        bool callback(PDU &pdu) {
+        bool callback(PDU& pdu) {
             return stream->callback(pdu, data_fun, end_fun);
         }
         
-        TCPStreamFollower *stream;
+        TCPStreamFollower* stream;
         DataFunctor data_fun;
         EndFunctor end_fun;
     };
     
     template<typename DataFunctor, typename EndFunctor>
-    bool callback(PDU &pdu, const DataFunctor &fun, const EndFunctor &end_fun);
+    bool callback(PDU& pdu, const DataFunctor& fun, const EndFunctor& end_fun);
     static void dummy_function(TCPStream&) { }
     
-    sessions_type sessions;
-    uint64_t last_identifier;
+    sessions_type sessions_;
+    uint64_t last_identifier_;
 };
 
 template<typename DataFunctor, typename EndFunctor>
-void TCPStreamFollower::follow_streams(BaseSniffer &sniffer, DataFunctor data_fun, EndFunctor end_fun) {
+void TCPStreamFollower::follow_streams(BaseSniffer& sniffer, 
+                                       DataFunctor data_fun,
+                                       EndFunctor end_fun) {
     typedef proxy_caller<DataFunctor, EndFunctor> proxy_type;
     proxy_type proxy = { this, data_fun, end_fun };
     sniffer.sniff_loop(make_sniffer_handler(&proxy, &proxy_type::callback));
 }
 
 template<typename ForwardIterator, typename DataFunctor, typename EndFunctor>
-void TCPStreamFollower::follow_streams(ForwardIterator start, ForwardIterator end, 
-  DataFunctor data_fun, EndFunctor end_fun) 
-{
+void TCPStreamFollower::follow_streams(ForwardIterator start, 
+                                       ForwardIterator end, 
+                                       DataFunctor data_fun,
+                                       EndFunctor end_fun)  {
     while(start != end) {
-        if(!callback(Utils::dereference_until_pdu(start), data_fun, end_fun))
+        if (!callback(Utils::dereference_until_pdu(start), data_fun, end_fun)) {
             return;
+        }
         start++;
     }
 }
 
 template<typename DataFunctor>
-void TCPStreamFollower::follow_streams(BaseSniffer &sniffer, DataFunctor data_fun) {
+void TCPStreamFollower::follow_streams(BaseSniffer& sniffer, DataFunctor data_fun) {
     return follow_streams(sniffer, data_fun, dummy_function);
 }
 
 template<typename ForwardIterator, typename DataFunctor>
-void TCPStreamFollower::follow_streams(ForwardIterator start, ForwardIterator end, 
-  DataFunctor data_fun) 
-{
+void TCPStreamFollower::follow_streams(ForwardIterator start,
+                                       ForwardIterator end, 
+                                       DataFunctor data_fun) {
     follow_streams(start, end, data_fun, dummy_function);
 }
 
 template<typename DataFunctor, typename EndFunctor>
-bool TCPStreamFollower::callback(PDU &pdu, const DataFunctor &data_fun, const EndFunctor &end_fun) {
-    IP *ip = pdu.find_pdu<IP>();
-    TCP *tcp = pdu.find_pdu<TCP>();
-    if(!ip || !tcp) {
+bool TCPStreamFollower::callback(PDU& pdu, 
+                                 const DataFunctor& data_fun,
+                                 const EndFunctor& end_fun) {
+    IP* ip = pdu.find_pdu<IP>();
+    TCP* tcp = pdu.find_pdu<TCP>();
+    if (!ip || !tcp) {
         return true;
     }
     TCPStream::StreamInfo info( 
         ip->src_addr(), ip->dst_addr(),
         tcp->sport(), tcp->dport()
     );
-    sessions_type::iterator it = sessions.find(info);
-    if(it == sessions.end()) {
+    sessions_type::iterator it = sessions_.find(info);
+    if (it == sessions_.end()) {
         std::swap(info.client_addr, info.server_addr);
         std::swap(info.client_port, info.server_port);
-        if((it = sessions.find(info)) == sessions.end()) {
-            if(tcp->get_flag(TCP::SYN) && !tcp->get_flag(TCP::ACK)) {
-                sessions.insert(
+        if ((it = sessions_.find(info)) == sessions_.end()) {
+            if (tcp->get_flag(TCP::SYN) && !tcp->get_flag(TCP::ACK)) {
+                sessions_.insert(
                     std::make_pair(
                         info,
-                        TCPStream(ip, tcp, last_identifier++)
+                        TCPStream(ip, tcp, last_identifier_++)
                     )
                 );
             }
             return true;
         }
     }
-    if(it->second.update(ip, tcp))
+    if (it->second.update(ip, tcp)) {
         data_fun(it->second);
+    }
     // We're done with this stream
-    if(it->second.is_finished()) {
+    if (it->second.is_finished()) {
         end_fun(it->second);
-        sessions.erase(it);
+        sessions_.erase(it);
     }
     return true;
 }
-}
+
+} // Tins
 
 #endif // TINS_TCP_STREAM_H
diff --git a/include/tins/timestamp.h b/include/tins/timestamp.h
index 4227bc1..e671925 100644
--- a/include/tins/timestamp.h
+++ b/include/tins/timestamp.h
@@ -93,7 +93,7 @@ public:
      * Constructs a timestamp from a timeval object.
      * \param time_val The timeval object.
      */
-    Timestamp(const timeval &time_val) : tv(time_val) {}
+    Timestamp(const timeval& time_val) : tv(time_val) {}
     
     /**
      * Returns the amount of seconds in this timestamp.
@@ -121,6 +121,7 @@ public:
 private:
     timeval tv;
 };
-}
+
+} // Tins
 
 #endif // TINS_TIMESTAMP_H
diff --git a/include/tins/udp.h b/include/tins/udp.h
index 7ce46b8..a026a08 100644
--- a/include/tins/udp.h
+++ b/include/tins/udp.h
@@ -36,150 +36,159 @@
 
 namespace Tins {
 
-    /** 
-     * \class UDP
-     * \brief Represents an UDP PDU.
-     *
-     * This class represents an UDP PDU. 
-     * 
-     * While sniffing, the payload sent in each packet will be wrapped
-     * in a RawPDU, which is set as the UDP object's inner_pdu. Therefore,
-     * if you are sniffing and want to see the UDP packet's payload,
-     * you need to do the following:
-     *
-     * \code
-     * // Get a packet from somewhere.
-     * UDP udp = ...;
-     *
-     * // Extract the RawPDU object.
-     * const RawPDU& raw = udp.rfind_pdu<RawPDU>();
-     *
-     * // Finally, take the payload (this is a vector<uint8_t>)
-     * const RawPDU::payload_type& payload = raw.payload();
-     * \endcode
-     *
-     * \sa RawPDU
+/** 
+ * \class UDP
+ * \brief Represents an UDP PDU.
+ *
+ * This class represents an UDP PDU. 
+ * 
+ * While sniffing, the payload sent in each packet will be wrapped
+ * in a RawPDU, which is set as the UDP object's inner_pdu. Therefore,
+ * if you are sniffing and want to see the UDP packet's payload,
+ * you need to do the following:
+ *
+ * \code
+ * // Get a packet from somewhere.
+ * UDP udp = ...;
+ *
+ * // Extract the RawPDU object.
+ * const RawPDU& raw = udp.rfind_pdu<RawPDU>();
+ *
+ * // Finally, take the payload (this is a vector<uint8_t>)
+ * const RawPDU::payload_type& payload = raw.payload();
+ * \endcode
+ *
+ * \sa RawPDU
+ */
+class UDP : public PDU {
+public:
+    /**
+     * \brief This PDU's flag.
      */
-    class UDP : public PDU {
-    public:
-        /**
-         * \brief This PDU's flag.
-         */
-        static const PDU::PDUType pdu_flag = PDU::UDP;
+    static const PDU::PDUType pdu_flag = PDU::UDP;
+
+    /** 
+     * \brief UDP constructor.
+     *
+     * Constructs an instance of UDP. The destination and source 
+     * port can be provided, otherwise both of them will be 0.
+     * 
+     * \param dport Destination port.
+     * \param sport Source port.
+     * */
+    UDP(uint16_t dport = 0, uint16_t sport = 0);
+
+    /**
+     * \brief Constructs an UDP object from a buffer.
+     * 
+     * If there is not enough size for a UDP header a malformed_packet 
+     * exception is thrown.
+     * 
+     * Any extra data will be stored in a RawPDU.
+     * 
+     * \param buffer The buffer from which this PDU will be constructed.
+     * \param total_sz The total size of the buffer.
+     */
+    UDP(const uint8_t* buffer, uint32_t total_sz);
     
-        /** 
-         * \brief UDP constructor.
-         *
-         * Constructs an instance of UDP. The destination and source 
-         * port can be provided, otherwise both of them will be 0.
-         * 
-         * \param dport Destination port.
-         * \param sport Source port.
-         * */
-        UDP(uint16_t dport = 0, uint16_t sport = 0);
+    /** 
+     * \brief Getter for the destination port.
+     * \return The datagram's destination port.
+     */
+    uint16_t dport() const {
+        return Endian::be_to_host(header_.dport);
+    }
 
-        /**
-         * \brief Constructs an UDP object from a buffer.
-         * 
-         * If there is not enough size for a UDP header a malformed_packet 
-         * exception is thrown.
-         * 
-         * Any extra data will be stored in a RawPDU.
-         * 
-         * \param buffer The buffer from which this PDU will be constructed.
-         * \param total_sz The total size of the buffer.
-         */
-        UDP(const uint8_t *buffer, uint32_t total_sz);
-        
-        /** 
-         * \brief Getter for the destination port.
-         * \return The datagram's destination port.
-         */
-        uint16_t dport() const { return Endian::be_to_host(_udp.dport); }
+    /** 
+     * \brief Getter for the source port.
+     * \return The datagram's source port.
+     */
+    uint16_t sport() const {
+        return Endian::be_to_host(header_.sport);
+    }
+    
+    /**
+     * \brief Getter for the length of the datagram.
+     * \return The length of the datagram.
+     */
+    uint16_t length() const {
+        return Endian::be_to_host(header_.len);
+    }
+    
+    /**
+     * \brief Getter for the checksum of the datagram.
+     * \return The datagram's checksum.
+     */
+    uint16_t checksum() const {
+        return Endian::be_to_host(header_.check);
+    }
 
-        /** 
-         * \brief Getter for the source port.
-         * \return The datagram's source port.
-         */
-        uint16_t sport() const { return Endian::be_to_host(_udp.sport); }
-        
-        /**
-         * \brief Getter for the length of the datagram.
-         * \return The length of the datagram.
-         */
-        uint16_t length() const { return Endian::be_to_host(_udp.len); }
-        
-        /**
-         * \brief Getter for the checksum of the datagram.
-         * \return The datagram's checksum.
-         */
-        uint16_t checksum() const { return Endian::be_to_host(_udp.check); }
+    /** 
+     * \brief Set the destination port.
+     * \param new_dport The new destination port.
+     */
+    void dport(uint16_t new_dport);
 
-        /** 
-         * \brief Set the destination port.
-         * \param new_dport The new destination port.
-         */
-        void dport(uint16_t new_dport);
+    /** 
+     * \brief Set the source port.
+     *
+     * \param new_sport The new source port.
+     */
+    void sport(uint16_t new_sport);
+    
+    /** 
+     * \brief Getter for the length field.
+     * \param new_len The new length field.
+     * \return The length field.
+     */
+    void length(uint16_t new_len);
 
-        /** 
-         * \brief Set the source port.
-         *
-         * \param new_sport The new source port.
-         */
-        void sport(uint16_t new_sport);
-        
-        /** 
-         * \brief Getter for the length field.
-         * \param new_len The new length field.
-         * \return The length field.
-         */
-        void length(uint16_t new_len);
+    /**
+     * \brief Check wether ptr points to a valid response for this PDU.
+     *
+     * This compares the source and destination ports in the provided
+     * response with those stored in this PDU.
+     * 
+     * \sa PDU::matches_response
+     * \param ptr The pointer to the buffer.
+     * \param total_sz The size of the buffer.
+     */
+    bool matches_response(const uint8_t* ptr, uint32_t total_sz) const;
 
-        /**
-         * \brief Check wether ptr points to a valid response for this PDU.
-         *
-         * This compares the source and destination ports in the provided
-         * response with those stored in this PDU.
-         * 
-         * \sa PDU::matches_response
-         * \param ptr The pointer to the buffer.
-         * \param total_sz The size of the buffer.
-         */
-        bool matches_response(const uint8_t *ptr, uint32_t total_sz) const;
+    /** 
+     * \brief Returns the header size.
+     *
+     * This metod overrides PDU::header_size. This size includes the
+     * payload and options size. \sa PDU::header_size
+     */
+    uint32_t header_size() const;
+    
+    /**
+     * \brief Getter for the PDU's type.
+     * \sa PDU::pdu_type
+     */
+    PDUType pdu_type() const { return PDU::UDP; }
+    
+    /**
+     * \sa PDU::clone
+     */
+    UDP* clone() const {
+        return new UDP(*this);
+    }
+private:
+    TINS_BEGIN_PACK
+    struct udp_header {
+        uint16_t sport;
+        uint16_t dport;
+        uint16_t len;
+        uint16_t check;
+    } TINS_END_PACK;
 
-        /** 
-         * \brief Returns the header size.
-         *
-         * This metod overrides PDU::header_size. This size includes the
-         * payload and options size. \sa PDU::header_size
-         */
-        uint32_t header_size() const;
-        
-        /**
-         * \brief Getter for the PDU's type.
-         * \sa PDU::pdu_type
-         */
-        PDUType pdu_type() const { return PDU::UDP; }
-        
-        /**
-         * \sa PDU::clone
-         */
-        UDP *clone() const {
-            return new UDP(*this);
-        }
-    private:
-        TINS_BEGIN_PACK
-        struct udphdr {
-            uint16_t sport;
-            uint16_t dport;
-            uint16_t len;
-            uint16_t check;
-        } TINS_END_PACK;
+    void write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent);
 
-        void write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent);
+    udp_header header_;
+};
 
-        udphdr _udp;
-    };
-}
+} // Tins
 
 #endif // TINS_UDP_H
diff --git a/include/tins/utils.h b/include/tins/utils.h
index ecdc51d..e3fcaf4 100644
--- a/include/tins/utils.h
+++ b/include/tins/utils.h
@@ -59,335 +59,351 @@
 #include "internals.h"
 
 namespace Tins {
-    class NetworkInterface;
-    class PacketSender;
-    class PDU;
-    
-    /** 
-     * \brief Network utils namespace.
-     *
-     * This namespace provides utils to convert between integer IP addresses
-     * and dotted notation strings, "net to host" integer conversions, 
-     * interface listing, etc.
+class NetworkInterface;
+class PacketSender;
+class PDU;
+
+/** 
+ * \brief Network utils namespace.
+ *
+ * This namespace provides utils to convert between integer IP addresses
+ * and dotted notation strings, "net to host" integer conversions, 
+ * interface listing, etc.
+ */
+namespace Utils {
+/**
+ * Struct that represents an entry in /proc/net/route
+ */
+struct RouteEntry {
+    /**
+     * This interface's name.
      */
-    namespace Utils {
-        /**
-         * Struct that represents an entry in /proc/net/route
-         */
-        struct RouteEntry {
-            /**
-             * This interface's name.
-             */
-            std::string interface;
-            
-            /**
-             * This route entry's destination.
-             */
-            IPv4Address destination;
-            
-            /**
-             * This route entry's gateway.
-             */
-            IPv4Address gateway;
-            
-            /**
-             * This route entry's subnet mask.
-             */
-            IPv4Address mask;
+    std::string interface;
+    
+    /**
+     * This route entry's destination.
+     */
+    IPv4Address destination;
+    
+    /**
+     * This route entry's gateway.
+     */
+    IPv4Address gateway;
+    
+    /**
+     * This route entry's subnet mask.
+     */
+    IPv4Address mask;
 
-            /**
-             * This route entry's metric.
-             */
-            int metric;
-        };
-        
-        /** 
-         * \brief Resolves a domain name and returns its corresponding ip address.
-         *
-         * If an ip address is given, its integer representation is returned.
-         * Otherwise, the domain name is resolved and its ip address is returned.
-         *
-         * \param to_resolve The domain name/ip address to resolve.
-         */
-        IPv4Address resolve_domain(const std::string &to_resolve);
-        
-        /** 
-         * \brief Resolves a domain name and returns its corresponding ip address.
-         *
-         * If an ip address is given, its integer representation is returned.
-         * Otherwise, the domain name is resolved and its ip address is returned.
-         *
-         * \param to_resolve The domain name/ip address to resolve.
-         */
-        IPv6Address resolve_domain6(const std::string &to_resolve);
-        
-        /** 
-         * \brief Resolves the hardware address for a given ip.
-         *
-         * If the address can't be resolved, a std::runtime_error
-         * exception is thrown.
-         * 
-         * \param iface The interface in which the packet will be sent.
-         * \param ip The ip to resolve, in integer format.
-         * \param sender The sender to use to send and receive the ARP requests.
-         * \return HWAddress<6> containing the resolved hardware address.
-         */
-        HWAddress<6> resolve_hwaddr(const NetworkInterface &iface, 
-          IPv4Address ip, PacketSender &sender);
-        
-        /** 
-         * \brief Resolves the hardware address for a given ip.
-         *
-         * If the address can't be resolved, a std::runtime_error
-         * exception is thrown.
-         * 
-         * This method sends and receives the packet through
-         * PacketSender::default_interface.
-         * 
-         * \param ip The ip to resolve, in integer format.
-         * \param sender The sender to use to send and receive the ARP requests.
-         * \return HWAddress<6> containing the resolved hardware address.
-         */
-        HWAddress<6> resolve_hwaddr(IPv4Address ip, PacketSender &sender);
+    /**
+     * This route entry's metric.
+     */
+    int metric;
+};
 
-        /** \brief List all network interfaces.
-         *
-         * Returns a set of strings, each of them representing the name
-         * of a network interface. These names can be used as the input
-         * interface for Utils::interface_ip, Utils::interface_hwaddr, etc.
-         */
-        std::set<std::string> network_interfaces();
-        
-        /**
-         * \brief Finds the gateway's IP address for the given IP 
-         * address.
-         * 
-         * \param ip The IP address for which the default gateway will
-         * be searched.
-         * \param gw_addr This parameter will contain the gateway's IP
-         * address in case it is found.
-         * 
-         * \return bool indicating wether the lookup was successfull.
-         */
-        bool gateway_from_ip(IPv4Address ip, IPv4Address &gw_addr);
-        
-        
-        /**
-         * \brief Retrieves entries in the routing table.
-         * 
-         * \brief output ForwardIterator in which entries will be stored.
-         */
-        template<class ForwardIterator>
-        void route_entries(ForwardIterator output);
+/** 
+ * \brief Resolves a domain name and returns its corresponding ip address.
+ *
+ * If an ip address is given, its integer representation is returned.
+ * Otherwise, the domain name is resolved and its ip address is returned.
+ *
+ * \param to_resolve The domain name/ip address to resolve.
+ */
+TINS_API IPv4Address resolve_domain(const std::string& to_resolve);
 
-        /**
-         * \brief Retrieves entries in the routing table.
-         * 
-         * \return a vector which contains all of the route entries.
-         */
-        std::vector<RouteEntry> route_entries();
+/** 
+ * \brief Resolves a domain name and returns its corresponding ip address.
+ *
+ * If an ip address is given, its integer representation is returned.
+ * Otherwise, the domain name is resolved and its ip address is returned.
+ *
+ * \param to_resolve The domain name/ip address to resolve.
+ */
+TINS_API IPv6Address resolve_domain6(const std::string& to_resolve);
 
-        /** \brief Returns the 32 bit crc of the given buffer.
-         *
-         * \param data The input buffer.
-         * \param data_size The size of the input buffer.
-         */
-        uint32_t crc32(const uint8_t* data, uint32_t data_size);
+/** 
+ * \brief Resolves the hardware address for a given ip.
+ *
+ * If the address can't be resolved, a std::runtime_error
+ * exception is thrown.
+ * 
+ * \param iface The interface in which the packet will be sent.
+ * \param ip The ip to resolve, in integer format.
+ * \param sender The sender to use to send and receive the ARP requests.
+ * \return HWAddress<6> containing the resolved hardware address.
+ */
+TINS_API HWAddress<6> resolve_hwaddr(const NetworkInterface& iface, 
+                                     IPv4Address ip,
+                                     PacketSender& sender);
 
-        /**
-         * \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 Converts mhz units to the appropriate channel number.
-         * \param mhz The mhz units to be converted.
-         * \return The channel number.
-         */
-        uint16_t mhz_to_channel(uint16_t mhz);
-        
-        /**
-         * \brief Converts a PDUType to a string.
-         * \param pduType The PDUType to be converted.
-         * \return A string representation, for example "DOT11_QOS_DATA".
-         */
-        std::string to_string(PDU::PDUType pduType);
+/** 
+ * \brief Resolves the hardware address for a given ip.
+ *
+ * If the address can't be resolved, a std::runtime_error
+ * exception is thrown.
+ * 
+ * This method sends and receives the packet through
+ * PacketSender::default_interface.
+ * 
+ * \param ip The ip to resolve, in integer format.
+ * \param sender The sender to use to send and receive the ARP requests.
+ * \return HWAddress<6> containing the resolved hardware address.
+ */
+TINS_API HWAddress<6> resolve_hwaddr(IPv4Address ip, PacketSender& sender);
 
-        /** 
-         * \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
-         * bytes, the last one is padded and added to the checksum. 
-         * \param start The pointer to the start of the buffer.
-         * \param end The pointer to the end of the buffer(excluding the last element).
-         * \return Returns the checksum between start and end (non inclusive) 
-         * in network endian
-         */
-        uint32_t do_checksum(const uint8_t *start, const uint8_t *end);
+/** \brief List all network interfaces.
+ *
+ * Returns a set of strings, each of them representing the name
+ * of a network interface. These names can be used as the input
+ * interface for Utils::interface_ip, Utils::interface_hwaddr, etc.
+ */
+TINS_API std::set<std::string> network_interfaces();
 
-        /** 
-         * \brief Computes the 16 bit sum of the input buffer.
-         *
-         * If there's and odd number of bytes in the buffer, the last one is padded and 
-         * added to the checksum. 
-         * \param start The pointer to the start of the buffer.
-         * \param end The pointer to the end of the buffer(excluding the last element).
-         * \return Returns the checksum between start and end (non inclusive) 
-         * in network endian
-         */
-        uint16_t sum_range(const uint8_t *start, const uint8_t *end);
+/**
+ * \brief Finds the gateway's IP address for the given IP 
+ * address.
+ * 
+ * \param ip The IP address for which the default gateway will
+ * be searched.
+ * \param gw_addr This parameter will contain the gateway's IP
+ * address in case it is found.
+ * 
+ * \return bool indicating wether the lookup was successfull.
+ */
+TINS_API bool gateway_from_ip(IPv4Address ip, IPv4Address& gw_addr);
 
-        /** \brief Performs the pseudo header checksum used in TCP and UDP PDUs.
-         *
-         * \param source_ip The source ip address.
-         * \param dest_ip The destination ip address.
-         * \param len The length to be included in the pseudo header.
-         * \param flag The flag to use in the protocol field of the pseudo header.
-         * \return The pseudo header checksum.
-         */
-        uint32_t pseudoheader_checksum(IPv4Address source_ip, IPv4Address dest_ip, uint16_t len, uint16_t flag);
-        
-        /** \brief Performs the pseudo header checksum used in TCP and UDP PDUs.
-         *
-         * \param source_ip The source ip address.
-         * \param dest_ip The destination ip address.
-         * \param len The length to be included in the pseudo header.
-         * \param flag The flag to use in the protocol field of the pseudo header.
-         * \return The pseudo header checksum.
-         */
-        uint32_t pseudoheader_checksum(IPv6Address source_ip, IPv6Address dest_ip, uint16_t len, uint16_t flag);
 
-        /** \brief Generic function to iterate through interface and collect
-         * data.
-         *
-         * The parameter is applied to every interface found, allowing
-         * the object to collect data from them.
-         * \param functor An instance of an class which implements operator(struct ifaddrs*).
-         */
-        #ifndef _WIN32
-        template<class Functor> 
-        void generic_iface_loop(Functor &functor) {
-            struct ifaddrs *ifaddrs = 0;
-            struct ifaddrs *if_it = 0;
-            getifaddrs(&ifaddrs);
-            for(if_it = ifaddrs; if_it; if_it = if_it->ifa_next) {
-                if(functor(if_it))
-                    break;
-            }
-            if(ifaddrs)
-                freeifaddrs(ifaddrs);
+/**
+ * \brief Retrieves entries in the routing table.
+ * 
+ * \brief output ForwardIterator in which entries will be stored.
+ */
+template<class ForwardIterator>
+void route_entries(ForwardIterator output);
+
+/**
+ * \brief Retrieves entries in the routing table.
+ * 
+ * \return a vector which contains all of the route entries.
+ */
+TINS_API std::vector<RouteEntry> route_entries();
+
+/** \brief Returns the 32 bit crc of the given buffer.
+ *
+ * \param data The input buffer.
+ * \param data_size The size of the input buffer.
+ */
+TINS_API 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.
+ */
+TINS_API uint16_t channel_to_mhz(uint16_t channel);
+
+/**
+ * \brief Converts mhz units to the appropriate channel number.
+ * \param mhz The mhz units to be converted.
+ * \return The channel number.
+ */
+TINS_API uint16_t mhz_to_channel(uint16_t mhz);
+
+/**
+ * \brief Converts a PDUType to a string.
+ * \param pduType The PDUType to be converted.
+ * \return A string representation, for example "DOT11_QOS_DATA".
+ */
+TINS_API std::string to_string(PDU::PDUType pduType);
+
+/** 
+ * \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
+ * bytes, the last one is padded and added to the checksum. 
+ * \param start The pointer to the start of the buffer.
+ * \param end The pointer to the end of the buffer(excluding the last element).
+ * \return Returns the checksum between start and end (non inclusive) 
+ * in network endian
+ */
+TINS_API uint32_t do_checksum(const uint8_t* start, const uint8_t* end);
+
+/** 
+ * \brief Computes the 16 bit sum of the input buffer.
+ *
+ * If there's and odd number of bytes in the buffer, the last one is padded and 
+ * added to the checksum. 
+ * \param start The pointer to the start of the buffer.
+ * \param end The pointer to the end of the buffer(excluding the last element).
+ * \return Returns the checksum between start and end (non inclusive) 
+ * in network endian
+ */
+TINS_API uint16_t sum_range(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.
+ * \param dest_ip The destination ip address.
+ * \param len The length to be included in the pseudo header.
+ * \param flag The flag to use in the protocol field of the pseudo header.
+ * \return The pseudo header checksum.
+ */
+TINS_API uint32_t pseudoheader_checksum(IPv4Address source_ip,
+                                        IPv4Address dest_ip,
+                                        uint16_t len,
+                                        uint16_t flag);
+
+/** \brief Performs the pseudo header checksum used in TCP and UDP PDUs.
+ *
+ * \param source_ip The source ip address.
+ * \param dest_ip The destination ip address.
+ * \param len The length to be included in the pseudo header.
+ * \param flag The flag to use in the protocol field of the pseudo header.
+ * \return The pseudo header checksum.
+ */
+TINS_API uint32_t pseudoheader_checksum(IPv6Address source_ip,  
+                                        IPv6Address dest_ip,
+                                        uint16_t len,
+                                        uint16_t flag);
+
+/** \brief Generic function to iterate through interface and collect
+ * data.
+ *
+ * The parameter is applied to every interface found, allowing
+ * the object to collect data from them.
+ * \param functor An instance of an class which implements operator(struct ifaddrs*).
+ */
+#ifndef _WIN32
+template<class Functor> 
+void generic_iface_loop(Functor& functor) {
+    struct ifaddrs* ifaddrs = 0;
+    struct ifaddrs* if_it = 0;
+    getifaddrs(&ifaddrs);
+    for (if_it = ifaddrs; if_it; if_it = if_it->ifa_next) {
+        if (functor(if_it)) {
+            break;
         }
-        #else // _WIN32
-        template<class Functor> 
-        void generic_iface_loop(Functor &functor) {
-            ULONG size;
-            ::GetAdaptersAddresses(AF_INET, 0, 0, 0, &size);
-            std::vector<uint8_t> buffer(size);
-            if (::GetAdaptersAddresses(AF_INET, 0, 0, (IP_ADAPTER_ADDRESSES *)&buffer[0], &size) == ERROR_SUCCESS) {
-                PIP_ADAPTER_ADDRESSES iface = (IP_ADAPTER_ADDRESSES *)&buffer[0];
-                while(iface) {
-                    if(functor(iface))
-                        break;
-                    iface = iface->Next;
-                }
-            }
-        }
-        #endif // _WIN32
-        
-        template <typename T>
-        struct is_pdu {  
-            template <typename U>
-            static char test(typename U::PDUType*);
-             
-            template <typename U>
-            static long test(...);
-         
-            static const bool value = sizeof(test<T>(0)) == 1;
-        };
-
-        /**
-         * Returns the argument.
-         */
-        inline PDU& dereference_until_pdu(PDU &pdu) {
-            return pdu;
-        }
-        
-        /**
-         * \brief Dereferences the parameter until a PDU is found.
-         * 
-         * This function dereferences the parameter until a PDU object
-         * is found. When it's found, it is returned. 
-         * 
-         * \param value The parameter to be dereferenced.
-         */
-        template<typename T> 
-        inline typename Internals::enable_if<!is_pdu<T>::value, PDU&>::type 
-        dereference_until_pdu(T &value) {
-            return dereference_until_pdu(*value);
-        }
-        #if defined(BSD) || defined(__FreeBSD_kernel__)
-        inline std::vector<char> query_route_table() {
-            int mib[6];
-            std::vector<char> buf;
-            size_t len;
-
-            mib[0] = CTL_NET;
-            mib[1] = AF_ROUTE;
-            mib[2] = 0;
-            mib[3] = AF_INET;
-            mib[4] = NET_RT_DUMP;
-            mib[5] = 0;	
-            if (sysctl(mib, 6, NULL, &len, NULL, 0) < 0)
-                throw std::runtime_error("sysctl failed");
-
-            buf.resize(len);
-            if (sysctl(mib, 6, &buf[0], &len, NULL, 0) < 0) {
-                throw std::runtime_error("sysctl failed");
-            }
-
-            return buf;
-        }
-
-        template<typename ForwardIterator>
-        void parse_header(struct rt_msghdr *rtm, ForwardIterator iter)
-        {
-            char *ptr = (char *)(rtm + 1);
-            sockaddr *sa = 0;
-
-            for (int i = 0; i < RTAX_MAX; i++) {
-                if (rtm->rtm_addrs & (1 << i)) {
-                    sa = (struct sockaddr *)ptr;
-                    ptr += sa->sa_len;
-                    if (sa->sa_family == 0)
-                        sa = 0;
-                } 
-                *iter++ = sa;
-            }
-        }
-        #endif
+    }
+    if (ifaddrs) {
+        freeifaddrs(ifaddrs);
     }
 }
+#else // _WIN32
+template<class Functor> 
+void generic_iface_loop(Functor& functor) {
+    ULONG size;
+    ::GetAdaptersAddresses(AF_INET, 0, 0, 0, &size);
+    std::vector<uint8_t> buffer(size);
+    if (::GetAdaptersAddresses(AF_INET, 0, 0, (IP_ADAPTER_ADDRESSES *)&buffer[0], &size) == ERROR_SUCCESS) {
+        PIP_ADAPTER_ADDRESSES iface = (IP_ADAPTER_ADDRESSES *)&buffer[0];
+        while (iface) {
+            if (functor(iface)) {
+                break;
+            }
+            iface = iface->Next;
+        }
+    }
+}
+#endif // _WIN32
+
+template <typename T>
+struct is_pdu {  
+    template <typename U>
+    static char test(typename U::PDUType*);
+     
+    template <typename U>
+    static long test(...);
+ 
+    static const bool value = sizeof(test<T>(0)) == 1;
+};
+
+/**
+ * Returns the argument.
+ */
+inline PDU& dereference_until_pdu(PDU& pdu) {
+    return pdu;
+}
+
+/**
+ * \brief Dereferences the parameter until a PDU is found.
+ * 
+ * This function dereferences the parameter until a PDU object
+ * is found. When it's found, it is returned. 
+ * 
+ * \param value The parameter to be dereferenced.
+ */
+template<typename T> 
+inline typename Internals::enable_if<!is_pdu<T>::value, PDU&>::type 
+dereference_until_pdu(T& value) {
+    return dereference_until_pdu(*value);
+}
+
+#if defined(BSD) || defined(__FreeBSD_kernel__)
+inline std::vector<char> query_route_table() {
+    int mib[6];
+    std::vector<char> buf;
+    size_t len;
+
+    mib[0] = CTL_NET;
+    mib[1] = AF_ROUTE;
+    mib[2] = 0;
+    mib[3] = AF_INET;
+    mib[4] = NET_RT_DUMP;
+    mib[5] = 0;	
+    if (sysctl(mib, 6, NULL, &len, NULL, 0) < 0) {
+        throw std::runtime_error("sysctl failed");
+    }
+
+    buf.resize(len);
+    if (sysctl(mib, 6, &buf[0], &len, NULL, 0) < 0) {
+        throw std::runtime_error("sysctl failed");
+    }
+
+    return buf;
+}
+
+template<typename ForwardIterator>
+void parse_header(struct rt_msghdr* rtm, ForwardIterator iter) {
+    char* ptr = (char *)(rtm + 1);
+    sockaddr* sa = 0;
+
+    for (int i = 0; i < RTAX_MAX; i++) {
+        if (rtm->rtm_addrs & (1 << i)) {
+            sa = (struct sockaddr *)ptr;
+            ptr += sa->sa_len;
+            if (sa->sa_family == 0) {
+                sa = 0;
+            }
+        } 
+        *iter++ = sa;
+    }
+}
+#endif
+
+} // Utils
+} // Tins
+
 #if defined(BSD) || defined(__FreeBSD_kernel__)
 template<class ForwardIterator>
 void Tins::Utils::route_entries(ForwardIterator output) {
     std::vector<char> buffer = query_route_table();
-    char *next = &buffer[0], *end = &buffer[buffer.size()];
-    rt_msghdr *rtm;
+    char* next = &buffer[0], *end = &buffer[buffer.size()];
+    rt_msghdr* rtm;
     std::vector<sockaddr*> sa(RTAX_MAX);
     char iface_name[IF_NAMESIZE];
-    while(next < end) {
+    while (next < end) {
         rtm = (rt_msghdr*)next;
         parse_header(rtm, sa.begin());
         if (sa[RTAX_DST] && sa[RTAX_GATEWAY] && if_indextoname(rtm->rtm_index, iface_name)) {
             RouteEntry entry;
             entry.destination = IPv4Address(((struct sockaddr_in *)sa[RTAX_DST])->sin_addr.s_addr);
             entry.gateway = IPv4Address(((struct sockaddr_in *)sa[RTAX_GATEWAY])->sin_addr.s_addr);
-            if(sa[RTAX_GENMASK])
+            if (sa[RTAX_GENMASK]) {
                 entry.mask = IPv4Address(((struct sockaddr_in *)sa[RTAX_GENMASK])->sin_addr.s_addr);
-            else
+            }
+            else {
                 entry.mask = IPv4Address(uint32_t());
+            }
             entry.interface = iface_name;
             entry.metric = 0;
             *output++ = entry;
@@ -398,7 +414,7 @@ void Tins::Utils::route_entries(ForwardIterator output) {
 #elif defined(_WIN32)
 template<class ForwardIterator>
 void Tins::Utils::route_entries(ForwardIterator output) {
-    MIB_IPFORWARDTABLE *table;
+    MIB_IPFORWARDTABLE* table;
     ULONG size = 0;
     GetIpForwardTable(0, &size, 0);
     std::vector<uint8_t> buffer(size);
@@ -406,9 +422,9 @@ void Tins::Utils::route_entries(ForwardIterator output) {
     GetIpForwardTable(table, &size, 0);
     
     for (DWORD i = 0; i < table->dwNumEntries; i++) {
-        MIB_IPFORWARDROW *row = &table->table[i];
-        if(row->dwForwardType == MIB_IPROUTE_TYPE_INDIRECT || 
-                row->dwForwardType == MIB_IPROUTE_TYPE_DIRECT) {
+        MIB_IPFORWARDROW* row = &table->table[i];
+        if (row->dwForwardType == MIB_IPROUTE_TYPE_INDIRECT || 
+            row->dwForwardType == MIB_IPROUTE_TYPE_DIRECT) {
             RouteEntry entry;
             entry.interface = NetworkInterface::from_index(row->dwForwardIfIndex).name();
             entry.destination = IPv4Address(row->dwForwardDest);
@@ -428,9 +444,10 @@ void Tins::Utils::route_entries(ForwardIterator output) {
     uint32_t dummy;
     skip_line(input);
     RouteEntry entry;
-    while(input >> entry.interface >> destination >> gw) {
-        for(unsigned i(0); i < 4; ++i)
+    while (input >> entry.interface >> destination >> gw) {
+        for (unsigned i(0); i < 4; ++i) {
             input >> metric;
+        }
         input >> mask;
         from_hex(destination, dummy);
         entry.destination = IPv4Address(dummy);
diff --git a/src/address_range.cpp b/src/address_range.cpp
index bdb134b..00e94a1 100644
--- a/src/address_range.cpp
+++ b/src/address_range.cpp
@@ -31,22 +31,27 @@
 #include "ip_address.h"
 #include "ipv6_address.h"
 
+using std::logic_error;
+
 namespace Tins {
-IPv4Range operator/(const IPv4Address &addr, int mask) {
-    if(mask > 32)
-        throw std::logic_error("Prefix length cannot exceed 32");
+
+IPv4Range operator/(const IPv4Address& addr, int mask) {
+    if (mask > 32) {
+        throw logic_error("Prefix length cannot exceed 32");
+    }
     return IPv4Range::from_mask(
         addr, 
         IPv4Address(Endian::host_to_be(0xffffffff << (32 - mask)))
     );
 }
 
-IPv6Range operator/(const IPv6Address &addr, int mask) {
-    if(mask > 128)
+IPv6Range operator/(const IPv6Address& addr, int mask) {
+    if (mask > 128) {
         throw std::logic_error("Prefix length cannot exceed 128");
+    }
     IPv6Address last_addr;
     IPv6Address::iterator it = last_addr.begin();
-    while(mask > 8) {
+    while (mask > 8) {
         *it = 0xff;
         ++it;
         mask -= 8;
@@ -54,4 +59,5 @@ IPv6Range operator/(const IPv6Address &addr, int mask) {
     *it = 0xff << (8 - mask);
     return IPv6Range::from_mask(addr, last_addr);
 }
-}
\ No newline at end of file
+
+} // Tins
diff --git a/src/arp.cpp b/src/arp.cpp
index c6da88c..9ef3fb1 100644
--- a/src/arp.cpp
+++ b/src/arp.cpp
@@ -38,17 +38,16 @@
 #include "exceptions.h"
 #include "memory_helpers.h"
 
-using std::runtime_error;
-
 using Tins::Memory::InputMemoryStream;
 using Tins::Memory::OutputMemoryStream;
 
 namespace Tins {
 
-ARP::ARP(ipaddress_type target_ip, ipaddress_type sender_ip, 
-const hwaddress_type &target_hw, const hwaddress_type &sender_hw)
-: _arp() 
-{
+ARP::ARP(ipaddress_type target_ip, 
+         ipaddress_type sender_ip, 
+         const hwaddress_type& target_hw, 
+         const hwaddress_type& sender_hw) 
+: header_() {
     hw_addr_format((uint16_t)Constants::ARP::ETHER);
     prot_addr_format((uint16_t)Constants::Ethernet::IP);
     hw_addr_length(Tins::EthernetII::address_type::address_size);
@@ -59,89 +58,92 @@ const hwaddress_type &target_hw, const hwaddress_type &sender_hw)
     target_hw_addr(target_hw);
 }
 
-ARP::ARP(const uint8_t *buffer, uint32_t total_sz) 
-{
+ARP::ARP(const uint8_t* buffer, uint32_t total_sz) {
     InputMemoryStream stream(buffer, total_sz);
-    stream.read(_arp);
+    stream.read(header_);
     if (stream) {
         inner_pdu(new RawPDU(stream.pointer(), stream.size()));
     }
 }
 
-void ARP::sender_hw_addr(const hwaddress_type &new_snd_hw_addr) {
-    std::copy(new_snd_hw_addr.begin(), new_snd_hw_addr.end(), _arp.ar_sha);
+void ARP::sender_hw_addr(const hwaddress_type& address) {
+    address.copy(header_.sender_hw_address);
 }
 
-void ARP::sender_ip_addr(ipaddress_type new_snd_ip_addr) {
-    this->_arp.ar_sip = new_snd_ip_addr;
+void ARP::sender_ip_addr(ipaddress_type address) {
+    header_.sender_ip_address = address;
 }
 
-void ARP::target_hw_addr(const hwaddress_type &new_tgt_hw_addr) {
-    std::copy(new_tgt_hw_addr.begin(), new_tgt_hw_addr.end(), _arp.ar_tha);
+void ARP::target_hw_addr(const hwaddress_type& address) {
+    address.copy(header_.target_hw_address);
 }
 
-void ARP::target_ip_addr(ipaddress_type new_tgt_ip_addr) {
-    this->_arp.ar_tip = new_tgt_ip_addr;
+void ARP::target_ip_addr(ipaddress_type address) {
+    header_.target_ip_address = address;
 }
 
-void ARP::hw_addr_format(uint16_t new_hw_addr_fmt) {
-    this->_arp.ar_hrd = Endian::host_to_be(new_hw_addr_fmt);
+void ARP::hw_addr_format(uint16_t format) {
+    header_.hw_address_format = Endian::host_to_be(format);
 }
 
-void ARP::prot_addr_format(uint16_t new_prot_addr_fmt) {
-    this->_arp.ar_pro = Endian::host_to_be(new_prot_addr_fmt);
+void ARP::prot_addr_format(uint16_t format) {
+    header_.proto_address_format = Endian::host_to_be(format);
 }
 
-void ARP::hw_addr_length(uint8_t new_hw_addr_len) {
-    this->_arp.ar_hln = new_hw_addr_len;
+void ARP::hw_addr_length(uint8_t length) {
+    header_.hw_address_length = length;
 }
 
-void ARP::prot_addr_length(uint8_t new_prot_addr_len) {
-    this->_arp.ar_pln = new_prot_addr_len;
+void ARP::prot_addr_length(uint8_t length) {
+    header_.proto_address_length = length;
 }
 
-void ARP::opcode(Flags new_opcode) {
-    this->_arp.ar_op = Endian::host_to_be<uint16_t>(new_opcode);
+void ARP::opcode(Flags code) {
+    header_.opcode = Endian::host_to_be<uint16_t>(code);
 }
 
 uint32_t ARP::header_size() const {
-    return sizeof(arphdr);
+    return sizeof(header_);
 }
 
-void ARP::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *) {
+void ARP::write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU *) {
     OutputMemoryStream stream(buffer, total_sz);
-    stream.write(_arp);
+    stream.write(header_);
 }
 
-bool ARP::matches_response(const uint8_t *ptr, uint32_t total_sz) const {
-    if(total_sz < sizeof(arphdr))
+bool ARP::matches_response(const uint8_t* ptr, uint32_t total_sz) const {
+    if (total_sz < sizeof(header_)) {
         return false;
-    const arphdr *arp_ptr = (const arphdr*)ptr;
-    return arp_ptr->ar_sip == _arp.ar_tip && arp_ptr->ar_tip == _arp.ar_sip;
+    }
+    const arp_header* arp_ptr = (const arp_header*)ptr;
+    return arp_ptr->sender_ip_address == header_.target_ip_address && 
+           arp_ptr->target_ip_address == header_.sender_ip_address;
 }
 
-EthernetII ARP::make_arp_request(ipaddress_type target, ipaddress_type sender, 
-const hwaddress_type &hw_snd) 
-{
-    /* Create ARP packet and set its attributes */
+EthernetII ARP::make_arp_request(ipaddress_type target, 
+                                 ipaddress_type sender, 
+                                 const hwaddress_type& hw_snd) {
+    // Create ARP packet and set its attributes
     ARP arp;
     arp.target_ip_addr(target);
     arp.sender_ip_addr(sender);
     arp.sender_hw_addr(hw_snd);
     arp.opcode(REQUEST);
 
-    /* Create the EthernetII PDU with the ARP PDU as its inner PDU */
+    // Create the EthernetII PDU with the ARP PDU as its inner PDU
     return EthernetII(EthernetII::BROADCAST, hw_snd) / arp;
 }
 
-EthernetII ARP::make_arp_reply(ipaddress_type target, ipaddress_type sender, 
-const hwaddress_type &hw_tgt, const hwaddress_type &hw_snd) 
-{
-    /* Create ARP packet and set its attributes */
+EthernetII ARP::make_arp_reply(ipaddress_type target, 
+                               ipaddress_type sender, 
+                               const hwaddress_type& hw_tgt, 
+                               const hwaddress_type& hw_snd)  {
+    // Create ARP packet and set its attributes
     ARP arp(target, sender, hw_tgt, hw_snd);
     arp.opcode(REPLY);
 
-    /* Create the EthernetII PDU with the ARP PDU as its inner PDU */
+    // Create the EthernetII PDU with the ARP PDU as its inner PDU
     return EthernetII(hw_tgt, hw_snd) / arp;
 }
-}
+
+} // Tins
diff --git a/src/bootp.cpp b/src/bootp.cpp
index d2a0d24..6a2745e 100644
--- a/src/bootp.cpp
+++ b/src/bootp.cpp
@@ -33,98 +33,100 @@
 #include "exceptions.h"
 #include "memory_helpers.h"
 
+using std::copy;
+
 using Tins::Memory::InputMemoryStream;
 using Tins::Memory::OutputMemoryStream;
 
 namespace Tins{
 
 BootP::BootP() 
-: _bootp(), _vend(64) {
+: bootp_(), vend_(64) {
 
 }
 
-BootP::BootP(const uint8_t *buffer, uint32_t total_sz, uint32_t vend_field_size) 
-: _vend(vend_field_size) 
-{
+BootP::BootP(const uint8_t* buffer, uint32_t total_sz, uint32_t vend_field_size) 
+: vend_(vend_field_size) {
     InputMemoryStream stream(buffer, total_sz);
-    stream.read(_bootp);
-    buffer += sizeof(bootphdr);
-    total_sz -= sizeof(bootphdr);
-    _vend.assign(stream.pointer(), stream.pointer() + vend_field_size);
+    stream.read(bootp_);
+    if (!stream.can_read(vend_field_size)) {
+        throw malformed_packet();
+    }
+    stream.read(vend_, vend_field_size);
 }
 
 uint32_t BootP::header_size() const {
-    return static_cast<uint32_t>(sizeof(bootphdr) + _vend.size());
+    return static_cast<uint32_t>(sizeof(bootp_) + vend_.size());
 }
 
-void BootP::opcode(uint8_t new_opcode) {
-    _bootp.opcode = new_opcode;
+void BootP::opcode(uint8_t code) {
+    bootp_.opcode = code;
 }
 
-void BootP::htype(uint8_t new_htype) {
-    _bootp.htype = new_htype;
+void BootP::htype(uint8_t type) {
+    bootp_.htype = type;
 }
 
-void BootP::hlen(uint8_t new_hlen) {
-    _bootp.hlen = new_hlen;
+void BootP::hlen(uint8_t length) {
+    bootp_.hlen = length;
 }
 
-void BootP::hops(uint8_t new_hops) {
-    _bootp.hops = new_hops;
+void BootP::hops(uint8_t count) {
+    bootp_.hops = count;
 }
 
-void BootP::xid(uint32_t new_xid) {
-    _bootp.xid = Endian::host_to_be(new_xid);
+void BootP::xid(uint32_t identifier) {
+    bootp_.xid = Endian::host_to_be(identifier);
 }
 
-void BootP::secs(uint16_t new_secs) {
-    _bootp.secs = Endian::host_to_be(new_secs);
+void BootP::secs(uint16_t value) {
+    bootp_.secs = Endian::host_to_be(value);
 }
 
-void BootP::padding(uint16_t new_padding) {
-    _bootp.padding = Endian::host_to_be(new_padding);
+void BootP::padding(uint16_t value) {
+    bootp_.padding = Endian::host_to_be(value);
 }
 
-void BootP::ciaddr(ipaddress_type new_ciaddr) {
-    _bootp.ciaddr = new_ciaddr;
+void BootP::ciaddr(ipaddress_type address) {
+    bootp_.ciaddr = address;
 }
 
-void BootP::yiaddr(ipaddress_type new_yiaddr) {
-    _bootp.yiaddr = new_yiaddr;
+void BootP::yiaddr(ipaddress_type address) {
+    bootp_.yiaddr = address;
 }
 
-void BootP::siaddr(ipaddress_type new_siaddr) {
-    _bootp.siaddr = new_siaddr;
+void BootP::siaddr(ipaddress_type address) {
+    bootp_.siaddr = address;
 }
 
-void BootP::giaddr(ipaddress_type new_giaddr) {
-    _bootp.giaddr = new_giaddr;
+void BootP::giaddr(ipaddress_type address) {
+    bootp_.giaddr = address;
 }
 
-void BootP::sname(const uint8_t *new_sname) {
-    //std::memcpy(_bootp.sname, new_sname, sizeof(_bootp.sname));
-    std::copy(new_sname, new_sname + sizeof(_bootp.sname), _bootp.sname);
+void BootP::sname(const uint8_t* new_sname) {
+    copy(new_sname, new_sname + sizeof(bootp_.sname), bootp_.sname);
 }
 
-void BootP::file(const uint8_t *new_file) {
-    //std::memcpy(_bootp.file, new_file, sizeof(_bootp.file));
-    std::copy(new_file, new_file + sizeof(_bootp.file), _bootp.file);
+void BootP::file(const uint8_t* new_file) {
+    copy(new_file, new_file + sizeof(bootp_.file), bootp_.file);
 }
 
-void BootP::vend(const vend_type &new_vend) {
-    _vend = new_vend;
+void BootP::vend(const vend_type& newvend_) {
+    vend_ = newvend_;
 }
 
-void BootP::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent) {
+void BootP::write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent) {
     OutputMemoryStream stream(buffer, total_sz);
-    stream.write(_bootp);
-    stream.write(_vend.begin(), _vend.end());
+    stream.write(bootp_);
+    stream.write(vend_.begin(), vend_.end());
 }
 
-bool BootP::matches_response(const uint8_t *ptr, uint32_t total_sz) const {
-    if(total_sz < sizeof(bootphdr))
+bool BootP::matches_response(const uint8_t* ptr, uint32_t total_sz) const {
+    if (total_sz < sizeof(bootp_)) {
         return false;
-    const bootphdr *bootp_ptr = (const bootphdr *)ptr;
-    return bootp_ptr->xid == _bootp.xid;
-}
+    }
+    const bootp_header* bootp_ptr = (const bootp_header *)ptr;
+    return bootp_ptr->xid == bootp_.xid;
 }
+
+} // Tins
diff --git a/src/crypto.cpp b/src/crypto.cpp
index ab22cc4..183c7ee 100644
--- a/src/crypto.cpp
+++ b/src/crypto.cpp
@@ -40,42 +40,57 @@
 #include "dot11/dot11_beacon.h"
 #include "exceptions.h"
 
+using std::string;
+using std::make_pair;
+using std::equal;
+using std::copy;
+using std::min;
+using std::max;
+using std::lexicographical_compare;
+using std::fill;
+using std::runtime_error;
+
 namespace Tins {
 namespace Crypto {
+
 WEPDecrypter::WEPDecrypter() 
-: key_buffer(4) {
+: key_buffer_(4) {
     
 }
 
-void WEPDecrypter::add_password(const address_type &addr, const std::string &password) {
-    passwords[addr] = password;
-    key_buffer.resize(std::max(3 + password.size(), key_buffer.size()));
+void WEPDecrypter::add_password(const address_type& addr, const string& password) {
+    passwords_[addr] = password;
+    key_buffer_.resize(max(3 + password.size(), key_buffer_.size()));
 }
 
-void WEPDecrypter::remove_password(const address_type &addr) {
-    passwords.erase(addr); 
+void WEPDecrypter::remove_password(const address_type& addr) {
+    passwords_.erase(addr); 
 }
 
-bool WEPDecrypter::decrypt(PDU &pdu) {
-    Dot11Data *dot11 = pdu.find_pdu<Dot11Data>();
-    if(dot11) {
-        RawPDU *raw = dot11->find_pdu<RawPDU>();
-        if(raw) {
+bool WEPDecrypter::decrypt(PDU& pdu) {
+    Dot11Data* dot11 = pdu.find_pdu<Dot11Data>();
+    if (dot11) {
+        RawPDU* raw = dot11->find_pdu<RawPDU>();
+        if (raw) {
             address_type addr;
-            if(!dot11->from_ds() && !dot11->to_ds())
+            if (!dot11->from_ds() && !dot11->to_ds()) {
                 addr = dot11->addr3();
-            else if(!dot11->from_ds() && dot11->to_ds())
+            }
+            else if (!dot11->from_ds() && dot11->to_ds()) {
                 addr = dot11->addr1();
-            else if(dot11->from_ds() && !dot11->to_ds())
+            }
+            else if (dot11->from_ds() && !dot11->to_ds()) {
                 addr = dot11->addr2();
-            else
+            }
+            else {
                 // ????
                 addr = dot11->addr3();
-            passwords_type::iterator it = passwords.find(addr);
-            if(it != passwords.end()) {
+            }
+            passwords_type::iterator it = passwords_.find(addr);
+            if (it != passwords_.end()) {
                 dot11->inner_pdu(decrypt(*raw, it->second));
                 // If its valid, then return true
-                if(dot11->inner_pdu()) {
+                if (dot11->inner_pdu()) {
                     // it's no longer encrypted.
                     dot11->wep(0);
                     return true;
@@ -86,29 +101,31 @@ bool WEPDecrypter::decrypt(PDU &pdu) {
     return false;
 }
 
-PDU *WEPDecrypter::decrypt(RawPDU &raw, const std::string &password) {
-    RawPDU::payload_type &pload = raw.payload();
+PDU* WEPDecrypter::decrypt(RawPDU& raw, const string& password) {
+    RawPDU::payload_type& pload = raw.payload();
     // We require at least the IV, the encrypted checksum and something to decrypt
-    if(pload.size() <= 8)
+    if (pload.size() <= 8) {
         return 0;
-    std::copy(pload.begin(), pload.begin() + 3, key_buffer.begin());
-    std::copy(password.begin(), password.end(), key_buffer.begin() + 3);
+    }
+    copy(pload.begin(), pload.begin() + 3, key_buffer_.begin());
+    copy(password.begin(), password.end(), key_buffer_.begin() + 3);
     
     // Generate the key
-    RC4Key key(key_buffer.begin(), key_buffer.begin() + password.size() + 3);
+    RC4Key key(key_buffer_.begin(), key_buffer_.begin() + password.size() + 3);
     rc4(pload.begin() + 4, pload.end(), key, pload.begin());
     uint32_t payload_size = static_cast<uint32_t>(pload.size() - 8);
     uint32_t crc = Utils::crc32(&pload[0], payload_size);
-    if(pload[pload.size() - 8] != (crc & 0xff) ||
+    if (pload[pload.size() - 8] != (crc & 0xff) ||
         pload[pload.size() - 7] != ((crc >> 8) & 0xff) ||
         pload[pload.size() - 6] != ((crc >> 16) & 0xff) ||
-        pload[pload.size() - 5] != ((crc >> 24) & 0xff))
+        pload[pload.size() - 5] != ((crc >> 24) & 0xff)) {
         return 0;
+    }
     
     try {
         return new SNAP(&pload[0], payload_size);
     }
-    catch(std::runtime_error&) {
+    catch (exception_base&) {
         return 0;
     }
 }
@@ -118,17 +135,17 @@ PDU *WEPDecrypter::decrypt(RawPDU &raw, const std::string &password) {
 
 using WPA2::SessionKeys;
 
-const HWAddress<6> &min(const HWAddress<6>& lhs, const HWAddress<6>& rhs) {
+const HWAddress<6>& min(const HWAddress<6>& lhs, const HWAddress<6>& rhs) {
     return lhs < rhs ? lhs : rhs;
 }
 
-const HWAddress<6> &max(const HWAddress<6>& lhs, const HWAddress<6>& rhs) {
+const HWAddress<6>& max(const HWAddress<6>& lhs, const HWAddress<6>& rhs) {
     return lhs < rhs ? rhs : lhs;
 }
 
 template<typename InputIterator1, typename InputIterator2, typename OutputIterator>
 void xor_range(InputIterator1 src1, InputIterator2 src2, OutputIterator dst, size_t sz) {
-    for(size_t i = 0; i < sz; ++i) {
+    for (size_t i = 0; i < sz; ++i) {
         *dst++ = *src1++ ^ *src2++;
     }
 }
@@ -224,13 +241,16 @@ uint16_t lower_byte(uint16_t value) {
     return value & 0xff;
 }
 
-HWAddress<6> get_bssid(const Dot11Data &dot11) {
-    if(dot11.from_ds() && !dot11.to_ds())
+HWAddress<6> get_bssid(const Dot11Data& dot11) {
+    if (dot11.from_ds() && !dot11.to_ds()) {
         return dot11.addr3();
-    else if(!dot11.from_ds() && dot11.to_ds())
+    }
+    else if (!dot11.from_ds() && dot11.to_ds()) {
         return dot11.addr2();
-    else 
+    }
+    else {
         return dot11.addr2();
+    }
 }
 
 namespace WPA2 {
@@ -243,51 +263,55 @@ SessionKeys::SessionKeys() {
 }
 
 SessionKeys::SessionKeys(const ptk_type& ptk, bool is_ccmp) 
-: ptk(ptk), is_ccmp(is_ccmp) {
-    if (ptk.size() != PTK_SIZE) {
+: ptk_(ptk), is_ccmp_(is_ccmp) {
+    if (ptk_.size() != PTK_SIZE) {
         throw invalid_handshake();
     }
 }
 
-SessionKeys::SessionKeys(const RSNHandshake &hs, const pmk_type &pmk) 
-: ptk(PTK_SIZE) {
+SessionKeys::SessionKeys(const RSNHandshake& hs, const pmk_type& pmk) 
+: ptk_(PTK_SIZE) {
     if (pmk.size() != PMK_SIZE) {
         throw invalid_handshake();
     }
 
     uint8_t PKE[100] = "Pairwise key expansion";
     uint8_t MIC[20];
-    is_ccmp = (hs.handshake()[3].key_descriptor() == 2);
+    is_ccmp_ = (hs.handshake()[3].key_descriptor() == 2);
     
     min(hs.client_address(), hs.supplicant_address()).copy(PKE + 23);
     max(hs.client_address(), hs.supplicant_address()).copy(PKE + 29);
-    const uint8_t *nonce1 = hs.handshake()[1].nonce(), 
+    const uint8_t* nonce1 = hs.handshake()[1].nonce(), 
                   *nonce2 = hs.handshake()[2].nonce();
-    if(std::lexicographical_compare(nonce1, nonce1 + 32, nonce2, nonce2 + 32)) {
-        std::copy(nonce1, nonce1 + 32, PKE + 35);
-        std::copy(nonce2, nonce2 + 32, PKE + 67);
+    if (lexicographical_compare(nonce1, nonce1 + 32, nonce2, nonce2 + 32)) {
+        copy(nonce1, nonce1 + 32, PKE + 35);
+        copy(nonce2, nonce2 + 32, PKE + 67);
     }
     else {
-        std::copy(nonce2, nonce2 + 32, PKE + 35);
-        std::copy(nonce1, nonce1 + 32, PKE + 67);
+        copy(nonce2, nonce2 + 32, PKE + 35);
+        copy(nonce1, nonce1 + 32, PKE + 67);
     }
-    for(int i(0); i < 4; ++i) {
+    for (int i(0); i < 4; ++i) {
         PKE[99] = i;
-        HMAC(EVP_sha1(), &pmk[0], pmk.size(), PKE, 100, &ptk[0] + i * 20, 0);
+        HMAC(EVP_sha1(), &pmk[0], pmk.size(), PKE, 100, &ptk_[0] + i * 20, 0);
+    }
+    RSNEAPOL& last_hs = const_cast<RSNEAPOL&>(hs.handshake()[3]);
+    PDU::serialization_type buffer = last_hs.serialize();
+    fill(buffer.begin() + 81, buffer.begin() + 81 + 16, 0);
+    if (is_ccmp_) {
+        HMAC(EVP_sha1(), &ptk_[0], 16, &buffer[0], buffer.size(), MIC, 0);
+    }
+    else {
+        HMAC(EVP_md5(), &ptk_[0], 16, &buffer[0], buffer.size(), MIC, 0);
     }
-    PDU::serialization_type buffer = const_cast<RSNEAPOL&>(hs.handshake()[3]).serialize();
-    std::fill(buffer.begin() + 81, buffer.begin() + 81 + 16, 0);
-    if(is_ccmp)
-        HMAC(EVP_sha1(), &ptk[0], 16, &buffer[0], buffer.size(), MIC, 0);
-    else
-        HMAC(EVP_md5(), &ptk[0], 16, &buffer[0], buffer.size(), MIC, 0);
     
-    if(!std::equal(MIC, MIC + RSNEAPOL::mic_size, hs.handshake()[3].mic()))
+    if (!equal(MIC, MIC + RSNEAPOL::mic_size, last_hs.mic())) {
         throw invalid_handshake();
+    }
 }
 
-SNAP *SessionKeys::ccmp_decrypt_unicast(const Dot11Data &dot11, RawPDU &raw) const {
-    RawPDU::payload_type &pload = raw.payload();
+SNAP* SessionKeys::ccmp_decrypt_unicast(const Dot11Data& dot11, RawPDU& raw) const {
+    RawPDU::payload_type& pload = raw.payload();
     uint8_t MIC[16] = {0};
     uint8_t PN[6] = {
         pload[7],
@@ -301,8 +325,9 @@ SNAP *SessionKeys::ccmp_decrypt_unicast(const Dot11Data &dot11, RawPDU &raw) con
     uint8_t AAD[32] = {0};
     AAD[0] = 0;
     AAD[1] = 22 + 6 * int(dot11.from_ds() && dot11.to_ds());
-    if(dot11.subtype() == Dot11::QOS_DATA_DATA) 
+    if (dot11.subtype() == Dot11::QOS_DATA_DATA)  {
         AAD[1] += 2;
+    }
     AAD[2] = dot11.protocol() | (dot11.type() << 2) | ((dot11.subtype() << 4) & 0x80);
     AAD[3] = 0x40 | dot11.to_ds() | (dot11.from_ds() << 1) |
             (dot11.more_frag() << 2) | (dot11.order() << 7);
@@ -313,11 +338,12 @@ SNAP *SessionKeys::ccmp_decrypt_unicast(const Dot11Data &dot11, RawPDU &raw) con
     AAD[22] = dot11.frag_num();
     AAD[23] = 0;
     
-    if(dot11.from_ds() && dot11.to_ds())
+    if (dot11.from_ds() && dot11.to_ds()) {
         dot11.addr4().copy(AAD + 24);
+    }
     
     AES_KEY ctx;
-    AES_set_encrypt_key(&ptk[0] + 32, 128, &ctx);
+    AES_set_encrypt_key(&ptk_[0] + 32, 128, &ctx);
     uint8_t crypted_block[16];
     size_t total_sz = raw.payload_size() - 16, offset = 8, blocks = (total_sz + 15) / 16;
     
@@ -325,7 +351,7 @@ SNAP *SessionKeys::ccmp_decrypt_unicast(const Dot11Data &dot11, RawPDU &raw) con
     counter[0] = 0x59;
     counter[1] = 0;
     dot11.addr2().copy(counter + 2);
-    std::copy(PN, PN + 6, counter + 8);
+    copy(PN, PN + 6, counter + 8);
     counter[14] = (total_sz >> 8) & 0xff;
     counter[15] = total_sz & 0xff;
     
@@ -339,12 +365,13 @@ SNAP *SessionKeys::ccmp_decrypt_unicast(const Dot11Data &dot11, RawPDU &raw) con
     counter[14] = counter[15] = 0;
     AES_encrypt(counter, crypted_block, &ctx);
     uint8_t nice_MIC[8];
-    std::copy(pload.begin() + pload.size() - 8, pload.end(), nice_MIC);
+    copy(pload.begin() + pload.size() - 8, pload.end(), nice_MIC);
     xor_range(crypted_block, nice_MIC, nice_MIC, 8);
-    for(size_t i = 1; i <= blocks; ++i) {
+    for (size_t i = 1; i <= blocks; ++i) {
         size_t block_sz = (i == blocks) ? (total_sz % 16) : 16;
-        if(block_sz == 0)
+        if (block_sz == 0) {
             block_sz = 16;
+        }
         counter[14] = (i >> 8) & 0xff;
         counter[15] = i & 0xff;
         AES_encrypt(counter, crypted_block, &ctx );
@@ -355,14 +382,17 @@ SNAP *SessionKeys::ccmp_decrypt_unicast(const Dot11Data &dot11, RawPDU &raw) con
         AES_encrypt(MIC, MIC, &ctx);   
         offset += block_sz;
     }
-    return (std::equal(nice_MIC, nice_MIC + sizeof(nice_MIC), MIC)) ? 
-        new SNAP(&pload[0], total_sz) : 
-        0;
+    if (equal(nice_MIC, nice_MIC + sizeof(nice_MIC), MIC)) {
+        return new SNAP(&pload[0], total_sz);
+    }
+    else {
+        return 0;
+    }
 }
 
-RC4Key SessionKeys::generate_rc4_key(const Dot11Data &dot11, const RawPDU &raw) const {
-    const RawPDU::payload_type &pload = raw.payload();
-    const uint8_t *tk = &ptk[0] + 32;
+RC4Key SessionKeys::generate_rc4_key(const Dot11Data& dot11, const RawPDU& raw) const {
+    const RawPDU::payload_type& pload = raw.payload();
+    const uint8_t* tk = &ptk_[0] + 32;
     Internals::byte_array<16> rc4_key;
     uint16_t ppk[6];
     const Dot11::address_type addr = dot11.addr2();
@@ -373,7 +403,7 @@ RC4Key SessionKeys::generate_rc4_key(const Dot11Data &dot11, const RawPDU &raw)
     ppk[3] = join_bytes(addr[3], addr[2]);
     ppk[4] = join_bytes(addr[5], addr[4]);
     
-    for(size_t i = 0; i < 4; ++i) {
+    for (size_t i = 0; i < 4; ++i) {
         ppk[0] += sbox(ppk[4] ^ join_bytes(tk[1], tk[0]));
         ppk[1] += sbox(ppk[0] ^ join_bytes(tk[5], tk[4]));
         ppk[2] += sbox(ppk[1] ^ join_bytes(tk[9], tk[8]));
@@ -424,41 +454,43 @@ RC4Key SessionKeys::generate_rc4_key(const Dot11Data &dot11, const RawPDU &raw)
     return RC4Key(rc4_key.begin(), rc4_key.end());
 }
 
-SNAP *SessionKeys::tkip_decrypt_unicast(const Dot11Data &dot11, RawPDU &raw) const {
+SNAP* SessionKeys::tkip_decrypt_unicast(const Dot11Data& dot11, RawPDU& raw) const {
     // at least 20 bytes for IV + crc + stuff
-    if(raw.payload_size() <= 20)
+    if (raw.payload_size() <= 20) {
         return 0;
+    }
     Crypto::RC4Key key = generate_rc4_key(dot11, raw);
-    RawPDU::payload_type &pload = raw.payload();
+    RawPDU::payload_type& pload = raw.payload();
     rc4(pload.begin() + 8, pload.end(), key, pload.begin());
 
     uint32_t crc = Utils::crc32(&pload[0], pload.size() - 12);
-    if(pload[pload.size() - 12] != (crc & 0xff) ||
+    if (pload[pload.size() - 12] != (crc & 0xff) ||
         pload[pload.size() - 11] != ((crc >> 8) & 0xff) ||
         pload[pload.size() - 10] != ((crc >> 16) & 0xff) ||
-        pload[pload.size() - 9] != ((crc >> 24) & 0xff))
+        pload[pload.size() - 9] != ((crc >> 24) & 0xff)) {
         return 0;
+    }
 
     return new SNAP(&pload[0], pload.size() - 20);
 }
 
-SNAP *SessionKeys::decrypt_unicast(const Dot11Data &dot11, RawPDU &raw) const {
-    return is_ccmp ? 
-        ccmp_decrypt_unicast(dot11, raw) :
-        tkip_decrypt_unicast(dot11, raw);
+SNAP* SessionKeys::decrypt_unicast(const Dot11Data& dot11, RawPDU& raw) const {
+    return is_ccmp_ ? 
+           ccmp_decrypt_unicast(dot11, raw) :
+           tkip_decrypt_unicast(dot11, raw);
 }
 
 const SessionKeys::ptk_type& SessionKeys::get_ptk() const {
-    return ptk;
+    return ptk_;
 }
 
 bool SessionKeys::uses_ccmp() const {
-    return is_ccmp;
+    return is_ccmp_;
 }
 
 // supplicant_data
 
-SupplicantData::SupplicantData(const std::string &psk, const std::string &ssid)
+SupplicantData::SupplicantData(const string& psk, const string& ssid)
 : pmk_(SessionKeys::PMK_SIZE) {
     PKCS5_PBKDF2_HMAC_SHA1(
         psk.c_str(), 
@@ -471,106 +503,122 @@ SupplicantData::SupplicantData(const std::string &psk, const std::string &ssid)
     );
 }
 
-const SupplicantData::pmk_type &SupplicantData::pmk() const {
+const SupplicantData::pmk_type& SupplicantData::pmk() const {
     return pmk_;
 }
 } // namespace WPA2
 
-void WPA2Decrypter::add_ap_data(const std::string &psk, const std::string &ssid) {
-    pmks.insert(std::make_pair(ssid, WPA2::SupplicantData(psk, ssid)));
+void WPA2Decrypter::add_ap_data(const string& psk, const string& ssid) {
+    pmks_.insert(make_pair(ssid, WPA2::SupplicantData(psk, ssid)));
 }
 
-void WPA2Decrypter::add_ap_data(const std::string &psk, const std::string &ssid,
-  const address_type &addr) 
-{
+void WPA2Decrypter::add_ap_data(const string& psk, 
+                                const string& ssid,
+                                const address_type& addr) {
     add_ap_data(psk, ssid);
     add_access_point(ssid, addr);
 }
 
-void WPA2Decrypter::add_access_point(const std::string &ssid, const address_type &addr) {
-    pmks_map::const_iterator it = pmks.find(ssid);
-    if(it == pmks.end()) 
-        throw std::runtime_error("supplicant data not registered");
-    aps.insert(std::make_pair(addr, it->second));
+void WPA2Decrypter::add_access_point(const string& ssid, const address_type& addr) {
+    pmks_map::const_iterator it = pmks_.find(ssid);
+    if (it == pmks_.end()) {
+        throw runtime_error("Supplicant data not registered");
+    }
+    aps_.insert(make_pair(addr, it->second));
 }
 
-void WPA2Decrypter::add_decryption_keys(const addr_pair& addresses, const SessionKeys& session_keys) {
+void WPA2Decrypter::add_decryption_keys(const addr_pair& addresses, 
+                                        const SessionKeys& session_keys) {
     addr_pair sorted_pair = make_addr_pair(addresses.first, addresses.second);
-    keys[sorted_pair] = session_keys;
+    keys_[sorted_pair] = session_keys;
 }
 
-void WPA2Decrypter::try_add_keys(const Dot11Data &dot11, const RSNHandshake &hs) {
+void WPA2Decrypter::try_add_keys(const Dot11Data& dot11, const RSNHandshake& hs) {
     bssids_map::const_iterator it = find_ap(dot11);
-    if(it != aps.end()) {
+    if (it != aps_.end()) {
         addr_pair addr_p = extract_addr_pair(dot11);
         try {
             SessionKeys session(hs, it->second.pmk());
-            keys[addr_p] = session;
+            keys_[addr_p] = session;
+        }
+        catch(WPA2::invalid_handshake&) {
+
         }
-        catch(WPA2::invalid_handshake&) { }
     }
 }
 
 const WPA2Decrypter::keys_map& WPA2Decrypter::get_keys() const {
-    return keys;
+    return keys_;
 }
 
-WPA2Decrypter::addr_pair WPA2Decrypter::extract_addr_pair(const Dot11Data &dot11) {
-    if(dot11.from_ds() && !dot11.to_ds())
+WPA2Decrypter::addr_pair WPA2Decrypter::extract_addr_pair(const Dot11Data& dot11) {
+    if (dot11.from_ds() && !dot11.to_ds()) {
         return make_addr_pair(dot11.addr2(), dot11.addr3());
-    else if(!dot11.from_ds() && dot11.to_ds())
-        return make_addr_pair(dot11.addr1(), dot11.addr2());
-    else 
-        return make_addr_pair(dot11.addr2(), dot11.addr3());
-}
-
-WPA2Decrypter::addr_pair WPA2Decrypter::extract_addr_pair_dst(const Dot11Data &dot11) {
-    if(dot11.from_ds() && !dot11.to_ds())
-        return make_addr_pair(dot11.addr1(), dot11.addr2());
-    else if(!dot11.from_ds() && dot11.to_ds())
-        return make_addr_pair(dot11.addr1(), dot11.addr3());
-    else 
-        return make_addr_pair(dot11.addr1(), dot11.addr3());
-}
-
-WPA2Decrypter::bssids_map::const_iterator WPA2Decrypter::find_ap(const Dot11Data &dot11) {
-    if(dot11.from_ds() && !dot11.to_ds())
-        return aps.find(dot11.addr2());
-    else if(!dot11.from_ds() && dot11.to_ds())
-        return aps.find(dot11.addr1());
-    else 
-        return aps.find(dot11.addr3());
-}
-
-bool WPA2Decrypter::decrypt(PDU &pdu) {
-    if(capturer.process_packet(pdu)) {
-        try_add_keys(pdu.rfind_pdu<Dot11Data>(), capturer.handshakes().front());
-        capturer.clear_handshakes();
     }
-    else if(const Dot11Beacon *beacon = pdu.find_pdu<Dot11Beacon>()) {
-        if(aps.count(beacon->addr3()) == 0) {
+    else if (!dot11.from_ds() && dot11.to_ds()) {
+        return make_addr_pair(dot11.addr1(), dot11.addr2());
+    }
+    else {
+        return make_addr_pair(dot11.addr2(), dot11.addr3());
+    }
+}
+
+WPA2Decrypter::addr_pair WPA2Decrypter::extract_addr_pair_dst(const Dot11Data& dot11) {
+    if (dot11.from_ds() && !dot11.to_ds()) {
+        return make_addr_pair(dot11.addr1(), dot11.addr2());
+    }
+    else if (!dot11.from_ds() && dot11.to_ds()) {
+        return make_addr_pair(dot11.addr1(), dot11.addr3());
+    }
+    else {
+        return make_addr_pair(dot11.addr1(), dot11.addr3());
+    }
+}
+
+WPA2Decrypter::bssids_map::const_iterator WPA2Decrypter::find_ap(const Dot11Data& dot11) {
+    if (dot11.from_ds() && !dot11.to_ds()) {
+        return aps_.find(dot11.addr2());
+    }
+    else if (!dot11.from_ds() && dot11.to_ds()) {
+        return aps_.find(dot11.addr1());
+    }
+    else {
+        return aps_.find(dot11.addr3());
+    }
+}
+
+bool WPA2Decrypter::decrypt(PDU& pdu) {
+    if (capturer_.process_packet(pdu)) {
+        try_add_keys(pdu.rfind_pdu<Dot11Data>(), capturer_.handshakes().front());
+        capturer_.clear_handshakes();
+    }
+    else if (const Dot11Beacon* beacon = pdu.find_pdu<Dot11Beacon>()) {
+        if (aps_.count(beacon->addr3()) == 0) {
             try {
-                std::string ssid = beacon->ssid();
-                if(pmks.count(ssid)) {
+                string ssid = beacon->ssid();
+                if (pmks_.count(ssid)) {
                     add_access_point(ssid, beacon->addr3());
                 }
             }
-            catch(option_not_found&) { }
+            catch(option_not_found&) {
+
+            }
         }
     }
     else {
-        Dot11Data *data = pdu.find_pdu<Dot11Data>();
-        RawPDU *raw = pdu.find_pdu<RawPDU>();
-        if(data && raw && data->wep()) {
+        Dot11Data* data = pdu.find_pdu<Dot11Data>();
+        RawPDU* raw = pdu.find_pdu<RawPDU>();
+        if (data && raw && data->wep()) {
             // search for the tuple (bssid, src_addr)
-            keys_map::const_iterator it = keys.find(extract_addr_pair(*data));
+            keys_map::const_iterator it = keys_.find(extract_addr_pair(*data));
             
             // search for the tuple (bssid, dst_addr) if the above didn't work
-            if(it == keys.end())
-                it = keys.find(extract_addr_pair_dst(*data));
-            if(it != keys.end()) {
-                SNAP *snap = it->second.decrypt_unicast(*data, *raw);
-                if(snap) {
+            if (it == keys_.end()) {
+                it = keys_.find(extract_addr_pair_dst(*data));
+            }
+            if (it != keys_.end()) {
+                SNAP* snap = it->second.decrypt_unicast(*data, *raw);
+                if (snap) {
                     data->inner_pdu(snap);
                     data->wep(0);
                     return true;
@@ -579,8 +627,10 @@ bool WPA2Decrypter::decrypt(PDU &pdu) {
         }
     }
     return false;
-} // namespace WPA2
+}
+
 #endif // HAVE_WPA2_DECRYPTION
+
 } // namespace Crypto
 } // namespace Tins
 
diff --git a/src/dhcp.cpp b/src/dhcp.cpp
index 9377d31..ccc8358 100644
--- a/src/dhcp.cpp
+++ b/src/dhcp.cpp
@@ -37,6 +37,7 @@
 #include "memory_helpers.h"
 
 using std::string;
+using std::vector;
 using std::list;
 using std::runtime_error;
 using std::find_if;
@@ -48,20 +49,20 @@ namespace Tins {
 
 // Magic cookie: uint32_t. 
 DHCP::DHCP() 
-: _size(sizeof(uint32_t)) {
+: size_(sizeof(uint32_t)) {
     opcode(BOOTREQUEST);
     htype(1); //ethernet
     hlen(EthernetII::address_type::address_size);
 }
 
-DHCP::DHCP(const uint8_t *buffer, uint32_t total_sz) 
-: BootP(buffer, total_sz, 0), _size(sizeof(uint32_t))
-{
+DHCP::DHCP(const uint8_t* buffer, uint32_t total_sz) 
+: BootP(buffer, total_sz, 0), size_(sizeof(uint32_t)) {
     InputMemoryStream stream(buffer, total_sz);
     stream.skip(BootP::header_size() - vend().size());
     const uint32_t magic_number = stream.read<uint32_t>();
-    if (magic_number != Endian::host_to_be<uint32_t>(0x63825363))
+    if (magic_number != Endian::host_to_be<uint32_t>(0x63825363)) {
         throw malformed_packet();
+    }
     // While there's data left
     while (stream) {
         OptionTypes option_type;
@@ -80,39 +81,39 @@ DHCP::DHCP(const uint8_t *buffer, uint32_t total_sz)
     }
 }
 
-void DHCP::add_option(const option &opt) {
+void DHCP::add_option(const option& opt) {
     internal_add_option(opt);
-    _options.push_back(opt);
+    options_.push_back(opt);
 }
 
-void DHCP::internal_add_option(const option &opt) {
-    _size += static_cast<uint32_t>(opt.data_size() + (sizeof(uint8_t) << 1));
+void DHCP::internal_add_option(const option& opt) {
+    size_ += static_cast<uint32_t>(opt.data_size() + (sizeof(uint8_t) << 1));
 }
 
 bool DHCP::remove_option(OptionTypes type) {
     options_type::iterator iter = search_option_iterator(type);
-    if (iter == _options.end()) {
+    if (iter == options_.end()) {
         return false;
     }
-    _size -= static_cast<uint32_t>(iter->data_size() + (sizeof(uint8_t) << 1));
-    _options.erase(iter);
+    size_ -= static_cast<uint32_t>(iter->data_size() + (sizeof(uint8_t) << 1));
+    options_.erase(iter);
     return true;
 }
 
-const DHCP::option *DHCP::search_option(OptionTypes opt) const {
+const DHCP::option* DHCP::search_option(OptionTypes opt) const {
     // Search for the iterator. If we found something, return it, otherwise return nullptr.
     options_type::const_iterator iter = search_option_iterator(opt);
-    return (iter != _options.end()) ? &*iter : 0;
+    return (iter != options_.end()) ? &*iter : 0;
 }
 
 DHCP::options_type::const_iterator DHCP::search_option_iterator(OptionTypes opt) const {
     Internals::option_type_equality_comparator<option> comparator(opt);
-    return find_if(_options.begin(), _options.end(), comparator);
+    return find_if(options_.begin(), options_.end(), comparator);
 }
 
 DHCP::options_type::iterator DHCP::search_option_iterator(OptionTypes opt) {
     Internals::option_type_equality_comparator<option> comparator(opt);
-    return find_if(_options.begin(), _options.end(), comparator);
+    return find_if(options_.begin(), options_.end(), comparator);
 }
 
 void DHCP::type(Flags type) {
@@ -164,22 +165,22 @@ DHCP::ipaddress_type DHCP::subnet_mask() const {
     return search_and_convert<ipaddress_type>(SUBNET_MASK);
 }
 
-void DHCP::routers(const std::vector<ipaddress_type> &routers) {
+void DHCP::routers(const vector<ipaddress_type>& routers) {
     serialization_type buffer = serialize_list(routers);
     add_option(option(ROUTERS, buffer.begin(), buffer.end()));
 }
 
-std::vector<DHCP::ipaddress_type> DHCP::routers() const {
-    return search_and_convert<std::vector<DHCP::ipaddress_type> >(ROUTERS);
+vector<DHCP::ipaddress_type> DHCP::routers() const {
+    return search_and_convert<vector<DHCP::ipaddress_type> >(ROUTERS);
 }
 
-void DHCP::domain_name_servers(const std::vector<ipaddress_type> &dns) {
+void DHCP::domain_name_servers(const vector<ipaddress_type>& dns) {
     serialization_type buffer = serialize_list(dns);
     add_option(option(DOMAIN_NAME_SERVERS, buffer.begin(), buffer.end()));
 }
 
-std::vector<DHCP::ipaddress_type> DHCP::domain_name_servers() const {
-    return search_and_convert<std::vector<DHCP::ipaddress_type> >(DOMAIN_NAME_SERVERS);
+vector<DHCP::ipaddress_type> DHCP::domain_name_servers() const {
+    return search_and_convert<vector<DHCP::ipaddress_type> >(DOMAIN_NAME_SERVERS);
 }
 
 void DHCP::broadcast(ipaddress_type addr) {
@@ -200,20 +201,20 @@ DHCP::ipaddress_type DHCP::requested_ip() const {
     return search_and_convert<ipaddress_type>(DHCP_REQUESTED_ADDRESS);
 }
 
-void DHCP::domain_name(const string &name) {
+void DHCP::domain_name(const string& name) {
     add_option(option(DOMAIN_NAME, name.size(), (const uint8_t*)name.c_str()));
 }
 
-std::string DHCP::domain_name() const {
-    return search_and_convert<std::string>(DOMAIN_NAME);
+string DHCP::domain_name() const {
+    return search_and_convert<string>(DOMAIN_NAME);
 }
 
-void DHCP::hostname(const std::string &name) {
+void DHCP::hostname(const string& name) {
     add_option(option(HOST_NAME, name.size(), (const uint8_t*)name.c_str()));
 }
 
-std::string DHCP::hostname() const {
-    return search_and_convert<std::string>(HOST_NAME);
+string DHCP::hostname() const {
+    return search_and_convert<string>(HOST_NAME);
 }
 
 void DHCP::rebind_time(uint32_t time) {
@@ -225,27 +226,29 @@ uint32_t DHCP::rebind_time() const {
     return search_and_convert<uint32_t>(DHCP_REBINDING_TIME);
 }
 
-PDU::serialization_type DHCP::serialize_list(const std::vector<ipaddress_type> &ip_list) {
+PDU::serialization_type DHCP::serialize_list(const vector<ipaddress_type>& ip_list) {
     serialization_type buffer(ip_list.size() * sizeof(uint32_t));
-    uint32_t *ptr = (uint32_t*)&buffer[0];
-    for(std::vector<ipaddress_type>::const_iterator it = ip_list.begin(); it != ip_list.end(); ++it)
+    uint32_t* ptr = (uint32_t*)&buffer[0];
+    typedef vector<ipaddress_type>::const_iterator iterator;
+    for (iterator it = ip_list.begin(); it != ip_list.end(); ++it) {
         *(ptr++) = *it;
+    }
     return buffer;
 }
 
 uint32_t DHCP::header_size() const {
-    return static_cast<uint32_t>(BootP::header_size() - vend().size() + _size);
+    return static_cast<uint32_t>(BootP::header_size() - vend().size() + size_);
 }
 
-void DHCP::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent) {
-    if (_size) {
-        vend_type &result = BootP::vend();
-        result.resize(_size);
+void DHCP::write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent) {
+    if (size_) {
+        vend_type& result = BootP::vend();
+        result.resize(size_);
         // Build a stream over the vend vector
         OutputMemoryStream stream(&result[0], result.size());
         // Magic cookie
         stream.write(Endian::host_to_be<uint32_t>(0x63825363));
-        for (options_type::const_iterator it = _options.begin(); it != _options.end(); ++it) {
+        for (options_type::const_iterator it = options_.begin(); it != options_.end(); ++it) {
             stream.write(it->option());
             stream.write<uint8_t>(it->length_field());
             stream.write(it->data_ptr(), it->data_size());
@@ -253,4 +256,5 @@ void DHCP::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *pa
     }
     BootP::write_serialization(buffer, total_sz, parent);
 }
+
 } // Tins
diff --git a/src/dhcpv6.cpp b/src/dhcpv6.cpp
index af069e0..ec58c05 100644
--- a/src/dhcpv6.cpp
+++ b/src/dhcpv6.cpp
@@ -34,6 +34,11 @@
 #include "memory_helpers.h"
 
 using std::find_if;
+using std::copy;
+using std::vector;
+using std::runtime_error;
+using std::memcpy;
+using std::equal;
 
 using Tins::Memory::InputMemoryStream;
 using Tins::Memory::OutputMemoryStream;
@@ -41,13 +46,12 @@ using Tins::Memory::OutputMemoryStream;
 namespace Tins {
 
 DHCPv6::DHCPv6() 
-: header_data(), options_size() {
+: header_data_(), options_size_() {
 
 }
 
-DHCPv6::DHCPv6(const uint8_t *buffer, uint32_t total_sz) 
-: options_size() 
-{
+DHCPv6::DHCPv6(const uint8_t* buffer, uint32_t total_sz) 
+: options_size_() {
     InputMemoryStream stream(buffer, total_sz);
     if (!stream) {
         throw malformed_packet();
@@ -56,32 +60,25 @@ DHCPv6::DHCPv6(const uint8_t *buffer, uint32_t total_sz)
     const MessageType message_type = (MessageType)*stream.pointer();
     bool is_relay_msg = (message_type == RELAY_FORWARD || message_type == RELAY_REPLY);
     uint32_t required_size = is_relay_msg ? 2 : 4;
-    stream.read(&header_data, required_size);
+    stream.read(&header_data_, required_size);
     if (is_relay_message()) {
-        if (!stream.can_read(ipaddress_type::address_size * 2)) {
-            throw malformed_packet();
-        }
-        // Read both addresses
-        link_addr = stream.pointer();
-        peer_addr = stream.pointer() + ipaddress_type::address_size;
-        stream.skip(ipaddress_type::address_size * 2);
+        stream.read(link_addr_);
+        stream.read(peer_addr_);
     }
     while (stream) {
-        uint16_t opt = Endian::be_to_host(stream.read<uint16_t>());
-        uint16_t data_size = Endian::be_to_host(stream.read<uint16_t>());
-        if(!stream.can_read(data_size)) {
+        uint16_t opt = stream.read_be<uint16_t>();
+        uint16_t data_size = stream.read_be<uint16_t>();
+        if (!stream.can_read(data_size)) {
             throw malformed_packet();
         }
-        add_option(
-            option(opt, stream.pointer(), stream.pointer() + data_size)
-        );
+        add_option(option(opt, stream.pointer(), stream.pointer() + data_size));
         stream.skip(data_size);
     }
 }
     
-void DHCPv6::add_option(const option &opt) {
+void DHCPv6::add_option(const option& opt) {
     options_.push_back(opt);
-    options_size += opt.data_size() + sizeof(uint16_t) * 2;
+    options_size_ += opt.data_size() + sizeof(uint16_t) * 2;
 }
 
 bool DHCPv6::remove_option(OptionTypes type) {
@@ -89,12 +86,12 @@ bool DHCPv6::remove_option(OptionTypes type) {
     if (iter == options_.end()) {
         return false;
     }
-    options_size -= iter->data_size() + sizeof(uint16_t) * 2;
+    options_size_ -= iter->data_size() + sizeof(uint16_t) * 2;
     options_.erase(iter);
     return true;
 }
 
-const DHCPv6::option *DHCPv6::search_option(OptionTypes type) const {
+const DHCPv6::option* DHCPv6::search_option(OptionTypes type) const {
     // Search for the iterator. If we found something, return it, otherwise return nullptr.
     options_type::const_iterator iter = search_option_iterator(type);
     return (iter != options_.end()) ? &*iter : 0;
@@ -110,33 +107,33 @@ DHCPv6::options_type::iterator DHCPv6::search_option_iterator(OptionTypes type)
     return find_if(options_.begin(), options_.end(), comparator);
 }
 
-void DHCPv6::write_option(const option &opt, OutputMemoryStream& stream) const {
-    stream.write(Endian::host_to_be<uint16_t>(opt.option()));
-    stream.write(Endian::host_to_be<uint16_t>(opt.length_field()));
+void DHCPv6::write_option(const option& opt, OutputMemoryStream& stream) const {
+    stream.write_be<uint16_t>(opt.option());
+    stream.write_be<uint16_t>(opt.length_field());
     stream.write(opt.data_ptr(), opt.data_size());
 }
     
 void DHCPv6::msg_type(MessageType type) {
-    header_data[0] = static_cast<uint8_t>(type);
+    header_data_[0] = static_cast<uint8_t>(type);
 }
 
 void DHCPv6::hop_count(uint8_t count) {
-    header_data[1] = count;
+    header_data_[1] = count;
 }
 
 void DHCPv6::transaction_id(small_uint<24> id) {
     uint32_t id_32 = id;
-    header_data[1] = id_32 >> 16;
-    header_data[2] = id_32 >> 8;
-    header_data[3] = id_32 & 0xff;
+    header_data_[1] = id_32 >> 16;
+    header_data_[2] = id_32 >> 8;
+    header_data_[3] = id_32 & 0xff;
 }
 
-void DHCPv6::peer_address(const ipaddress_type &addr) {
-    peer_addr = addr;
+void DHCPv6::peer_address(const ipaddress_type& addr) {
+    peer_addr_ = addr;
 }
 
-void DHCPv6::link_address(const ipaddress_type &addr) {
-    link_addr = addr;
+void DHCPv6::link_address(const ipaddress_type& addr) {
+    link_addr_ = addr;
 }
 
 bool DHCPv6::is_relay_message() const {
@@ -144,25 +141,26 @@ bool DHCPv6::is_relay_message() const {
 }
 
 uint32_t DHCPv6::header_size() const {
-    return (is_relay_message() ? (2 + ipaddress_type::address_size * 2) : 4) + options_size;
+    return (is_relay_message() ? (2 + ipaddress_type::address_size * 2) : 4) + options_size_;
 }
 
-bool DHCPv6::matches_response(const uint8_t *ptr, uint32_t total_sz) const {
-    if(!is_relay_message()) {
-        if(total_sz < 4 || (ptr[0] == 12 || ptr[0] == 13))
+bool DHCPv6::matches_response(const uint8_t* ptr, uint32_t total_sz) const {
+    if (!is_relay_message()) {
+        if (total_sz < 4 || (ptr[0] == 12 || ptr[0] == 13)) {
             return false;
-        return std::equal(header_data + 1, header_data + 4, ptr + 1);
+        }
+        return equal(header_data_ + 1, header_data_ + 4, ptr + 1);
     }
     return false;
 }
 
-void DHCPv6::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *) {
+void DHCPv6::write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU *) {
     const uint32_t required_size = is_relay_message() ? 2 : 4;
     OutputMemoryStream stream(buffer, total_sz);
-    stream.write(header_data, required_size);
+    stream.write(header_data_, required_size);
     if (is_relay_message()) {
-        stream.write(link_addr);
-        stream.write(peer_addr);
+        stream.write(link_addr_);
+        stream.write(peer_addr_);
     }
     for (options_type::const_iterator it = options_.begin(); it != options_.end(); ++it) {
         write_option(*it, stream);
@@ -254,147 +252,99 @@ DHCPv6::duid_type DHCPv6::server_id() const {
 //                          Option setters
 // ********************************************************************
 
-void DHCPv6::ia_na(const ia_na_type &value) {
-    std::vector<uint8_t> buffer(sizeof(uint32_t) * 3 + value.options.size());
-    uint32_t *ptr = (uint32_t*)&buffer[0];
-    *ptr++ = Endian::host_to_be(value.id);
-    *ptr++ = Endian::host_to_be(value.t1);
-    *ptr++ = Endian::host_to_be(value.t2);
-    std::copy(
-        value.options.begin(), 
-        value.options.end(), 
-        buffer.begin() + sizeof(uint32_t) * 3
-    );
-    add_option(
-        option(IA_NA, buffer.begin(), buffer.end())
-    );
+void DHCPv6::ia_na(const ia_na_type& value) {
+    vector<uint8_t> buffer(sizeof(uint32_t) * 3 + value.options.size());
+    OutputMemoryStream stream(buffer);
+    stream.write_be(value.id);
+    stream.write_be(value.t1);
+    stream.write_be(value.t2);
+    stream.write(value.options.begin(), value.options.end());
+    add_option(option(IA_NA, buffer.begin(), buffer.end()));
 }
 
-void DHCPv6::ia_ta(const ia_ta_type &value) {
-    std::vector<uint8_t> buffer(sizeof(uint32_t) + value.options.size());
-    uint32_t *ptr = (uint32_t*)&buffer[0];
-    *ptr++ = Endian::host_to_be(value.id);
-    std::copy(
-        value.options.begin(), 
-        value.options.end(), 
-        buffer.begin() + sizeof(uint32_t)
-    );
-    add_option(
-        option(IA_TA, buffer.begin(), buffer.end())
-    );
+void DHCPv6::ia_ta(const ia_ta_type& value) {
+    vector<uint8_t> buffer(sizeof(uint32_t) + value.options.size());
+    OutputMemoryStream stream(buffer);
+    stream.write_be(value.id);
+    stream.write(value.options.begin(), value.options.end());
+    add_option(option(IA_TA, buffer.begin(), buffer.end()));
 }
 
-void DHCPv6::ia_address(const ia_address_type &value) {
-    std::vector<uint8_t> buffer(
+void DHCPv6::ia_address(const ia_address_type& value) {
+    vector<uint8_t> buffer(
         sizeof(uint32_t) * 2 + ipaddress_type::address_size + value.options.size()
     );
-    uint32_t *ptr = (uint32_t*)&buffer[ipaddress_type::address_size];
-    value.address.copy(&buffer[0]);
-    *ptr++ = Endian::host_to_be(value.preferred_lifetime);
-    *ptr++ = Endian::host_to_be(value.valid_lifetime);
-    std::copy(
-        value.options.begin(), 
-        value.options.end(), 
-        buffer.begin() + sizeof(uint32_t) * 2 + ipaddress_type::address_size
-    );
-    add_option(
-        option(IA_ADDR, buffer.begin(), buffer.end())
-    );
+    OutputMemoryStream stream(buffer);
+    stream.write(value.address);
+    stream.write_be(value.preferred_lifetime);
+    stream.write_be(value.valid_lifetime);
+    stream.write(value.options.begin(), value.options.end());
+    add_option(option(IA_ADDR, buffer.begin(), buffer.end()));
 }
 
-void DHCPv6::option_request(const option_request_type &value) {
+void DHCPv6::option_request(const option_request_type& value) {
     typedef option_request_type::const_iterator iterator;
     
-    std::vector<uint8_t> buffer(value.size() * sizeof(uint16_t));
-    size_t index = 0;
-    uint16_t uint16_t_buffer;
-    for(iterator it = value.begin(); it != value.end(); ++it, index += 2) {
-        uint16_t_buffer = Endian::host_to_be<uint16_t>(*it);
-        std::memcpy(&buffer[index], &uint16_t_buffer, sizeof(uint16_t));
+    vector<uint8_t> buffer(value.size() * sizeof(uint16_t));
+    OutputMemoryStream stream(buffer);
+    for (iterator it = value.begin(); it != value.end(); ++it) {
+        stream.write_be(*it);
     }
-    add_option(
-        option(OPTION_REQUEST, buffer.begin(), buffer.end())
-    );
+    add_option(option(OPTION_REQUEST, buffer.begin(), buffer.end()));
 }
 
 void DHCPv6::preference(uint8_t value) {
-    add_option(
-        option(PREFERENCE, 1, &value)
-    );
+    add_option(option(PREFERENCE, 1, &value));
 }
 
 void DHCPv6::elapsed_time(uint16_t value) {
     value = Endian::host_to_be(value);
-    add_option(
-        option(ELAPSED_TIME, 2, (const uint8_t*)&value)
-    );
+    add_option(option(ELAPSED_TIME, 2, (const uint8_t*)&value));
 }
 
-void DHCPv6::relay_message(const relay_msg_type &value) {
-    add_option(
-        option(RELAY_MSG, value.begin(), value.end())
-    );
+void DHCPv6::relay_message(const relay_msg_type& value) {
+    add_option(option(RELAY_MSG, value.begin(), value.end()));
 }
 
-void DHCPv6::authentication(const authentication_type &value) {
-    std::vector<uint8_t> buffer(
+void DHCPv6::authentication(const authentication_type& value) {
+    vector<uint8_t> buffer(
         sizeof(uint8_t) * 3 + sizeof(uint64_t) + value.auth_info.size()
     );
-    buffer[0] = value.protocol;
-    buffer[1] = value.algorithm;
-    buffer[2] = value.rdm;
-    uint64_t uint64_t_buffer = Endian::host_to_be(value.replay_detection);
-    std::memcpy(&buffer[3], &uint64_t_buffer, sizeof(uint64_t));
-    std::copy(
-        value.auth_info.begin(), 
-        value.auth_info.end(),
-        buffer.begin() + sizeof(uint8_t) * 3 + sizeof(uint64_t)
-    );
-    add_option(
-        option(AUTH, buffer.begin(), buffer.end())
-    );
+    OutputMemoryStream stream(buffer);
+    stream.write(value.protocol);
+    stream.write(value.algorithm);
+    stream.write(value.rdm);
+    stream.write_be(value.replay_detection);
+    stream.write(value.auth_info.begin(), value.auth_info.end());
+    add_option(option(AUTH, buffer.begin(), buffer.end()));
 }
 
-void DHCPv6::server_unicast(const ipaddress_type &value) {
-    add_option(
-        option(UNICAST, value.begin(), value.end())
-    );
+void DHCPv6::server_unicast(const ipaddress_type& value) {
+    add_option(option(UNICAST, value.begin(), value.end()));
 }
 
-void DHCPv6::status_code(const status_code_type &value) {
-    std::vector<uint8_t> buffer(sizeof(uint16_t) + value.message.size());
-    uint16_t uint16_t_buffer = Endian::host_to_be(value.code);
-    std::memcpy(&buffer[0], &uint16_t_buffer, sizeof(uint16_t));
-    std::copy(
-        value.message.begin(), 
-        value.message.end(), 
-        buffer.begin() + sizeof(uint16_t)
-    );
-    add_option(
-        option(STATUS_CODE, buffer.begin(), buffer.end())
-    );
+void DHCPv6::status_code(const status_code_type& value) {
+    vector<uint8_t> buffer(sizeof(uint16_t) + value.message.size());
+    OutputMemoryStream stream(buffer);
+    stream.write_be(value.code);
+    stream.write(value.message.begin(), value.message.end());
+    add_option(option(STATUS_CODE, buffer.begin(), buffer.end()));
 }
 
 void DHCPv6::rapid_commit() {
-    add_option(
-        RAPID_COMMIT
-    );
+    add_option(RAPID_COMMIT);
 }
 
-void DHCPv6::user_class(const user_class_type &value) {
-    std::vector<uint8_t> buffer;
+void DHCPv6::user_class(const user_class_type& value) {
+    vector<uint8_t> buffer;
     Internals::class_option_data2option(value.data.begin(), value.data.end(), buffer);
-    add_option(
-        option(USER_CLASS, buffer.begin(), buffer.end())
-    );
+    add_option(option(USER_CLASS, buffer.begin(), buffer.end()));
 }
 
-void DHCPv6::vendor_class(const vendor_class_type &value) {
-    std::vector<uint8_t> buffer(
-        sizeof(uint32_t)
-    );
-    uint32_t enterprise_number = Endian::host_to_be(value.enterprise_number);
-    std::memcpy(&buffer[0], &enterprise_number, sizeof(uint32_t));
+void DHCPv6::vendor_class(const vendor_class_type& value) {
+    vector<uint8_t> buffer(sizeof(uint32_t));
+    OutputMemoryStream stream(buffer);
+    stream.write_be(value.enterprise_number);
     Internals::class_option_data2option(
         value.vendor_class_data.begin(),
         value.vendor_class_data.end(),
@@ -406,276 +356,218 @@ void DHCPv6::vendor_class(const vendor_class_type &value) {
     );
 }
 
-void DHCPv6::vendor_info(const vendor_info_type &value) {
-    std::vector<uint8_t> buffer(sizeof(uint32_t) + value.data.size());
-    uint32_t enterprise_number = Endian::host_to_be(value.enterprise_number);
-    std::memcpy(&buffer[0], &enterprise_number, sizeof(uint32_t));
-    std::copy(
-        value.data.begin(),
-        value.data.end(),
-        buffer.begin() + sizeof(uint32_t)
-    );
-    add_option(
-        option(VENDOR_OPTS, buffer.begin(), buffer.end())
-    );
+void DHCPv6::vendor_info(const vendor_info_type& value) {
+    vector<uint8_t> buffer(sizeof(uint32_t) + value.data.size());
+    OutputMemoryStream stream(buffer);
+    stream.write_be(value.enterprise_number);
+    stream.write(value.data.begin(), value.data.end());
+    add_option(option(VENDOR_OPTS, buffer.begin(), buffer.end()));
 }
 
-void DHCPv6::interface_id(const interface_id_type &value) {
-    add_option(
-        option(INTERFACE_ID, value.begin(), value.end())
-    );
+void DHCPv6::interface_id(const interface_id_type& value) {
+    add_option(option(INTERFACE_ID, value.begin(), value.end()));
 }
 
 void DHCPv6::reconfigure_msg(uint8_t value) {
-    add_option(
-        option(RECONF_MSG, 1, &value)
-    );
+    add_option(option(RECONF_MSG, 1, &value));
 }
 
 void DHCPv6::reconfigure_accept() {
     add_option(RECONF_ACCEPT);
 }
 
+void DHCPv6::client_id(const duid_type& value) {
+    serialization_type buffer(sizeof(uint16_t) + value.data.size());
+    OutputMemoryStream stream(buffer);
+    stream.write_be(value.id);
+    stream.write(value.data.begin(), value.data.end());
+    add_option(option(CLIENTID, buffer.begin(), buffer.end()));
+}
+
+void DHCPv6::server_id(const duid_type& value) {
+    serialization_type buffer(sizeof(uint16_t) + value.data.size());
+    OutputMemoryStream stream(buffer);
+    stream.write_be(value.id);
+    stream.write(value.data.begin(), value.data.end());
+    add_option(option(SERVERID, buffer.begin(), buffer.end()));
+}
 
 // DUIDs
 
-DHCPv6::duid_llt DHCPv6::duid_llt::from_bytes(const uint8_t *buffer, uint32_t total_sz) 
-{
+DHCPv6::duid_llt DHCPv6::duid_llt::from_bytes(const uint8_t* buffer, uint32_t total_sz) {
     // at least one byte for lladdress
-    if(total_sz < sizeof(uint16_t) + sizeof(uint32_t) + 1)
-        throw std::runtime_error("Not enough size for a DUID_LLT identifier");
+    if (total_sz < sizeof(uint16_t) + sizeof(uint32_t) + 1) {
+        throw runtime_error("Not enough size for a DUID_LLT identifier");
+    }
+    InputMemoryStream stream(buffer, total_sz);
     duid_llt output;
-    std::memcpy(&output.hw_type, buffer, sizeof(uint16_t));
-    output.hw_type = Endian::be_to_host(output.hw_type);
-    buffer += sizeof(uint16_t);
-    std::memcpy(&output.time, buffer, sizeof(uint32_t));
-    output.time = Endian::be_to_host(output.time);
-    buffer += sizeof(uint32_t);
-    total_sz -= sizeof(uint16_t) + sizeof(uint32_t);
-    output.lladdress.assign(buffer, buffer + total_sz);
+    output.hw_type = stream.read_be<uint16_t>();
+    output.time = stream.read_be<uint32_t>();
+    stream.read(output.lladdress, stream.size());
     return output;
 }
 
 PDU::serialization_type DHCPv6::duid_llt::serialize() const {
     serialization_type output(sizeof(uint16_t) + sizeof(uint32_t) + lladdress.size());
-    uint16_t tmp_hw_type = Endian::host_to_be(hw_type);
-    uint32_t tmp_time = Endian::host_to_be(time);
-    std::memcpy(&output[0], &tmp_hw_type, sizeof(uint16_t));
-    std::memcpy(&output[sizeof(uint16_t)], &tmp_time, sizeof(uint32_t));
-    std::copy(
-        lladdress.begin(),
-        lladdress.end(),
-        output.begin() + sizeof(uint16_t) + sizeof(uint32_t)
-    );
+    OutputMemoryStream stream(output);
+    stream.write_be(hw_type);
+    stream.write_be(time);
+    stream.write(lladdress.begin(), lladdress.end());
     return output;
 }
 
-DHCPv6::duid_en DHCPv6::duid_en::from_bytes(const uint8_t *buffer, uint32_t total_sz) 
-{
+DHCPv6::duid_en DHCPv6::duid_en::from_bytes(const uint8_t* buffer, uint32_t total_sz) {
     // at least one byte for identifier
-    if(total_sz < sizeof(uint32_t) + 1)
-        throw std::runtime_error("Not enough size for a DUID_en identifier");
+    if (total_sz < sizeof(uint32_t) + 1) {
+        throw runtime_error("Not enough size for a DUID_en identifier");
+    }
+    InputMemoryStream stream(buffer, total_sz);
     duid_en output;
-    std::memcpy(&output.enterprise_number, buffer, sizeof(uint32_t));
-    output.enterprise_number = Endian::be_to_host(output.enterprise_number);
-    buffer += sizeof(uint32_t);
-    total_sz -= sizeof(uint32_t);
-    output.identifier.assign(buffer, buffer + total_sz);
+    output.enterprise_number = stream.read_be<uint32_t>();
+    stream.read(output.identifier, stream.size());
     return output;
 }
 
 PDU::serialization_type DHCPv6::duid_en::serialize() const {
     serialization_type output(sizeof(uint32_t) + identifier.size());
-    uint32_t tmp_enterprise_number = Endian::host_to_be(enterprise_number);
-    std::memcpy(&output[0], &tmp_enterprise_number, sizeof(uint32_t));
-    std::copy(
-        identifier.begin(),
-        identifier.end(),
-        output.begin() + sizeof(uint32_t)
-    );
+    OutputMemoryStream stream(output);
+    stream.write_be(enterprise_number);
+    stream.write(identifier.begin(), identifier.end());
     return output;
 }
 
-DHCPv6::duid_ll DHCPv6::duid_ll::from_bytes(const uint8_t *buffer, uint32_t total_sz) 
-{
+DHCPv6::duid_ll DHCPv6::duid_ll::from_bytes(const uint8_t* buffer, uint32_t total_sz) {
     // at least one byte for lladdress
-    if(total_sz < sizeof(uint16_t) + 1)
-        throw std::runtime_error("Not enough size for a DUID_en identifier");
+    if (total_sz < sizeof(uint16_t) + 1) { 
+        throw runtime_error("Not enough size for a DUID_en identifier");
+    }
+    InputMemoryStream stream(buffer, total_sz);
     duid_ll output;
-    std::memcpy(&output.hw_type, buffer, sizeof(uint16_t));
-    output.hw_type = Endian::be_to_host(output.hw_type);
-    buffer += sizeof(uint16_t);
-    total_sz -= sizeof(uint16_t);
-    output.lladdress.assign(buffer, buffer + total_sz);
+    output.hw_type = stream.read_be<uint16_t>();
+    stream.read(output.lladdress, stream.size());
     return output;
 }
 
 PDU::serialization_type DHCPv6::duid_ll::serialize() const {
     serialization_type output(sizeof(uint16_t) + lladdress.size());
-    uint16_t tmp_hw_type = Endian::host_to_be(hw_type);
-    std::memcpy(&output[0], &tmp_hw_type, sizeof(uint16_t));
-    std::copy(
-        lladdress.begin(),
-        lladdress.end(),
-        output.begin() + sizeof(uint16_t)
-    );
+    OutputMemoryStream stream(output);
+    stream.write_be(hw_type);
+    stream.write(lladdress.begin(), lladdress.end());
     return output;
 }
 
-void DHCPv6::client_id(const duid_type &value) {
-    serialization_type buffer(sizeof(uint16_t) + value.data.size());
-    uint16_t tmp_id = Endian::host_to_be(value.id);
-    std::memcpy(&buffer[0], &tmp_id, sizeof(uint16_t));
-    std::copy(
-        value.data.begin(),
-        value.data.end(),
-        buffer.begin() + sizeof(uint16_t)
-    );
-    add_option(
-        option(CLIENTID, buffer.begin(), buffer.end())
-    );
-}
-
-void DHCPv6::server_id(const duid_type &value) {
-    serialization_type buffer(sizeof(uint16_t) + value.data.size());
-    uint16_t tmp_id = Endian::host_to_be(value.id);
-    std::memcpy(&buffer[0], &tmp_id, sizeof(uint16_t));
-    std::copy(
-        value.data.begin(),
-        value.data.end(),
-        buffer.begin() + sizeof(uint16_t)
-    );
-    add_option(
-        option(SERVERID, buffer.begin(), buffer.end())
-    );
-}
-
 // Options
 
-DHCPv6::ia_na_type DHCPv6::ia_na_type::from_option(const option &opt)
-{
-    if(opt.data_size() < sizeof(uint32_t) * 3)
+DHCPv6::ia_na_type DHCPv6::ia_na_type::from_option(const option& opt) {
+    if (opt.data_size() < sizeof(uint32_t) * 3) {
         throw malformed_option();
-    const uint8_t *ptr = opt.data_ptr() + sizeof(uint32_t) * 3;
-    const uint32_t *ptr_32 = (const uint32_t*)opt.data_ptr();
+    }
+    InputMemoryStream stream(opt.data_ptr(), opt.data_size());
     DHCPv6::ia_na_type output;
-    output.id = Endian::be_to_host(*ptr_32++);
-    output.t1 = Endian::be_to_host(*ptr_32++);
-    output.t2 = Endian::be_to_host(*ptr_32++);
-    output.options.assign(ptr, opt.data_ptr() + opt.data_size());
+    output.id = stream.read_be<uint32_t>();
+    output.t1 = stream.read_be<uint32_t>();
+    output.t2 = stream.read_be<uint32_t>();
+    stream.read(output.options, stream.size());
     return output;
 }
 
-DHCPv6::ia_ta_type DHCPv6::ia_ta_type::from_option(const option &opt)
-{
-    if(opt.data_size() < sizeof(uint32_t))
+DHCPv6::ia_ta_type DHCPv6::ia_ta_type::from_option(const option& opt) {
+    if (opt.data_size() < sizeof(uint32_t)) {
         throw malformed_option();
-    const uint8_t *ptr = opt.data_ptr() + sizeof(uint32_t);
-    const uint32_t *ptr_32 = (const uint32_t*)opt.data_ptr();
+    }
+    InputMemoryStream stream(opt.data_ptr(), opt.data_size());
     DHCPv6::ia_ta_type output;
-    output.id = Endian::be_to_host(*ptr_32++);
-    output.options.assign(ptr, opt.data_ptr() + opt.data_size());
+    output.id = stream.read_be<uint32_t>();
+    stream.read(output.options, stream.size());
     return output;
 }
 
-DHCPv6::ia_address_type DHCPv6::ia_address_type::from_option(const option &opt)
-{
-    if(opt.data_size() < sizeof(uint32_t) * 2 + DHCPv6::ipaddress_type::address_size)
+DHCPv6::ia_address_type DHCPv6::ia_address_type::from_option(const option& opt) {
+    if (opt.data_size() < sizeof(uint32_t) * 2 + DHCPv6::ipaddress_type::address_size) {
         throw malformed_option();
-    const uint8_t *ptr = opt.data_ptr() + sizeof(uint32_t) * 2 + ipaddress_type::address_size;
-    const uint32_t *ptr_32 = (const uint32_t*)(opt.data_ptr() + ipaddress_type::address_size);
+    }
+    InputMemoryStream stream(opt.data_ptr(), opt.data_size());
     DHCPv6::ia_address_type output;
-    output.address = opt.data_ptr();
-    output.preferred_lifetime = Endian::be_to_host(*ptr_32++);
-    output.valid_lifetime = Endian::be_to_host(*ptr_32++);
-    output.options.assign(ptr, opt.data_ptr() + opt.data_size());
+    stream.read(output.address);
+    output.preferred_lifetime = stream.read_be<uint32_t>();
+    output.valid_lifetime = stream.read_be<uint32_t>();
+    stream.read(output.options, stream.size());
     return output;
 }
 
-DHCPv6::authentication_type DHCPv6::authentication_type::from_option(const option &opt)
-{
-    if(opt.data_size() < sizeof(uint8_t) * 3 + sizeof(uint64_t))
+DHCPv6::authentication_type DHCPv6::authentication_type::from_option(const option& opt) {
+    if (opt.data_size() < sizeof(uint8_t) * 3 + sizeof(uint64_t)) {
         throw malformed_option();
-    const uint8_t *ptr = opt.data_ptr();
+    }
+    InputMemoryStream stream(opt.data_ptr(), opt.data_size());
     authentication_type output;
-    output.protocol = *ptr++;
-    output.algorithm = *ptr++;
-    output.rdm = *ptr++;
-    std::memcpy(&output.replay_detection, ptr, sizeof(uint64_t));
-    output.replay_detection = Endian::be_to_host(output.replay_detection);
-    ptr += sizeof(uint64_t);
-    output.auth_info.assign(ptr, opt.data_ptr() + opt.data_size());
+    output.protocol = stream.read<uint8_t>();
+    output.algorithm = stream.read<uint8_t>();
+    output.rdm = stream.read<uint8_t>();
+    output.replay_detection = stream.read_be<uint64_t>();
+    stream.read(output.auth_info, stream.size());
     return output;
 }
 
-DHCPv6::status_code_type DHCPv6::status_code_type::from_option(const option &opt)
-{
-    if(opt.data_size() < sizeof(uint16_t))
+DHCPv6::status_code_type DHCPv6::status_code_type::from_option(const option& opt) {
+    if (opt.data_size() < sizeof(uint16_t)) {
         throw malformed_option();
+    }
+    InputMemoryStream stream(opt.data_ptr(), opt.data_size());
     status_code_type output;
-    std::memcpy(&output.code, opt.data_ptr(), sizeof(uint16_t));
-    output.code = Endian::be_to_host(output.code);
-    output.message.assign(
-        opt.data_ptr() + sizeof(uint16_t),
-        opt.data_ptr() + opt.data_size()
-    );
+    output.code = stream.read_be<uint16_t>();
+    output.message.assign(stream.pointer(), stream.pointer() + stream.size());
     return output;
 }
 
-DHCPv6::vendor_info_type DHCPv6::vendor_info_type::from_option(const option &opt)
-{
-    if(opt.data_size() < sizeof(uint32_t))
+DHCPv6::vendor_info_type DHCPv6::vendor_info_type::from_option(const option& opt) {
+    if (opt.data_size() < sizeof(uint32_t)) {
         throw malformed_option();
+    }
+    InputMemoryStream stream(opt.data_ptr(), opt.data_size());
     vendor_info_type output;
-    std::memcpy(&output.enterprise_number, opt.data_ptr(), sizeof(uint32_t));
-    output.enterprise_number = Endian::be_to_host(output.enterprise_number);
-    output.data.assign(
-        opt.data_ptr() + sizeof(uint32_t),
-        opt.data_ptr() + opt.data_size()
-    );
+    output.enterprise_number = stream.read_be<uint32_t>();
+    stream.read(output.data, stream.size());
     return output;
 }
 
-DHCPv6::vendor_class_type DHCPv6::vendor_class_type::from_option(const option &opt)
-{
-    if(opt.data_size() < sizeof(uint32_t))
+DHCPv6::vendor_class_type DHCPv6::vendor_class_type::from_option(const option& opt) {
+    if (opt.data_size() < sizeof(uint32_t)) {
         throw malformed_option();
+    }
     typedef vendor_class_type::class_data_type data_type;
+    InputMemoryStream stream(opt.data_ptr(), opt.data_size());
     vendor_class_type output;
-    std::memcpy(&output.enterprise_number, opt.data_ptr(), sizeof(uint32_t));
-    output.enterprise_number = Endian::be_to_host(output.enterprise_number);
+    output.enterprise_number = stream.read_be<uint32_t>();
     output.vendor_class_data = Internals::option2class_option_data<data_type>(
-        opt.data_ptr() + sizeof(uint32_t),
-        static_cast<uint32_t>(opt.data_size() - sizeof(uint32_t))
+        stream.pointer(),
+        stream.size()
     );
     
     return output;
 }
 
-DHCPv6::duid_type DHCPv6::duid_type::from_option(const option &opt)
-{
-    if(opt.data_size() < sizeof(uint16_t) + 1)
+DHCPv6::duid_type DHCPv6::duid_type::from_option(const option& opt) {
+    if (opt.data_size() < sizeof(uint16_t) + 1) {
         throw malformed_option();
-
-    uint16_t uint16_t_buffer;
-    std::memcpy(&uint16_t_buffer, opt.data_ptr(), sizeof(uint16_t));
+    }
+    InputMemoryStream stream(opt.data_ptr(), opt.data_size());
+    uint16_t id = stream.read_be<uint16_t>();
     return duid_type(
-        Endian::be_to_host(uint16_t_buffer),
-        serialization_type(
-            opt.data_ptr() + sizeof(uint16_t),
-            opt.data_ptr() + opt.data_size()
-        )
+        id,
+        serialization_type(stream.pointer(), stream.pointer() + stream.size())
     );
 }
 
-DHCPv6::user_class_type DHCPv6::user_class_type::from_option(const option &opt)
-{
-    if(opt.data_size() < sizeof(uint16_t))
+DHCPv6::user_class_type DHCPv6::user_class_type::from_option(const option& opt) {
+    if (opt.data_size() < sizeof(uint16_t)) {
         throw malformed_option();
+    }
     user_class_type output;
     output.data = Internals::option2class_option_data<data_type>(
         opt.data_ptr(), static_cast<uint32_t>(opt.data_size())
     );
     return output;
 }
+
 } // namespace Tins
diff --git a/src/dns.cpp b/src/dns.cpp
index 33b1183..8b15ffe 100644
--- a/src/dns.cpp
+++ b/src/dns.cpp
@@ -41,7 +41,10 @@
 #include "memory_helpers.h"
 
 using std::string;
+using std::copy;
+using std::memcpy;
 using std::list;
+using std::make_pair;
 
 using Tins::Memory::InputMemoryStream;
 using Tins::Memory::OutputMemoryStream;
@@ -49,259 +52,232 @@ using Tins::Memory::OutputMemoryStream;
 namespace Tins {
 
 DNS::DNS() 
-: dns(), answers_idx(), authority_idx(), additional_idx()
-{ 
+: header_(), answers_idx_(), authority_idx_(), additional_idx_() { 
 }
 
-DNS::DNS(const uint8_t *buffer, uint32_t total_sz) 
-: answers_idx(), authority_idx(), additional_idx()
-{ 
+DNS::DNS(const uint8_t* buffer, uint32_t total_sz) 
+: answers_idx_(), authority_idx_(), additional_idx_() { 
     InputMemoryStream stream(buffer, total_sz);
-    stream.read(dns);
-    records_data.assign(stream.pointer(), stream.pointer() + stream.size());
+    stream.read(header_);
+    stream.read(records_data_, stream.size());
     // Avoid doing this if there's no data. Otherwise VS's asserts fail.
-    if (!records_data.empty()) {
-        buffer = &records_data[0];
-        const uint8_t *end = &records_data[0] + records_data.size(), *prev_start = buffer;
+    if (!records_data_.empty()) {
+        InputMemoryStream stream(records_data_);
         uint16_t nquestions = questions_count();
-        for(uint16_t i(0); i < nquestions; ++i) {
-            buffer = find_dname_end(buffer);
-            if((buffer + (sizeof(uint16_t) * 2)) > end)
-                throw malformed_packet();
-            buffer += sizeof(uint16_t) * 2;
+        for (uint16_t i(0); i < nquestions; ++i) {
+            skip_to_dname_end(stream);
+            stream.skip(sizeof(uint16_t) * 2);
         }
-        answers_idx = static_cast<uint32_t>(buffer - prev_start);
-        authority_idx = static_cast<uint32_t>(
-            find_section_end(&records_data[0] + answers_idx, answers_count()) - &records_data[0]
-        );
-        additional_idx = static_cast<uint32_t>(
-            find_section_end(&records_data[0] + authority_idx, authority_count()) - &records_data[0]
-        );
+        const uint8_t* base_offset = &records_data_[0];
+        answers_idx_ = static_cast<uint32_t>(stream.pointer() - base_offset);
+        skip_to_section_end(stream, answers_count());
+        authority_idx_ = static_cast<uint32_t>(stream.pointer() - base_offset);
+        skip_to_section_end(stream, authority_count());
+        additional_idx_ = static_cast<uint32_t>(stream.pointer() - base_offset);
     }
 }
 
-const uint8_t* DNS::find_dname_end(const uint8_t *ptr) const {
-    const uint8_t *end = &records_data[0] + records_data.size();
-    while(ptr < end) {
-        if(*ptr == 0) {
-            ++ptr;
+void DNS::skip_to_dname_end(InputMemoryStream& stream) const {
+    while (stream) {
+        uint8_t value = stream.read<uint8_t>();
+        if (value == 0) {
+            // Found the ending null byte, we're done
             break;
         }
         else {
-            if((*ptr & 0xc0)) {
-                ptr += sizeof(uint16_t);
+            if ((value & 0xc0)) {
+                // This is an offset label, skip the second byte and we're done
+                stream.skip(1);
                 break;
             }
             else {
-                uint8_t size = *ptr;
-                ptr += size + 1;
+                // This is an actual label, skip its contents
+                stream.skip(value);
             }
         }
     }
-    return ptr;
 }
 
-const uint8_t *DNS::find_section_end(const uint8_t *ptr, const uint32_t num_records) const {
-    const uint8_t *end = &records_data[0] + records_data.size();
-    uint16_t uint16_t_buffer;
-    for(uint32_t i = 0; i < num_records; ++i) {
-        ptr = find_dname_end(ptr);
-        if(ptr + sizeof(uint16_t) * 3 + sizeof(uint32_t) > end)
+void DNS::skip_to_section_end(InputMemoryStream& stream, 
+                              const uint32_t num_records) const {
+    for (uint32_t i = 0; i < num_records; ++i) {
+        skip_to_dname_end(stream);
+        stream.skip(sizeof(uint16_t) * 2 + sizeof(uint32_t));
+        uint16_t data_size = stream.read_be<uint16_t>();
+        if (!stream.can_read(data_size)) {
             throw malformed_packet();
-        ptr += sizeof(uint16_t) * 2 + sizeof(uint32_t);
-        std::memcpy(&uint16_t_buffer, ptr, sizeof(uint16_t));
-        uint16_t data_size = Endian::be_to_host(uint16_t_buffer); // Data size
-        ptr += sizeof(uint16_t);
-        if(ptr + data_size > end)
-            throw malformed_packet();
-        ptr += data_size;
+        }
+        stream.skip(data_size);
     }
-    return ptr;
 }
 
 uint32_t DNS::header_size() const {
-    return static_cast<uint32_t>(sizeof(dns) + records_data.size());
+    return static_cast<uint32_t>(sizeof(header_) + records_data_.size());
 }
 
 void DNS::id(uint16_t new_id) {
-    dns.id = Endian::host_to_be(new_id);
+    header_.id = Endian::host_to_be(new_id);
 }
 
 void DNS::type(QRType new_qr) {
-    dns.qr = new_qr;
+    header_.qr = new_qr;
 }
 
 void DNS::opcode(uint8_t new_opcode) {
-    dns.opcode = new_opcode;
+    header_.opcode = new_opcode;
 }
 
 void DNS::authoritative_answer(uint8_t new_aa) {
-    dns.aa = new_aa;
+    header_.aa = new_aa;
 }
 
 void DNS::truncated(uint8_t new_tc) {
-    dns.tc = new_tc;
+    header_.tc = new_tc;
 }
 
 void DNS::recursion_desired(uint8_t new_rd) {
-    dns.rd = new_rd;
+    header_.rd = new_rd;
 }
 
 void DNS::recursion_available(uint8_t new_ra) {
-    dns.ra = new_ra;
+    header_.ra = new_ra;
 }
 
 void DNS::z(uint8_t new_z) {
-    dns.z = new_z;
+    header_.z = new_z;
 }
 
 void DNS::authenticated_data(uint8_t new_ad) {
-    dns.ad = new_ad;
+    header_.ad = new_ad;
 }
 
 void DNS::checking_disabled(uint8_t new_cd) {
-    dns.cd = new_cd;
+    header_.cd = new_cd;
 }
 
 void DNS::rcode(uint8_t new_rcode) {
-    dns.rcode = new_rcode;
+    header_.rcode = new_rcode;
 }
 
 bool DNS::contains_dname(uint16_t type) {
-    return type == MX || type == CNAME ||
-          type == PTR || type == NS;
+    return type == MX || type == CNAME || type == PTR || type == NS;
 }
 
-void DNS::add_query(const Query &query) {
+void DNS::add_query(const Query& query) {
     string new_str = encode_domain_name(query.dname());
-    // Type (2 bytes) + Class (2 Bytes)
+    size_t previous_length = new_str.size();
+    // Epand the string to hold: Type (2 bytes) + Class (2 Bytes)
     new_str.insert(new_str.end(), sizeof(uint16_t) * 2, ' ');
-    uint16_t uint16_t_buffer;
-    uint16_t_buffer = Endian::host_to_be<uint16_t>(query.type());
-    std::memcpy(&new_str[new_str.size() - 4], &uint16_t_buffer, sizeof(uint16_t));
-    uint16_t_buffer = Endian::host_to_be<uint16_t>(query.query_class());
-    std::memcpy(&new_str[new_str.size() - 2], &uint16_t_buffer, sizeof(uint16_t));
+    // Build a stream at the end
+    OutputMemoryStream stream(
+        (uint8_t*)&new_str[0] + previous_length, 
+        sizeof(uint16_t) * 2
+    );
+    stream.write_be<uint16_t>(query.type());
+    stream.write_be<uint16_t>(query.query_class());
 
-    uint32_t offset = static_cast<uint32_t>(new_str.size()), threshold = answers_idx;
-    update_records(answers_idx, answers_count(), threshold, offset);
-    update_records(authority_idx, authority_count(), threshold, offset);
-    update_records(additional_idx, additional_count(), threshold, offset);
-    records_data.insert(
-        records_data.begin() + threshold,
+    uint32_t offset = static_cast<uint32_t>(new_str.size()), threshold = answers_idx_;
+    update_records(answers_idx_, answers_count(), threshold, offset);
+    update_records(authority_idx_, authority_count(), threshold, offset);
+    update_records(additional_idx_, additional_count(), threshold, offset);
+    records_data_.insert(
+        records_data_.begin() + threshold,
         new_str.begin(),
         new_str.end()
     );
-    dns.questions = Endian::host_to_be(static_cast<uint16_t>(questions_count() + 1));
+    header_.questions = Endian::host_to_be(static_cast<uint16_t>(questions_count() + 1));
 }
 
-void DNS::add_answer(const Resource &resource) {
+void DNS::add_answer(const Resource& resource) {
     sections_type sections;
-    sections.push_back(std::make_pair(&authority_idx, authority_count()));
-    sections.push_back(std::make_pair(&additional_idx, additional_count()));
+    sections.push_back(make_pair(&authority_idx_, authority_count()));
+    sections.push_back(make_pair(&additional_idx_, additional_count()));
     add_record(resource, sections);
-    dns.answers = Endian::host_to_be<uint16_t>(
+    header_.answers = Endian::host_to_be<uint16_t>(
         answers_count() + 1
     );
 }
 
-void DNS::add_record(const Resource &resource, const sections_type &sections) {
+void DNS::add_record(const Resource& resource, const sections_type& sections) {
     // We need to check that the data provided is correct. Otherwise, the sections
     // will end up being inconsistent.
     IPv4Address v4_addr;
     IPv6Address v6_addr;
-    std::string buffer = encode_domain_name(resource.dname()), encoded_data;
+    string buffer = encode_domain_name(resource.dname()), encoded_data;
     // By default the data size is the length of the data field.
     size_t data_size = resource.data().size();
-    if(resource.type() == A) {
+    if (resource.type() == A) {
         v4_addr = resource.data();
         data_size = 4;
     }
-    else if(resource.type() == AAAA) {
+    else if (resource.type() == AAAA) {
         v6_addr = resource.data();
         data_size = IPv6Address::address_size;
     }
-    else if(contains_dname(resource.type())) { 
+    else if (contains_dname(resource.type())) { 
         encoded_data = encode_domain_name(resource.data());
         data_size = encoded_data.size();
     }
     size_t offset = buffer.size() + sizeof(uint16_t) * 3 + sizeof(uint32_t) + data_size, 
-            threshold = sections.empty() ? records_data.size() : *sections.front().first;
+           threshold = sections.empty() ? records_data_.size() :* sections.front().first;
     // Skip the preference field
-    if(resource.type() == MX) {
+    if (resource.type() == MX) {
         offset += sizeof(uint16_t);
     }
-    for(size_t i = 0; i < sections.size(); ++i) {
+    for (size_t i = 0; i < sections.size(); ++i) {
         update_records(*sections[i].first, sections[i].second, 
             static_cast<uint32_t>(threshold), static_cast<uint32_t>(offset));
     }
     
-    records_data.insert(
-        records_data.begin() + threshold,
+    records_data_.insert(
+        records_data_.begin() + threshold,
         offset,
         0
     );
-    uint8_t *ptr = std::copy(
-        buffer.begin(),
-        buffer.end(),
-        &records_data[0] + threshold
-    );
-
-    uint16_t uint16_t_buffer;
-    uint32_t uint32_t_buffer;
-
-    uint16_t_buffer = Endian::host_to_be(resource.type());
-    std::memcpy(ptr, &uint16_t_buffer, sizeof(uint16_t));
-    ptr += sizeof(uint16_t);
-    uint16_t_buffer = Endian::host_to_be(resource.query_class());
-    std::memcpy(ptr, &uint16_t_buffer, sizeof(uint16_t));
-    ptr += sizeof(uint16_t);
-    uint32_t_buffer = Endian::host_to_be(resource.ttl());
-    std::memcpy(ptr, &uint32_t_buffer, sizeof(uint32_t));
-    ptr += sizeof(uint32_t);
-    uint16_t_buffer = Endian::host_to_be(
-        static_cast<uint16_t>(data_size + (resource.type() == MX ? 2 : 0))
-    );
-    std::memcpy(ptr, &uint16_t_buffer, sizeof(uint16_t));
-    ptr += sizeof(uint16_t);
-    if(resource.type() == MX) {
-        ptr += sizeof(uint16_t);
+    OutputMemoryStream stream(&records_data_[0] + threshold, offset);
+    stream.write(buffer.begin(), buffer.end());
+    stream.write_be(resource.type());
+    stream.write_be(resource.query_class());
+    stream.write_be(resource.ttl());
+    stream.write_be<uint16_t>(data_size + (resource.type() == MX ? 2 : 0));
+    if (resource.type() == MX) {
+        stream.skip(sizeof(uint16_t));
     }
-    if(resource.type() == A) {
-        uint32_t ip_int = v4_addr;
-        std::memcpy(ptr, &ip_int, sizeof(ip_int));
+    if (resource.type() == A) {
+        stream.write(v4_addr);
     }
-    else if(resource.type() == AAAA) {
-        std::copy(v6_addr.begin(), v6_addr.end(), ptr);
+    else if (resource.type() == AAAA) {
+        stream.write(v6_addr);
     }
-    else if(!encoded_data.empty()) {
-        std::copy(encoded_data.begin(), encoded_data.end(), ptr);
+    else if (!encoded_data.empty()) {
+        stream.write(encoded_data.begin(), encoded_data.end());
     }
     else {
-        std::copy(resource.data().begin(), resource.data().end(), ptr);
+        stream.write(resource.data().begin(), resource.data().end());
     }
 }
 
-void DNS::add_authority(const Resource &resource) {
+void DNS::add_authority(const Resource& resource) {
     sections_type sections;
-    sections.push_back(std::make_pair(&additional_idx, additional_count()));
+    sections.push_back(make_pair(&additional_idx_, additional_count()));
     add_record(resource, sections);
-    dns.authority = Endian::host_to_be<uint16_t>(
+    header_.authority = Endian::host_to_be<uint16_t>(
         authority_count() + 1
     );
 }
 
-void DNS::add_additional(const Resource &resource){
+void DNS::add_additional(const Resource& resource){
     add_record(resource, sections_type());
-    dns.additional = Endian::host_to_be<uint16_t>(
+    header_.additional = Endian::host_to_be<uint16_t>(
         additional_count() + 1
     );
 }
 
-std::string DNS::encode_domain_name(const std::string &dn) {
-    std::string output;
+string DNS::encode_domain_name(const string& dn) {
+    string output;
     size_t last_index(0), index;
-    if(!dn.empty()) {
-        while((index = dn.find('.', last_index+1)) != string::npos) {
+    if (!dn.empty()) {
+        while ((index = dn.find('.', last_index+1)) != string::npos) {
             output.push_back(static_cast<char>(index - last_index));
             output.append(dn.begin() + last_index, dn.begin() + index);
             last_index = index + 1; //skip dot
@@ -316,59 +292,64 @@ std::string DNS::encode_domain_name(const std::string &dn) {
 // The output buffer should be at least 256 bytes long. This used to use
 // a std::string but it worked about 50% slower, so this is somehow 
 // unsafe but a lot faster.
-const uint8_t* DNS::compose_name(const uint8_t *ptr, char *out_ptr) const {
-    const uint8_t *end = &records_data[0] + records_data.size();
-    const uint8_t *end_ptr = 0;
-    char *current_out_ptr = out_ptr;
-    while(*ptr) {
+uint32_t DNS::compose_name(const uint8_t* ptr, char* out_ptr) const {
+    const uint8_t* start_ptr = ptr;
+    const uint8_t* end = &records_data_[0] + records_data_.size();
+    const uint8_t* end_ptr = 0;
+    char* current_out_ptr = out_ptr;
+    while (*ptr) {
         // It's an offset
-        if((*ptr & 0xc0)) {
-            if(ptr + sizeof(uint16_t) > end)
+        if ((*ptr & 0xc0)) {
+            if (ptr + sizeof(uint16_t) > end) {
                 throw malformed_packet();
+            }
             uint16_t index;
-            std::memcpy(&index, ptr, sizeof(uint16_t));
+            memcpy(&index, ptr, sizeof(uint16_t));
             index = Endian::be_to_host(index) & 0x3fff;
             // Check that the offset is neither too low or too high
-            if(index < 0x0c || (&records_data[0] + (index - 0x0c)) >= end)
+            if (index < 0x0c || (&records_data_[0] + (index - 0x0c)) >= end) {
                 throw malformed_packet();
+            }
             // We've probably found the end of the original domain name. Save it.
-            if(end_ptr == 0)
+            if (end_ptr == 0) {
                 end_ptr = ptr + sizeof(uint16_t);
+            }
             // Now this is our pointer
-            ptr = &records_data[index - 0x0c];
+            ptr = &records_data_[index - 0x0c];
         }
         else {
             // It's a label, grab its size.
             uint8_t size = *ptr;
             ptr++;
-            if(ptr + size > end || current_out_ptr - out_ptr + size + 1 > 255)
+            if (ptr + size > end || current_out_ptr - out_ptr + size + 1 > 255) {
                 throw malformed_packet();
+            }
             // Append a dot if it's not the first one.
-            if(current_out_ptr != out_ptr)
+            if (current_out_ptr != out_ptr) {
                 *current_out_ptr++ = '.';
-            std::copy(
-                ptr,
-                ptr + size,
-                current_out_ptr
-            );
+            }
+            copy(ptr, ptr + size, current_out_ptr);
             current_out_ptr += size;
             ptr += size;
         }
     }
     // Add the null terminator.
     *current_out_ptr = 0;
-    return end_ptr ? end_ptr : (ptr + 1);
+    if (!end_ptr) {
+        end_ptr = ptr + 1;
+    }
+    return end_ptr - start_ptr;
 }
 
-void DNS::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent) {
+void DNS::write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent) {
     OutputMemoryStream stream(buffer, total_sz);
-    stream.write(dns);
-    stream.write(records_data.begin(), records_data.end());
+    stream.write(header_);
+    stream.write(records_data_.begin(), records_data_.end());
 }
 
 // Optimization. Creating an IPv4Address and then using IPv4Address::to_string
 // was quite slow. The output buffer should be able to hold an IPv4 address.
-void DNS::inline_convert_v4(uint32_t value, char *output) {
+void DNS::inline_convert_v4(uint32_t value, char* output) {
     output += sprintf(
         output, 
         "%d.%d.%d.%d", 
@@ -388,82 +369,62 @@ void DNS::inline_convert_v4(uint32_t value, char *output) {
 }
 
 // Parses records in some section.
-void DNS::convert_records(const uint8_t *ptr, const uint8_t *end, resources_type &res) const {
+void DNS::convert_records(const uint8_t* ptr,
+                          const uint8_t* end,
+                          resources_type& res) const {
+    InputMemoryStream stream(ptr, end - ptr);
     char dname[256], small_addr_buf[256];
-    while(ptr < end) {
-        std::string addr;
+    while (stream) {
+        string addr;
         bool used_small_buffer = false;
         // Retrieve the record's domain name.
-        ptr = compose_name(ptr, dname);
-        // 3 uint16_t fields: Type + Class + Data size
-        // 1 uint32_t field: TTL
-        if(ptr + sizeof(uint16_t) * 3 + sizeof(uint32_t) > end)
-            throw malformed_packet();
+        stream.skip(compose_name(stream.pointer(), dname));
         // Retrieve the following fields.
         uint16_t type, qclass, data_size;
         uint32_t ttl;
-        std::memcpy(&type, ptr, sizeof(uint16_t)); // Type
-        type = Endian::be_to_host(type);
-        ptr += sizeof(uint16_t);
-        std::memcpy(&qclass, ptr, sizeof(uint16_t)); // Class
-        qclass = Endian::be_to_host(qclass);
-        ptr += sizeof(uint16_t);
-        std::memcpy(&ttl, ptr, sizeof(uint32_t)); // TTL
-        ttl = Endian::be_to_host(ttl);
-        ptr += sizeof(uint32_t);
-        std::memcpy(&data_size, ptr, sizeof(uint16_t)); // Data size
-        data_size = Endian::be_to_host(data_size);
-        ptr += sizeof(uint16_t);
+        type = stream.read_be<uint16_t>();
+        qclass = stream.read_be<uint16_t>();
+        ttl = stream.read_be<uint32_t>();
+        data_size = stream.read_be<uint16_t>();
         // Skip the preference field if it's MX
-        if(type ==  MX) {
-            if(data_size < 2)
-                throw malformed_packet();
-            ptr += 2;
-            data_size -= 2;
+        if (type ==  MX) {
+            stream.skip(sizeof(uint16_t));
+            data_size -= sizeof(uint16_t);
         }
-        if(ptr + data_size > end)
+        if (!stream.can_read(data_size)) {
             throw malformed_packet();
+        }
 
-        switch(type) {
+        switch (type) {
             case AAAA:
-                if(data_size != 16)
-                    throw malformed_packet();
-                addr = IPv6Address(ptr).to_string();
+                addr = stream.read<IPv6Address>().to_string();
                 break;
             case A:
-                if(data_size == 4) {
-                    uint32_t uint32_t_buffer;
-                    std::memcpy(&uint32_t_buffer, ptr, sizeof(uint32_t));
-                    inline_convert_v4(uint32_t_buffer, small_addr_buf);
-                    used_small_buffer = true;
-                }
-                else
-                    throw malformed_packet();
+                inline_convert_v4(stream.read<uint32_t>(), small_addr_buf);
+                used_small_buffer = true;
                 break;
             case NS:
             case CNAME:
             case DNAM:
             case PTR:
             case MX:
-                compose_name(ptr, small_addr_buf);
+                compose_name(stream.pointer(), small_addr_buf);
+                stream.skip(data_size);
                 used_small_buffer = true;
                 break;
             default:
-                if(data_size < sizeof(small_addr_buf) - 1) {
-                    std::copy(
-                        ptr,
-                        ptr + data_size,
-                        small_addr_buf
-                    );
+                if (data_size < sizeof(small_addr_buf) - 1) {
+                    stream.read(small_addr_buf, data_size);
                     // null terminator
                     small_addr_buf[data_size] = 0;
                     used_small_buffer = true;
                 }
-                else
-                    addr.assign(ptr, ptr + data_size);
+                else {
+                    addr.assign(stream.pointer(), stream.pointer() + data_size);
+                    stream.skip(data_size);
+                }
                 break;
         }
-        ptr += data_size;
         res.push_back(
             Resource(
                 dname, 
@@ -477,15 +438,15 @@ void DNS::convert_records(const uint8_t *ptr, const uint8_t *end, resources_type
 }
 
 // no length checks, records should already be valid
-uint8_t *DNS::update_dname(uint8_t *ptr, uint32_t threshold, uint32_t offset) {
-    while(*ptr != 0) {
-        if((*ptr & 0xc0)) {
+uint8_t* DNS::update_dname(uint8_t* ptr, uint32_t threshold, uint32_t offset) {
+    while (*ptr != 0) {
+        if ((*ptr & 0xc0)) {
             uint16_t index;
-            std::memcpy(&index, ptr, sizeof(uint16_t));
+            memcpy(&index, ptr, sizeof(uint16_t));
             index = Endian::be_to_host(index) & 0x3fff;
-            if(index > threshold) {
+            if (index > threshold) {
                 index = Endian::host_to_be<uint16_t>((index + offset) | 0xc000);
-                std::memcpy(ptr, &index, sizeof(uint16_t));
+                memcpy(ptr, &index, sizeof(uint16_t));
             }
             ptr += sizeof(uint16_t);
             break;
@@ -499,24 +460,27 @@ uint8_t *DNS::update_dname(uint8_t *ptr, uint32_t threshold, uint32_t offset) {
 
 // Updates offsets in domain names inside records.
 // No length checks, records are already valid.
-void DNS::update_records(uint32_t &section_start, uint32_t num_records, uint32_t threshold, uint32_t offset) {
-    if(section_start < records_data.size()) {
-        uint8_t *ptr = &records_data[section_start];
-        for(uint32_t i = 0; i < num_records; ++i) {
+void DNS::update_records(uint32_t& section_start, 
+                         uint32_t num_records, 
+                         uint32_t threshold, 
+                         uint32_t offset) {
+    if (section_start < records_data_.size()) {
+        uint8_t* ptr = &records_data_[section_start];
+        for (uint32_t i = 0; i < num_records; ++i) {
             ptr = update_dname(ptr, threshold, offset);
             uint16_t type;
-            std::memcpy(&type, ptr, sizeof(uint16_t));
+            memcpy(&type, ptr, sizeof(uint16_t));
             type = Endian::be_to_host(type);
             ptr += sizeof(uint16_t) * 2 + sizeof(uint32_t);
             uint16_t size;
-            std::memcpy(&size, ptr, sizeof(uint16_t));
+            memcpy(&size, ptr, sizeof(uint16_t));
             size = Endian::be_to_host(size);
             ptr += sizeof(uint16_t);
-            if(type == MX) {
+            if (type == MX) {
                 ptr += sizeof(uint16_t);
                 size -= sizeof(uint16_t);
             }
-            if(contains_dname(type)) {
+            if (contains_dname(type)) {
                 update_dname(ptr, threshold, offset);
             }
             ptr += size;
@@ -527,26 +491,16 @@ void DNS::update_records(uint32_t &section_start, uint32_t num_records, uint32_t
 
 DNS::queries_type DNS::queries() const { 
     queries_type output;
-    if(!records_data.empty()) {
-        const uint8_t *ptr = &records_data[0], 
-                    *end = &records_data[0] + answers_idx;
+    if (!records_data_.empty()) {
+        InputMemoryStream stream(&records_data_[0], answers_idx_);
         char buffer[256];
-        uint16_t tmp_query_type;
-        uint16_t tmp_query_class;
-        while(ptr < end) {
-            ptr = compose_name(ptr, buffer);
-            if(ptr + sizeof(uint16_t) * 2 > end) 
-                throw malformed_packet();
-            std::memcpy(&tmp_query_type, ptr, sizeof(uint16_t));
-            std::memcpy(&tmp_query_class, ptr + 2, sizeof(uint16_t));
+        while (stream) {
+            stream.skip(compose_name(stream.pointer(), buffer));
+            uint16_t query_type = stream.read_be<uint16_t>();
+            uint16_t query_class = stream.read_be<uint16_t>();
             output.push_back(
-                Query(
-                    buffer, 
-                    (QueryType)Endian::be_to_host(tmp_query_type), 
-                    (QueryClass)Endian::be_to_host(tmp_query_class)
-                )
+                Query(buffer, (QueryType)query_type, (QueryClass)query_class)
             );
-            ptr += sizeof(uint16_t) * 2;
         }
     }
     return output;
@@ -554,10 +508,10 @@ DNS::queries_type DNS::queries() const {
 
 DNS::resources_type DNS::answers() const {
     resources_type res;
-    if(answers_idx < records_data.size()) {
+    if (answers_idx_ < records_data_.size()) {
         convert_records(
-            &records_data[0] + answers_idx, 
-            &records_data[0] + authority_idx, 
+            &records_data_[0] + answers_idx_, 
+            &records_data_[0] + authority_idx_, 
             res
         );
     }
@@ -566,10 +520,10 @@ DNS::resources_type DNS::answers() const {
 
 DNS::resources_type DNS::authority() const {
     resources_type res;
-    if(authority_idx < records_data.size()) {
+    if (authority_idx_ < records_data_.size()) {
         convert_records(
-            &records_data[0] + authority_idx, 
-            &records_data[0] + additional_idx, 
+            &records_data_[0] + authority_idx_, 
+            &records_data_[0] + additional_idx_, 
             res
         );
     }
@@ -578,20 +532,22 @@ DNS::resources_type DNS::authority() const {
 
 DNS::resources_type DNS::additional() const {
     resources_type res;
-    if(additional_idx < records_data.size()) {
+    if (additional_idx_ < records_data_.size()) {
         convert_records(
-            &records_data[0] + additional_idx, 
-            &records_data[0] + records_data.size(), 
+            &records_data_[0] + additional_idx_, 
+            &records_data_[0] + records_data_.size(), 
             res
         );
     }
     return res;
 }
 
-bool DNS::matches_response(const uint8_t *ptr, uint32_t total_sz) const {
-    if(total_sz < sizeof(dnshdr))
+bool DNS::matches_response(const uint8_t* ptr, uint32_t total_sz) const {
+    if (total_sz < sizeof(header_)) {
         return false;
-    const dnshdr *hdr = (const dnshdr*)ptr;
-    return hdr->id == dns.id;
-}
+    }
+    const dns_header* hdr = (const dns_header*)ptr;
+    return hdr->id == header_.id;
 }
+
+} // Tins
diff --git a/src/dot11/dot11_assoc.cpp b/src/dot11/dot11_assoc.cpp
index 45d99b1..18b63fe 100644
--- a/src/dot11/dot11_assoc.cpp
+++ b/src/dot11/dot11_assoc.cpp
@@ -37,168 +37,159 @@ using Tins::Memory::InputMemoryStream;
 using Tins::Memory::OutputMemoryStream;
 
 namespace Tins {
-/* Diassoc */
 
-Dot11Disassoc::Dot11Disassoc(const address_type &dst_hw_addr, 
-  const address_type &src_hw_addr) 
-: Dot11ManagementFrame(dst_hw_addr, src_hw_addr), _body()
-{
-    this->subtype(Dot11::DISASSOC);
+// Disassoc
+
+Dot11Disassoc::Dot11Disassoc(const address_type& dst_hw_addr, 
+                             const address_type& src_hw_addr) 
+: Dot11ManagementFrame(dst_hw_addr, src_hw_addr), body_() {
+this->subtype(Dot11::DISASSOC);
 }
 
-Dot11Disassoc::Dot11Disassoc(const uint8_t *buffer, uint32_t total_sz) 
+Dot11Disassoc::Dot11Disassoc(const uint8_t* buffer, uint32_t total_sz) 
 : Dot11ManagementFrame(buffer, total_sz) {
     InputMemoryStream stream(buffer, total_sz);
     stream.skip(management_frame_size());
-    stream.read(_body);
+    stream.read(body_);
     parse_tagged_parameters(stream);
 }
 
 void Dot11Disassoc::reason_code(uint16_t new_reason_code) {
-    this->_body.reason_code = Endian::host_to_le(new_reason_code);
+    body_.reason_code = Endian::host_to_le(new_reason_code);
 }
 
 uint32_t Dot11Disassoc::header_size() const {
-    return Dot11ManagementFrame::header_size() + sizeof(DisassocBody);
+    return Dot11ManagementFrame::header_size() + sizeof(body_);
 }
 
 void Dot11Disassoc::write_fixed_parameters(OutputMemoryStream& stream) {
-    stream.write(_body);
+    stream.write(body_);
 }
 
-/* Assoc request. */
+// Assoc request
 
-Dot11AssocRequest::Dot11AssocRequest(const address_type &dst_hw_addr, 
-const address_type &src_hw_addr) 
-: Dot11ManagementFrame(dst_hw_addr, src_hw_addr), _body()
-{
+Dot11AssocRequest::Dot11AssocRequest(const address_type& dst_hw_addr, 
+                                     const address_type& src_hw_addr) 
+: Dot11ManagementFrame(dst_hw_addr, src_hw_addr), body_() {
     subtype(Dot11::ASSOC_REQ);
 }
 
-Dot11AssocRequest::Dot11AssocRequest(const uint8_t *buffer, uint32_t total_sz) 
-: Dot11ManagementFrame(buffer, total_sz) 
-{
+Dot11AssocRequest::Dot11AssocRequest(const uint8_t* buffer, uint32_t total_sz) 
+: Dot11ManagementFrame(buffer, total_sz) {
     InputMemoryStream stream(buffer, total_sz);
     stream.skip(management_frame_size());
-    stream.read(_body);
+    stream.read(body_);
     parse_tagged_parameters(stream);
 }
 
 void Dot11AssocRequest::listen_interval(uint16_t new_listen_interval) {
-    this->_body.listen_interval = Endian::host_to_le(new_listen_interval);
+    body_.listen_interval = Endian::host_to_le(new_listen_interval);
 }
 
 uint32_t Dot11AssocRequest::header_size() const {
-    return Dot11ManagementFrame::header_size() + sizeof(AssocReqBody);
+    return Dot11ManagementFrame::header_size() + sizeof(body_);
 }
 
 void Dot11AssocRequest::write_fixed_parameters(OutputMemoryStream& stream) {
-    stream.write(_body);
+    stream.write(body_);
 }
 
-/* Assoc response. */
+// Assoc response
 
-Dot11AssocResponse::Dot11AssocResponse(const address_type &dst_hw_addr, 
-  const address_type &src_hw_addr) 
-: Dot11ManagementFrame(dst_hw_addr, src_hw_addr) 
-{
+Dot11AssocResponse::Dot11AssocResponse(const address_type& dst_hw_addr, 
+                                       const address_type& src_hw_addr) 
+: Dot11ManagementFrame(dst_hw_addr, src_hw_addr), body_() {
     subtype(Dot11::ASSOC_RESP);
-    memset(&_body, 0, sizeof(_body));
 }
 
-Dot11AssocResponse::Dot11AssocResponse(const uint8_t *buffer, uint32_t total_sz) 
-: Dot11ManagementFrame(buffer, total_sz) 
-{
+Dot11AssocResponse::Dot11AssocResponse(const uint8_t* buffer, uint32_t total_sz) 
+: Dot11ManagementFrame(buffer, total_sz) {
     InputMemoryStream stream(buffer, total_sz);
     stream.skip(management_frame_size());
-    stream.read(_body);
+    stream.read(body_);
     parse_tagged_parameters(stream);
 }
 
 void Dot11AssocResponse::status_code(uint16_t new_status_code) {
-    this->_body.status_code = Endian::host_to_le(new_status_code);
+    body_.status_code = Endian::host_to_le(new_status_code);
 }
 
 void Dot11AssocResponse::aid(uint16_t new_aid) {
-    this->_body.aid = Endian::host_to_le(new_aid);
+    body_.aid = Endian::host_to_le(new_aid);
 }
 
 uint32_t Dot11AssocResponse::header_size() const {
-    return Dot11ManagementFrame::header_size() + sizeof(AssocRespBody);
+    return Dot11ManagementFrame::header_size() + sizeof(body_);
 }
 
 void Dot11AssocResponse::write_fixed_parameters(OutputMemoryStream& stream) {
-    stream.write(_body);
+    stream.write(body_);
 }
 
-/* ReAssoc request. */
+// ReAssoc request
 
-Dot11ReAssocRequest::Dot11ReAssocRequest(const address_type &dst_hw_addr, 
-  const address_type &src_hw_addr) 
-: Dot11ManagementFrame(dst_hw_addr, src_hw_addr)
-{
-    this->subtype(Dot11::REASSOC_REQ);
-    memset(&_body, 0, sizeof(_body));
+Dot11ReAssocRequest::Dot11ReAssocRequest(const address_type& dst_hw_addr, 
+                                         const address_type& src_hw_addr) 
+: Dot11ManagementFrame(dst_hw_addr, src_hw_addr), body_() {
+    subtype(Dot11::REASSOC_REQ);
 }
 
-Dot11ReAssocRequest::Dot11ReAssocRequest(const uint8_t *buffer, uint32_t total_sz) 
-: Dot11ManagementFrame(buffer, total_sz) 
-{
+Dot11ReAssocRequest::Dot11ReAssocRequest(const uint8_t* buffer, uint32_t total_sz) 
+: Dot11ManagementFrame(buffer, total_sz) {
     InputMemoryStream stream(buffer, total_sz);
     stream.skip(management_frame_size());
-    stream.read(_body);
+    stream.read(body_);
     parse_tagged_parameters(stream);
 }
 
 void Dot11ReAssocRequest::listen_interval(uint16_t new_listen_interval) {
-    this->_body.listen_interval = Endian::host_to_le(new_listen_interval);
+    body_.listen_interval = Endian::host_to_le(new_listen_interval);
 }
 
-void Dot11ReAssocRequest::current_ap(const address_type &new_current_ap) {
-    new_current_ap.copy(_body.current_ap);
+void Dot11ReAssocRequest::current_ap(const address_type& new_current_ap) {
+    new_current_ap.copy(body_.current_ap);
 }
 
 uint32_t Dot11ReAssocRequest::header_size() const {
-    return Dot11ManagementFrame::header_size() + sizeof(this->_body);
+    return Dot11ManagementFrame::header_size() + sizeof(body_);
 }
 
 void Dot11ReAssocRequest::write_fixed_parameters(OutputMemoryStream& stream) {
-    stream.write(_body);
+    stream.write(body_);
 }
 
-/* ReAssoc response. */
+// ReAssoc response
 
-Dot11ReAssocResponse::Dot11ReAssocResponse(const address_type &dst_hw_addr, 
-  const address_type &src_hw_addr)
-: Dot11ManagementFrame(dst_hw_addr, src_hw_addr) 
-{
-    this->subtype(Dot11::REASSOC_RESP);
-    memset(&_body, 0, sizeof(_body));
+Dot11ReAssocResponse::Dot11ReAssocResponse(const address_type& dst_hw_addr, 
+                                           const address_type& src_hw_addr)
+: Dot11ManagementFrame(dst_hw_addr, src_hw_addr), body_() {
+    subtype(Dot11::REASSOC_RESP);
 }
 
-Dot11ReAssocResponse::Dot11ReAssocResponse(const uint8_t *buffer, uint32_t total_sz) 
+Dot11ReAssocResponse::Dot11ReAssocResponse(const uint8_t* buffer, uint32_t total_sz) 
 : Dot11ManagementFrame(buffer, total_sz) {
     InputMemoryStream stream(buffer, total_sz);
     stream.skip(management_frame_size());
-    stream.read(_body);
+    stream.read(body_);
     parse_tagged_parameters(stream);
 }
 
 void Dot11ReAssocResponse::status_code(uint16_t new_status_code) {
-    this->_body.status_code = Endian::host_to_le(new_status_code);
+    body_.status_code = Endian::host_to_le(new_status_code);
 }
 
 void Dot11ReAssocResponse::aid(uint16_t new_aid) {
-    this->_body.aid = Endian::host_to_le(new_aid);
+    body_.aid = Endian::host_to_le(new_aid);
 }
 
 uint32_t Dot11ReAssocResponse::header_size() const {
-    return Dot11ManagementFrame::header_size() + sizeof(this->_body);
+    return Dot11ManagementFrame::header_size() + sizeof(body_);
 }
 
 void Dot11ReAssocResponse::write_fixed_parameters(OutputMemoryStream& stream) {
-    stream.write(_body);
+    stream.write(body_);
 }
-} // namespace Tins
+
+} // Tins
 
 #endif // HAVE_DOT11
diff --git a/src/dot11/dot11_auth.cpp b/src/dot11/dot11_auth.cpp
index 390a72b..679756e 100644
--- a/src/dot11/dot11_auth.cpp
+++ b/src/dot11/dot11_auth.cpp
@@ -37,74 +37,71 @@ using Tins::Memory::InputMemoryStream;
 using Tins::Memory::OutputMemoryStream;
 
 namespace Tins {
-/* Auth */
 
-Dot11Authentication::Dot11Authentication(const address_type &dst_hw_addr, 
-const address_type &src_hw_addr) 
-: Dot11ManagementFrame(dst_hw_addr, src_hw_addr) 
-{
-    this->subtype(Dot11::AUTH);
-    memset(&_body, 0, sizeof(_body));
+// Auth
+
+Dot11Authentication::Dot11Authentication(const address_type& dst_hw_addr, 
+                                         const address_type& src_hw_addr) 
+: Dot11ManagementFrame(dst_hw_addr, src_hw_addr), body_() {
+    subtype(Dot11::AUTH);
 }
 
-Dot11Authentication::Dot11Authentication(const uint8_t *buffer, uint32_t total_sz) 
-: Dot11ManagementFrame(buffer, total_sz) 
-{
+Dot11Authentication::Dot11Authentication(const uint8_t* buffer, uint32_t total_sz) 
+: Dot11ManagementFrame(buffer, total_sz) {
     InputMemoryStream stream(buffer, total_sz);
     stream.skip(management_frame_size());
-    stream.read(_body);
+    stream.read(body_);
     parse_tagged_parameters(stream);
 }
 
 void Dot11Authentication::auth_algorithm(uint16_t new_auth_algorithm) {
-    this->_body.auth_algorithm = Endian::host_to_le(new_auth_algorithm);
+    body_.auth_algorithm = Endian::host_to_le(new_auth_algorithm);
 }
 
 void Dot11Authentication::auth_seq_number(uint16_t new_auth_seq_number) {
-    this->_body.auth_seq_number = Endian::host_to_le(new_auth_seq_number);
+    body_.auth_seq_number = Endian::host_to_le(new_auth_seq_number);
 }
 
 void Dot11Authentication::status_code(uint16_t new_status_code) {
-    this->_body.status_code = Endian::host_to_le(new_status_code);
+    body_.status_code = Endian::host_to_le(new_status_code);
 }
 
 uint32_t Dot11Authentication::header_size() const {
-    return Dot11ManagementFrame::header_size() + sizeof(_body);
+    return Dot11ManagementFrame::header_size() + sizeof(body_);
 }
 
 void Dot11Authentication::write_fixed_parameters(OutputMemoryStream& stream) {
-    stream.write(_body);
+    stream.write(body_);
 }
 
-/* Deauth */
+// Deauth
 
-Dot11Deauthentication::Dot11Deauthentication(const address_type &dst_hw_addr, 
-  const address_type &src_hw_addr) 
-: Dot11ManagementFrame(dst_hw_addr, src_hw_addr)
-{
-    this->subtype(Dot11::DEAUTH);
-    memset(&_body, 0, sizeof(_body));
+Dot11Deauthentication::Dot11Deauthentication(const address_type& dst_hw_addr, 
+                                             const address_type& src_hw_addr) 
+: Dot11ManagementFrame(dst_hw_addr, src_hw_addr), body_() {
+    subtype(Dot11::DEAUTH);
 }
 
-Dot11Deauthentication::Dot11Deauthentication(const uint8_t *buffer, uint32_t total_sz) 
+Dot11Deauthentication::Dot11Deauthentication(const uint8_t* buffer, uint32_t total_sz) 
 : Dot11ManagementFrame(buffer, total_sz) {
     InputMemoryStream stream(buffer, total_sz);
     stream.skip(management_frame_size());
-    stream.read(_body);
+    stream.read(body_);
     parse_tagged_parameters(stream);
 }
 
 void Dot11Deauthentication::reason_code(uint16_t new_reason_code) {
-    this->_body.reason_code = Endian::host_to_le(new_reason_code);
+    body_.reason_code = Endian::host_to_le(new_reason_code);
 }
 
 uint32_t Dot11Deauthentication::header_size() const {
-    return Dot11ManagementFrame::header_size() + sizeof(this->_body);
+    return Dot11ManagementFrame::header_size() + sizeof(body_);
 }
 
 void Dot11Deauthentication::write_fixed_parameters(OutputMemoryStream& stream) {
-    stream.write(_body);
+    stream.write(body_);
 }
-} // namespace Tins
+
+} // Tins
 
 #endif // HAVE_DOT11
diff --git a/src/dot11/dot11_base.cpp b/src/dot11/dot11_base.cpp
index 4d9b3e1..3acd5ad 100644
--- a/src/dot11/dot11_base.cpp
+++ b/src/dot11/dot11_base.cpp
@@ -59,24 +59,23 @@ using Tins::Memory::InputMemoryStream;
 using Tins::Memory::OutputMemoryStream;
 
 namespace Tins {
+
 const Dot11::address_type Dot11::BROADCAST = "ff:ff:ff:ff:ff:ff";
 
-Dot11::Dot11(const address_type &dst_hw_addr) 
-: _header(), _options_size(0)
-{
+Dot11::Dot11(const address_type& dst_hw_addr) 
+: header_(), options_size_(0) {
     addr1(dst_hw_addr);
 }
 
-Dot11::Dot11(const ieee80211_header *header_ptr) 
-{
+Dot11::Dot11(const dot11_header* header_ptr)
+: header_(), options_size_(0) {
 
 }
 
-Dot11::Dot11(const uint8_t *buffer, uint32_t total_sz) 
-: _options_size(0) 
-{
+Dot11::Dot11(const uint8_t* buffer, uint32_t total_sz) 
+: options_size_(0) {
     InputMemoryStream stream(buffer, total_sz);
-    stream.read(_header);
+    stream.read(header_);
 }
 
 void Dot11::parse_tagged_parameters(InputMemoryStream& stream) {
@@ -93,104 +92,104 @@ void Dot11::parse_tagged_parameters(InputMemoryStream& stream) {
     }
 }
 
-void Dot11::add_tagged_option(OptionTypes opt, uint8_t len, const uint8_t *val) {
+void Dot11::add_tagged_option(OptionTypes opt, uint8_t len, const uint8_t* val) {
     uint32_t opt_size = len + sizeof(uint8_t) * 2;
-    _options.push_back(option((uint8_t)opt, val, val + len));
-    _options_size += opt_size;
+    options_.push_back(option((uint8_t)opt, val, val + len));
+    options_size_ += opt_size;
 }
 
-void Dot11::internal_add_option(const option &opt) {
-    _options_size += static_cast<uint32_t>(opt.data_size() + sizeof(uint8_t) * 2);
+void Dot11::internal_add_option(const option& opt) {
+    options_size_ += static_cast<uint32_t>(opt.data_size() + sizeof(uint8_t) * 2);
 }
 
 bool Dot11::remove_option(OptionTypes type) {
     options_type::iterator iter = search_option_iterator(type);
-    if (iter == _options.end()) {
+    if (iter == options_.end()) {
         return false;
     }
-    _options_size -= static_cast<uint32_t>(iter->data_size() + sizeof(uint8_t) * 2);
-    _options.erase(iter);
+    options_size_ -= static_cast<uint32_t>(iter->data_size() + sizeof(uint8_t) * 2);
+    options_.erase(iter);
     return true;
 }
 
-void Dot11::add_option(const option &opt) {
+void Dot11::add_option(const option& opt) {
     internal_add_option(opt);
-    _options.push_back(opt);
+    options_.push_back(opt);
 }
 
-const Dot11::option *Dot11::search_option(OptionTypes type) const {
+const Dot11::option* Dot11::search_option(OptionTypes type) const {
     // Search for the iterator. If we found something, return it, otherwise return nullptr.
     options_type::const_iterator iter = search_option_iterator(type);
-    return (iter != _options.end()) ? &*iter : 0;
+    return (iter != options_.end()) ? &*iter : 0;
 }
 
 Dot11::options_type::const_iterator Dot11::search_option_iterator(OptionTypes type) const {
     Internals::option_type_equality_comparator<option> comparator(static_cast<uint8_t>(type));
-    return find_if(_options.begin(), _options.end(), comparator);
+    return find_if(options_.begin(), options_.end(), comparator);
 }
 
 Dot11::options_type::iterator Dot11::search_option_iterator(OptionTypes type) {
     Internals::option_type_equality_comparator<option> comparator(static_cast<uint8_t>(type));
-    return find_if(_options.begin(), _options.end(), comparator);
+    return find_if(options_.begin(), options_.end(), comparator);
 }
 
 void Dot11::protocol(small_uint<2> new_proto) {
-    this->_header.control.protocol = new_proto;
+    header_.control.protocol = new_proto;
 }
 
 void Dot11::type(small_uint<2> new_type) {
-    this->_header.control.type = new_type;
+    header_.control.type = new_type;
 }
 
 void Dot11::subtype(small_uint<4> new_subtype) {
-    this->_header.control.subtype = new_subtype;
+    header_.control.subtype = new_subtype;
 }
 
 void Dot11::to_ds(small_uint<1> new_value) {
-    this->_header.control.to_ds = (new_value)? 1 : 0;
+    header_.control.to_ds = (new_value)? 1 : 0;
 }
 
 void Dot11::from_ds(small_uint<1> new_value) {
-    this->_header.control.from_ds = (new_value)? 1 : 0;
+    header_.control.from_ds = (new_value)? 1 : 0;
 }
 
 void Dot11::more_frag(small_uint<1> new_value) {
-    this->_header.control.more_frag = (new_value)? 1 : 0;
+    header_.control.more_frag = (new_value)? 1 : 0;
 }
 
 void Dot11::retry(small_uint<1> new_value) {
-    this->_header.control.retry = (new_value)? 1 : 0;
+    header_.control.retry = (new_value)? 1 : 0;
 }
 
 void Dot11::power_mgmt(small_uint<1> new_value) {
-    this->_header.control.power_mgmt = (new_value)? 1 : 0;
+    header_.control.power_mgmt = (new_value)? 1 : 0;
 }
 
 void Dot11::wep(small_uint<1> new_value) {
-    this->_header.control.wep = (new_value)? 1 : 0;
+    header_.control.wep = (new_value)? 1 : 0;
 }
 
 void Dot11::order(small_uint<1> new_value) {
-    this->_header.control.order = (new_value)? 1 : 0;
+    header_.control.order = (new_value)? 1 : 0;
 }
 
 void Dot11::duration_id(uint16_t new_duration_id) {
-    this->_header.duration_id = Endian::host_to_le(new_duration_id);
+    header_.duration_id = Endian::host_to_le(new_duration_id);
 }
 
-void Dot11::addr1(const address_type &new_addr1) {
-    std::copy(new_addr1.begin(), new_addr1.end(), _header.addr1);
+void Dot11::addr1(const address_type& new_addr1) {
+    new_addr1.copy(header_.addr1);
 }
 
 uint32_t Dot11::header_size() const {
-    uint32_t sz = sizeof(ieee80211_header) + _options_size;
-    return sz;
+    return sizeof(header_) + options_size_;
 }
 
 #ifndef _WIN32
-void Dot11::send(PacketSender &sender, const NetworkInterface &iface) {
-    if(!iface)
+void Dot11::send(PacketSender& sender, const NetworkInterface& iface) {
+    if (!iface) {
         throw invalid_interface();
+    }
     
     #if !defined(BSD) && !defined(__FreeBSD_kernel__)
         sockaddr_ll addr;
@@ -201,7 +200,7 @@ void Dot11::send(PacketSender &sender, const NetworkInterface &iface) {
         addr.sll_protocol = Endian::host_to_be<uint16_t>(ETH_P_ALL);
         addr.sll_halen = 6;
         addr.sll_ifindex = iface.id();
-        memcpy(&(addr.sll_addr), _header.addr1, 6);
+        memcpy(&(addr.sll_addr), header_.addr1, 6);
         sender.send_l2(*this, (struct sockaddr*)&addr, (uint32_t)sizeof(addr));
     #else
         sender.send_l2(*this, 0, 0, iface);
@@ -209,74 +208,84 @@ void Dot11::send(PacketSender &sender, const NetworkInterface &iface) {
 }
 #endif // _WIN32
 
-void Dot11::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent) {
+void Dot11::write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent) {
     OutputMemoryStream stream(buffer, total_sz);
-    stream.write(_header);
+    stream.write(header_);
     write_ext_header(stream);
     write_fixed_parameters(stream);
-    for (std::list<option>::const_iterator it = _options.begin(); it != _options.end(); ++it) {
+    for (std::list<option>::const_iterator it = options_.begin(); it != options_.end(); ++it) {
         stream.write<uint8_t>(it->option());
         stream.write<uint8_t>(it->length_field());
         stream.write(it->data_ptr(), it->data_size());
     }
 }
 
-Dot11 *Dot11::from_bytes(const uint8_t *buffer, uint32_t total_sz) {
+Dot11* Dot11::from_bytes(const uint8_t* buffer, uint32_t total_sz) {
     // We only need the control field, the length of the PDU will depend on the flags set.
     
-    // This should be sizeof(ieee80211_header::control), but gcc 4.2 complains
-    if(total_sz < 2)
+    // This should be sizeof(dot11_header::control), but gcc 4.2 complains
+    if (total_sz < 2) {
         throw malformed_packet();
-    const ieee80211_header *hdr = (const ieee80211_header*)buffer;
-    Dot11 *ret = 0;
-    if(hdr->control.type == MANAGEMENT) {
-        if(hdr->control.subtype == BEACON)
-            ret = new Dot11Beacon(buffer, total_sz);
-        else if(hdr->control.subtype == DISASSOC)
-            ret = new Dot11Disassoc(buffer, total_sz);
-        else if(hdr->control.subtype == ASSOC_REQ)
-            ret = new Dot11AssocRequest(buffer, total_sz);
-        else if(hdr->control.subtype == ASSOC_RESP)
-            ret = new Dot11AssocResponse(buffer, total_sz);
-        else if(hdr->control.subtype == REASSOC_REQ)
-            ret = new Dot11ReAssocRequest(buffer, total_sz);
-        else if(hdr->control.subtype == REASSOC_RESP)
-            ret = new Dot11ReAssocResponse(buffer, total_sz); 
-        else if(hdr->control.subtype == AUTH)
-            ret = new Dot11Authentication(buffer, total_sz); 
-        else if(hdr->control.subtype == DEAUTH)
-            ret = new Dot11Deauthentication(buffer, total_sz); 
-        else if(hdr->control.subtype == PROBE_REQ)
-            ret = new Dot11ProbeRequest(buffer, total_sz); 
-        else if(hdr->control.subtype == PROBE_RESP)
-            ret = new Dot11ProbeResponse(buffer, total_sz); 
     }
-    else if(hdr->control.type == DATA){
-        if(hdr->control.subtype <= 4)
-            ret = new Dot11Data(buffer, total_sz);
-        else
-            ret = new Dot11QoSData(buffer, total_sz);
+    const dot11_header* hdr = (const dot11_header*)buffer;
+    if (hdr->control.type == MANAGEMENT) {
+        switch (hdr->control.subtype) {
+            case BEACON:
+                return new Dot11Beacon(buffer, total_sz);
+            case DISASSOC:
+                return new Dot11Disassoc(buffer, total_sz);
+            case ASSOC_REQ:
+                return new Dot11AssocRequest(buffer, total_sz);
+            case ASSOC_RESP:
+                return new Dot11AssocResponse(buffer, total_sz);
+            case REASSOC_REQ:
+                return new Dot11ReAssocRequest(buffer, total_sz);
+            case REASSOC_RESP:
+                return new Dot11ReAssocResponse(buffer, total_sz); 
+            case AUTH:
+                return new Dot11Authentication(buffer, total_sz); 
+            case DEAUTH:
+                return new Dot11Deauthentication(buffer, total_sz); 
+            case PROBE_REQ:
+                return new Dot11ProbeRequest(buffer, total_sz); 
+            case PROBE_RESP:
+                return new Dot11ProbeResponse(buffer, total_sz); 
+            default: 
+                break;
+        };
     }
-    else if(hdr->control.type == CONTROL){
-        if(hdr->control.subtype == ACK)
-            ret = new Dot11Ack(buffer, total_sz);
-        else if(hdr->control.subtype == CF_END)
-            ret = new Dot11CFEnd(buffer, total_sz);
-        else if(hdr->control.subtype == CF_END_ACK)
-            ret = new Dot11EndCFAck(buffer, total_sz);
-        else if(hdr->control.subtype == PS)
-            ret = new Dot11PSPoll(buffer, total_sz);
-        else if(hdr->control.subtype == RTS)
-            ret = new Dot11RTS(buffer, total_sz);
-        else if(hdr->control.subtype == BLOCK_ACK)
-            ret = new Dot11BlockAck(buffer, total_sz);
-        else if(hdr->control.subtype == BLOCK_ACK_REQ)
-            ret = new Dot11BlockAckRequest(buffer, total_sz);
+    else if (hdr->control.type == DATA) {
+        if (hdr->control.subtype <= 4) {
+            return new Dot11Data(buffer, total_sz);
+        }
+        else {
+            return new Dot11QoSData(buffer, total_sz);
+        }
     }
-    if(ret == 0)
-        ret = new Dot11(buffer, total_sz);
-    return ret;
+    else if (hdr->control.type == CONTROL) {
+        switch (hdr->control.subtype) {
+            case ACK:
+                return new Dot11Ack(buffer, total_sz);
+            case CF_END:
+                return new Dot11CFEnd(buffer, total_sz);
+            case CF_END_ACK:
+                return new Dot11EndCFAck(buffer, total_sz);
+            case PS:
+                return new Dot11PSPoll(buffer, total_sz);
+            case RTS:
+                return new Dot11RTS(buffer, total_sz);
+            case BLOCK_ACK:
+                return new Dot11BlockAck(buffer, total_sz);
+            case BLOCK_ACK_REQ:
+                return new Dot11BlockAckRequest(buffer, total_sz);
+            default:
+                break;
+        };
+    }
+    // Fallback to just building a dot11
+    return new Dot11(buffer, total_sz);
 }
-} // namespace Tins
+
+} // Tins
 
 #endif // HAVE_DOT11
diff --git a/src/dot11/dot11_beacon.cpp b/src/dot11/dot11_beacon.cpp
index a3e70b9..ae81a88 100644
--- a/src/dot11/dot11_beacon.cpp
+++ b/src/dot11/dot11_beacon.cpp
@@ -37,40 +37,39 @@ using Tins::Memory::InputMemoryStream;
 using Tins::Memory::OutputMemoryStream;
 
 namespace Tins {
- /* Dot11Beacon */
 
-Dot11Beacon::Dot11Beacon(const address_type &dst_hw_addr, 
-const address_type &src_hw_addr) 
-: Dot11ManagementFrame(dst_hw_addr, src_hw_addr)
-{
+// Dot11Beacon
+
+Dot11Beacon::Dot11Beacon(const address_type& dst_hw_addr, 
+const address_type& src_hw_addr) 
+: Dot11ManagementFrame(dst_hw_addr, src_hw_addr), body_() {
     subtype(Dot11::BEACON);
-    std::memset(&_body, 0, sizeof(_body));
 }
 
-Dot11Beacon::Dot11Beacon(const uint8_t *buffer, uint32_t total_sz) 
-: Dot11ManagementFrame(buffer, total_sz) 
-{
+Dot11Beacon::Dot11Beacon(const uint8_t* buffer, uint32_t total_sz) 
+: Dot11ManagementFrame(buffer, total_sz) {
     InputMemoryStream stream(buffer, total_sz);
     stream.skip(management_frame_size());
-    stream.read(_body);
+    stream.read(body_);
     parse_tagged_parameters(stream);
 }
 
 void Dot11Beacon::timestamp(uint64_t new_timestamp) {
-    this->_body.timestamp = Endian::host_to_le(new_timestamp);
+    body_.timestamp = Endian::host_to_le(new_timestamp);
 }
 
 void Dot11Beacon::interval(uint16_t new_interval) {
-    this->_body.interval = Endian::host_to_le(new_interval);
+    body_.interval = Endian::host_to_le(new_interval);
 }
 
 uint32_t Dot11Beacon::header_size() const {
-    return Dot11ManagementFrame::header_size() + sizeof(_body);
+    return Dot11ManagementFrame::header_size() + sizeof(body_);
 }
 
 void Dot11Beacon::write_fixed_parameters(OutputMemoryStream& stream) {
-    stream.write(_body);
+    stream.write(body_);
 }
-} // namespace Tins
+
+} // Tins
 
 #endif // HAVE_DOT11
diff --git a/src/dot11/dot11_control.cpp b/src/dot11/dot11_control.cpp
index bfa4b0a..e9cadee 100644
--- a/src/dot11/dot11_control.cpp
+++ b/src/dot11/dot11_control.cpp
@@ -30,237 +30,225 @@
 #include "dot11/dot11_control.h"
 #ifdef HAVE_DOT11
 
-#include <cstring>
+#include <algorithm>
 #include "memory_helpers.h"
 
+using std::copy;
+
 using Tins::Memory::InputMemoryStream;
 using Tins::Memory::OutputMemoryStream;
 
 namespace Tins {
- /* Dot11Control */
 
-Dot11Control::Dot11Control(const address_type &dst_addr) 
-: Dot11(dst_addr) 
-{
+// Dot11Control
+
+Dot11Control::Dot11Control(const address_type& dst_addr) 
+: Dot11(dst_addr) {
     type(CONTROL);
 }
 
-Dot11Control::Dot11Control(const uint8_t *buffer, uint32_t total_sz) 
+Dot11Control::Dot11Control(const uint8_t* buffer, uint32_t total_sz) 
 : Dot11(buffer, total_sz) {
 
 }
 
-/* Dot11ControlTA */
+// Dot11ControlTA
 
-Dot11ControlTA::Dot11ControlTA(const address_type &dst_addr, 
-  const address_type &target_address) 
-: Dot11Control(dst_addr)
-{
+Dot11ControlTA::Dot11ControlTA(const address_type& dst_addr, 
+                               const address_type& target_address) 
+: Dot11Control(dst_addr) {
     target_addr(target_address);
 }
 
-Dot11ControlTA::Dot11ControlTA(const uint8_t *buffer, uint32_t total_sz) : Dot11Control(buffer, total_sz) {
+Dot11ControlTA::Dot11ControlTA(const uint8_t* buffer, uint32_t total_sz) : Dot11Control(buffer, total_sz) {
     InputMemoryStream stream(buffer, total_sz);
-    stream.skip(sizeof(ieee80211_header));
-    stream.read(_taddr);
+    stream.skip(sizeof(dot11_header));
+    stream.read(taddr_);
 }
 
 uint32_t Dot11ControlTA::header_size() const {
-    return Dot11::header_size() + sizeof(_taddr);
+    return Dot11::header_size() + taddr_.size();
 }
 
 void Dot11ControlTA::write_ext_header(OutputMemoryStream& stream) {
-    stream.write(_taddr);
+    stream.write(taddr_);
 }
 
-void Dot11ControlTA::target_addr(const address_type &addr) {
-    _taddr = addr;
+void Dot11ControlTA::target_addr(const address_type& addr) {
+    taddr_ = addr;
 }
 
-/* Dot11RTS */
+// Dot11RTS
 
-Dot11RTS::Dot11RTS(const address_type &dst_addr, 
-  const address_type &target_addr) 
-: Dot11ControlTA(dst_addr, target_addr) 
-{
+Dot11RTS::Dot11RTS(const address_type& dst_addr, 
+                   const address_type& target_addr) 
+: Dot11ControlTA(dst_addr, target_addr) {
     subtype(RTS);
 }
 
-Dot11RTS::Dot11RTS(const uint8_t *buffer, uint32_t total_sz) 
+Dot11RTS::Dot11RTS(const uint8_t* buffer, uint32_t total_sz) 
 : Dot11ControlTA(buffer, total_sz) {
 
 }
 
-/* Dot11PSPoll */
+// Dot11PSPoll
 
-Dot11PSPoll::Dot11PSPoll(const address_type &dst_addr, 
-  const address_type &target_addr) 
-: Dot11ControlTA(dst_addr, target_addr) 
-{
+Dot11PSPoll::Dot11PSPoll(const address_type& dst_addr, 
+                         const address_type& target_addr) 
+: Dot11ControlTA(dst_addr, target_addr) {
     subtype(PS);
 }
 
-Dot11PSPoll::Dot11PSPoll(const uint8_t *buffer, uint32_t total_sz) 
+Dot11PSPoll::Dot11PSPoll(const uint8_t* buffer, uint32_t total_sz) 
 : Dot11ControlTA(buffer, total_sz) {
 
 }
 
-/* Dot11CFEnd */
+// Dot11CFEnd
 
-Dot11CFEnd::Dot11CFEnd(const address_type &dst_addr, 
-  const address_type &target_addr) 
-: Dot11ControlTA(dst_addr, target_addr) 
-{
+Dot11CFEnd::Dot11CFEnd(const address_type& dst_addr, 
+                       const address_type& target_addr) 
+: Dot11ControlTA(dst_addr, target_addr) {
     subtype(CF_END);
 }
 
-Dot11CFEnd::Dot11CFEnd(const uint8_t *buffer, uint32_t total_sz) 
+Dot11CFEnd::Dot11CFEnd(const uint8_t* buffer, uint32_t total_sz) 
 : Dot11ControlTA(buffer, total_sz) {
 
 }
 
-/* Dot11EndCFAck */
+// Dot11EndCFAck
 
-Dot11EndCFAck::Dot11EndCFAck(const address_type &dst_addr, 
-  const address_type &target_addr) 
-: Dot11ControlTA(dst_addr, target_addr) 
-{
+Dot11EndCFAck::Dot11EndCFAck(const address_type& dst_addr, 
+                             const address_type& target_addr) 
+: Dot11ControlTA(dst_addr, target_addr) {
     subtype(CF_END_ACK);
 }
 
-Dot11EndCFAck::Dot11EndCFAck(const uint8_t *buffer, uint32_t total_sz) 
+Dot11EndCFAck::Dot11EndCFAck(const uint8_t* buffer, uint32_t total_sz) 
 : Dot11ControlTA(buffer, total_sz) {
 
 }
 
-/* Dot11Ack */
+// Dot11Ack
 
-Dot11Ack::Dot11Ack(const address_type &dst_addr) 
-: Dot11Control(dst_addr) 
-{
+Dot11Ack::Dot11Ack(const address_type& dst_addr) 
+: Dot11Control(dst_addr) {
     subtype(ACK);
 }
 
-Dot11Ack::Dot11Ack(const uint8_t *buffer, uint32_t total_sz) 
-: Dot11Control(buffer, total_sz)
-{
+Dot11Ack::Dot11Ack(const uint8_t* buffer, uint32_t total_sz) 
+: Dot11Control(buffer, total_sz) {
 
 }
 
-/* Dot11BlockAck */
+// Dot11BlockAck
 
-Dot11BlockAckRequest::Dot11BlockAckRequest(const address_type &dst_addr, 
-  const address_type &target_addr)
-: Dot11ControlTA(dst_addr, target_addr) 
-{
-    init_block_ack();
+Dot11BlockAckRequest::Dot11BlockAckRequest(const address_type& dst_addr, 
+                                           const address_type& target_addr)
+: Dot11ControlTA(dst_addr, target_addr), bar_control_(0), start_sequence_(0) {
+    subtype(BLOCK_ACK_REQ);
 }
 
-Dot11BlockAckRequest::Dot11BlockAckRequest(const uint8_t *buffer, uint32_t total_sz) 
-: Dot11ControlTA(buffer, total_sz) 
-{
+Dot11BlockAckRequest::Dot11BlockAckRequest(const uint8_t* buffer, uint32_t total_sz) 
+: Dot11ControlTA(buffer, total_sz) {
     InputMemoryStream stream(buffer, total_sz);
     stream.skip(controlta_size());
-    stream.read(_bar_control);
-    stream.read(_start_sequence);
-}
-
-void Dot11BlockAckRequest::init_block_ack() {
-    subtype(BLOCK_ACK_REQ);
-    std::memset(&_bar_control, 0, sizeof(_bar_control));
-    std::memset(&_start_sequence, 0, sizeof(_start_sequence));
+    stream.read(bar_control_);
+    stream.read(start_sequence_);
 }
 
 void Dot11BlockAckRequest::write_ext_header(OutputMemoryStream& stream) {
     Dot11ControlTA::write_ext_header(stream);
-    stream.write(_bar_control);
-    stream.write(_start_sequence);
+    stream.write(bar_control_);
+    stream.write(start_sequence_);
 }
 
 void Dot11BlockAckRequest::bar_control(small_uint<4> bar) {
     #if TINS_IS_LITTLE_ENDIAN
-    _bar_control = bar | (_bar_control & 0xfff0);
+    bar_control_ = bar | (bar_control_ & 0xfff0);
     #else
-    _bar_control = (bar << 8) | (_bar_control & 0xf0ff);
+    bar_control_ = (bar << 8) | (bar_control_ & 0xf0ff);
     #endif
 }
 
 void Dot11BlockAckRequest::start_sequence(small_uint<12> seq) {
     #if TINS_IS_LITTLE_ENDIAN
-    _start_sequence = (seq << 4) | (_start_sequence & 0xf);
+    start_sequence_ = (seq << 4) | (start_sequence_ & 0xf);
     #else
-    _start_sequence = Endian::host_to_le<uint16_t>(seq << 4) | (_start_sequence & 0xf00);
+    start_sequence_ = Endian::host_to_le<uint16_t>(seq << 4) | (start_sequence_ & 0xf00);
     #endif
 }
 
 void Dot11BlockAckRequest::fragment_number(small_uint<4> frag) {
     #if TINS_IS_LITTLE_ENDIAN
-    _start_sequence = frag | (_start_sequence & 0xfff0);
+    start_sequence_ = frag | (start_sequence_ & 0xfff0);
     #else
-    _start_sequence = (frag << 8) | (_start_sequence & 0xf0ff);
+    start_sequence_ = (frag << 8) | (start_sequence_ & 0xf0ff);
     #endif
 }
 
 uint32_t Dot11BlockAckRequest::header_size() const {
-    return Dot11ControlTA::header_size() + sizeof(_start_sequence) + sizeof(_start_sequence);
+    return Dot11ControlTA::header_size() + sizeof(start_sequence_) + sizeof(start_sequence_);
 }
 
-/* Dot11BlockAck */
+// Dot11BlockAck
 
-Dot11BlockAck::Dot11BlockAck(const address_type &dst_addr, 
-  const address_type &target_addr)
-: Dot11ControlTA(dst_addr, target_addr) 
-{
+Dot11BlockAck::Dot11BlockAck(const address_type& dst_addr, 
+                             const address_type& target_addr)
+: Dot11ControlTA(dst_addr, target_addr), bitmap_() {
     subtype(BLOCK_ACK);
-    std::memset(_bitmap, 0, sizeof(_bitmap));
 }
 
-Dot11BlockAck::Dot11BlockAck(const uint8_t *buffer, uint32_t total_sz) : Dot11ControlTA(buffer, total_sz) {
+Dot11BlockAck::Dot11BlockAck(const uint8_t* buffer, uint32_t total_sz) 
+: Dot11ControlTA(buffer, total_sz) {
     InputMemoryStream stream(buffer, total_sz);
     stream.skip(controlta_size());
-    stream.read(_bar_control);
-    stream.read(_start_sequence);
-    stream.read(_bitmap);
+    stream.read(bar_control_);
+    stream.read(start_sequence_);
+    stream.read(bitmap_);
 }
 
 void Dot11BlockAck::bar_control(small_uint<4> bar) {
     #if TINS_IS_LITTLE_ENDIAN
-    _bar_control = bar | (_bar_control & 0xfff0);
+    bar_control_ = bar | (bar_control_ & 0xfff0);
     #else
-    _bar_control = (bar << 8) | (_bar_control & 0xf0ff);
+    bar_control_ = (bar << 8) | (bar_control_ & 0xf0ff);
     #endif
 }
 
 void Dot11BlockAck::start_sequence(small_uint<12> seq) {
     #if TINS_IS_LITTLE_ENDIAN
-    _start_sequence = (seq << 4) | (_start_sequence & 0xf);
+    start_sequence_ = (seq << 4) | (start_sequence_ & 0xf);
     #else
-    _start_sequence = Endian::host_to_le<uint16_t>(seq << 4) | (_start_sequence & 0xf00);
+    start_sequence_ = Endian::host_to_le<uint16_t>(seq << 4) | (start_sequence_ & 0xf00);
     #endif
 }
 
 void Dot11BlockAck::fragment_number(small_uint<4> frag) {
     #if TINS_IS_LITTLE_ENDIAN
-    _start_sequence = frag | (_start_sequence & 0xfff0);
+    start_sequence_ = frag | (start_sequence_ & 0xfff0);
     #else
-    _start_sequence = (frag << 8) | (_start_sequence & 0xf0ff);
+    start_sequence_ = (frag << 8) | (start_sequence_ & 0xf0ff);
     #endif
 }
 
-void Dot11BlockAck::bitmap(const uint8_t *bit) {
-    std::memcpy(_bitmap, bit, sizeof(_bitmap));
+void Dot11BlockAck::bitmap(const uint8_t* bit) {
+    copy(bit, bit + bitmap_size, bitmap_);
 }
 
 void Dot11BlockAck::write_ext_header(OutputMemoryStream& stream) {
     Dot11ControlTA::write_ext_header(stream);
-    stream.write(_bar_control);
-    stream.write(_start_sequence);
-    stream.write(_bitmap);
+    stream.write(bar_control_);
+    stream.write(start_sequence_);
+    stream.write(bitmap_);
 }
 
 uint32_t Dot11BlockAck::header_size() const {
-    return Dot11ControlTA::header_size() + sizeof(_start_sequence) + sizeof(_start_sequence) + sizeof(_bitmap);
+    return Dot11ControlTA::header_size() + sizeof(start_sequence_) + 
+           sizeof(start_sequence_) + sizeof(bitmap_);
 }
-} // namespace Tins
+
+} // Tins
 
 #endif // HAVE_DOT11
diff --git a/src/dot11/dot11_data.cpp b/src/dot11/dot11_data.cpp
index 12d7646..858ab79 100644
--- a/src/dot11/dot11_data.cpp
+++ b/src/dot11/dot11_data.cpp
@@ -39,17 +39,17 @@ using Tins::Memory::InputMemoryStream;
 using Tins::Memory::OutputMemoryStream;
 
 namespace Tins {
-/* Dot11Data */
 
-Dot11Data::Dot11Data(const uint8_t *buffer, uint32_t total_sz) 
-: Dot11(buffer, total_sz)
-{
+// Dot11Data
+
+Dot11Data::Dot11Data(const uint8_t* buffer, uint32_t total_sz) 
+: Dot11(buffer, total_sz) {
     const uint32_t offset = init(buffer, total_sz);
     InputMemoryStream stream(buffer, total_sz);
     stream.skip(offset);
     if (stream) {
         // If the wep bit is on, then just use a RawPDU
-        if(wep()) {
+        if (wep()) {
             inner_pdu(new Tins::RawPDU(stream.pointer(), stream.size()));
         }
         else {
@@ -58,89 +58,84 @@ Dot11Data::Dot11Data(const uint8_t *buffer, uint32_t total_sz)
     }
 }
 
-Dot11Data::Dot11Data(const uint8_t *buffer, uint32_t total_sz, no_inner_pdu) 
-: Dot11(buffer, total_sz)
-{
+Dot11Data::Dot11Data(const uint8_t* buffer, uint32_t total_sz, no_inner_pdu) 
+: Dot11(buffer, total_sz) {
     init(buffer, total_sz);
 }
 
-uint32_t Dot11Data::init(const uint8_t *buffer, uint32_t total_sz) {
+uint32_t Dot11Data::init(const uint8_t* buffer, uint32_t total_sz) {
     InputMemoryStream stream(buffer, total_sz);
     stream.skip(Dot11::header_size());
-    stream.read(_ext_header);
+    stream.read(ext_header_);
     if (from_ds() && to_ds()) {
-        stream.read(_addr4);
+        stream.read(addr4_);
     }
     return total_sz - stream.size();
 }
 
-Dot11Data::Dot11Data(const address_type &dst_hw_addr, 
-  const address_type &src_hw_addr) 
-: Dot11(dst_hw_addr) 
-{
+Dot11Data::Dot11Data(const address_type& dst_hw_addr, 
+                     const address_type& src_hw_addr) 
+: Dot11(dst_hw_addr), ext_header_() {
     type(Dot11::DATA);
-    memset(&_ext_header, 0, sizeof(_ext_header));
     addr2(src_hw_addr);
 }
 
 uint32_t Dot11Data::header_size() const {
-    uint32_t sz = Dot11::header_size() + sizeof(_ext_header);
-    if (this->from_ds() && this->to_ds())
+    uint32_t sz = Dot11::header_size() + sizeof(ext_header_);
+    if (this->from_ds() && this->to_ds()) {
         sz += 6;
+    }
     return sz;
 }
 
-void Dot11Data::addr2(const address_type &new_addr2) {
-    std::copy(new_addr2.begin(), new_addr2.end(), _ext_header.addr2);
+void Dot11Data::addr2(const address_type& new_addr2) {
+    new_addr2.copy(ext_header_.addr2);
 }
 
-void Dot11Data::addr3(const address_type &new_addr3) {
-    std::copy(new_addr3.begin(), new_addr3.end(), _ext_header.addr3);
+void Dot11Data::addr3(const address_type& new_addr3) {
+    new_addr3.copy(ext_header_.addr3);
 }
 
 void Dot11Data::frag_num(small_uint<4> new_frag_num) {
     #if TINS_IS_LITTLE_ENDIAN
-    _ext_header.frag_seq = new_frag_num | (_ext_header.frag_seq & 0xfff0);
+    ext_header_.frag_seq = new_frag_num | (ext_header_.frag_seq & 0xfff0);
     #else
-    _ext_header.frag_seq = (new_frag_num << 8) | (_ext_header.frag_seq & 0xf0ff);
+    ext_header_.frag_seq = (new_frag_num << 8) | (ext_header_.frag_seq & 0xf0ff);
     #endif
 }
 
 void Dot11Data::seq_num(small_uint<12> new_seq_num) {
     #if TINS_IS_LITTLE_ENDIAN
-    _ext_header.frag_seq = (new_seq_num << 4) | (_ext_header.frag_seq & 0xf);
+    ext_header_.frag_seq = (new_seq_num << 4) | (ext_header_.frag_seq & 0xf);
     #else
-    _ext_header.frag_seq = Endian::host_to_le<uint16_t>(new_seq_num << 4) | (_ext_header.frag_seq & 0xf00);
+    ext_header_.frag_seq = Endian::host_to_le<uint16_t>(new_seq_num << 4) | (ext_header_.frag_seq & 0xf00);
     #endif
 }
 
-void Dot11Data::addr4(const address_type &new_addr4) {
-    _addr4 = new_addr4;
+void Dot11Data::addr4(const address_type& new_addr4) {
+    addr4_ = new_addr4;
 }
 
 void Dot11Data::write_ext_header(OutputMemoryStream& stream) {
-    stream.write(_ext_header);
+    stream.write(ext_header_);
     if (from_ds() && to_ds()) {
-        stream.write(_addr4);
+        stream.write(addr4_);
     }
 }
 
-/* QoS data. */
+// QoS data
 
-Dot11QoSData::Dot11QoSData(const address_type &dst_hw_addr, 
-  const address_type &src_hw_addr) 
-: Dot11Data(dst_hw_addr, src_hw_addr) 
-{
+Dot11QoSData::Dot11QoSData(const address_type& dst_hw_addr, 
+                           const address_type& src_hw_addr) 
+: Dot11Data(dst_hw_addr, src_hw_addr), qos_control_() {
     subtype(Dot11::QOS_DATA_DATA);
-    _qos_control = 0;
 }
 
-Dot11QoSData::Dot11QoSData(const uint8_t *buffer, uint32_t total_sz) 
-// Am I breaking something? :S
+Dot11QoSData::Dot11QoSData(const uint8_t* buffer, uint32_t total_sz) 
 : Dot11Data(buffer, total_sz, no_inner_pdu()) {
     InputMemoryStream stream(buffer, total_sz);
-    stream.skip(data_frame_size());
-    stream.read(_qos_control);
+    stream.skip(Dot11Data::header_size());
+    stream.read(qos_control_);
     if (total_sz) {
         // If the wep bit is on, then just use a RawPDU
         if (wep()) {
@@ -153,16 +148,17 @@ Dot11QoSData::Dot11QoSData(const uint8_t *buffer, uint32_t total_sz)
 }
 
 void Dot11QoSData::qos_control(uint16_t new_qos_control) {
-    this->_qos_control = Endian::host_to_le(new_qos_control);
+    qos_control_ = Endian::host_to_le(new_qos_control);
 }
 
 uint32_t Dot11QoSData::header_size() const {
-    return Dot11Data::header_size() + sizeof(this->_qos_control);
+    return Dot11Data::header_size() + sizeof(qos_control_);
 }
 
 void Dot11QoSData::write_fixed_parameters(OutputMemoryStream& stream) {
-    stream.write(_qos_control);
+    stream.write(qos_control_);
 }
-} // namespace Tins
+
+} // Tins
 
 #endif // HAVE_DOT11
diff --git a/src/dot11/dot11_mgmt.cpp b/src/dot11/dot11_mgmt.cpp
index e0d7f17..cfc82f4 100644
--- a/src/dot11/dot11_mgmt.cpp
+++ b/src/dot11/dot11_mgmt.cpp
@@ -34,76 +34,88 @@
 #include "rsn_information.h"
 #include "memory_helpers.h"
 
+using std::string;
+using std::copy;
+using std::vector;
+using std::back_inserter;
+using std::runtime_error;
+using std::pair;
+using std::make_pair;
+
 using Tins::Memory::InputMemoryStream;
 using Tins::Memory::OutputMemoryStream;
 
 namespace Tins {
-/* Dot11ManagementFrame */
 
-Dot11ManagementFrame::Dot11ManagementFrame(const uint8_t *buffer, uint32_t total_sz) 
-: Dot11(buffer, total_sz) 
-{
+// Dot11ManagementFrame
+
+Dot11ManagementFrame::Dot11ManagementFrame(const uint8_t* buffer, uint32_t total_sz) 
+: Dot11(buffer, total_sz) {
     InputMemoryStream stream(buffer, total_sz);
-    stream.skip(sizeof(ieee80211_header));
-    stream.read(_ext_header);
+    stream.skip(sizeof(dot11_header));
+    stream.read(ext_header_);
     if (from_ds() && to_ds()) {
-        stream.read(_addr4);
+        stream.read(addr4_);
     }
 }
 
-Dot11ManagementFrame::Dot11ManagementFrame(const address_type &dst_hw_addr, 
-const address_type &src_hw_addr) 
-: Dot11(dst_hw_addr), _ext_header()
-{
+Dot11ManagementFrame::Dot11ManagementFrame(const address_type& dst_hw_addr, 
+                                           const address_type& src_hw_addr) 
+: Dot11(dst_hw_addr), ext_header_() {
     type(Dot11::MANAGEMENT);
     addr2(src_hw_addr);
 }
 
 uint32_t Dot11ManagementFrame::header_size() const {
-    uint32_t sz = Dot11::header_size() + sizeof(_ext_header);
-    if (this->from_ds() && this->to_ds()) {
+    uint32_t sz = Dot11::header_size() + sizeof(ext_header_);
+    if (from_ds() && to_ds()) {
         sz += 6;
     }
     return sz;
 }
 
-void Dot11ManagementFrame::addr2(const address_type &new_addr2) {
-    std::copy(new_addr2.begin(), new_addr2.end(), _ext_header.addr2);
+void Dot11ManagementFrame::addr2(const address_type& new_addr2) {
+    new_addr2.copy(ext_header_.addr2);
 }
 
-void Dot11ManagementFrame::addr3(const address_type &new_addr3) {
-    std::copy(new_addr3.begin(), new_addr3.end(), _ext_header.addr3);
+void Dot11ManagementFrame::addr3(const address_type& new_addr3) {
+    new_addr3.copy(ext_header_.addr3);
 }
 
 void Dot11ManagementFrame::frag_num(small_uint<4> new_frag_num) {
     #if TINS_IS_LITTLE_ENDIAN
-    _ext_header.frag_seq = new_frag_num | (_ext_header.frag_seq & 0xfff0);
+    ext_header_.frag_seq = new_frag_num | (ext_header_.frag_seq & 0xfff0);
     #else
-    _ext_header.frag_seq = (new_frag_num << 8) | (_ext_header.frag_seq & 0xf0ff);
+    ext_header_.frag_seq = (new_frag_num << 8) | (ext_header_.frag_seq & 0xf0ff);
     #endif
 }
 
 void Dot11ManagementFrame::seq_num(small_uint<12> new_seq_num) {
     #if TINS_IS_LITTLE_ENDIAN
-    _ext_header.frag_seq = (new_seq_num << 4) | (_ext_header.frag_seq & 0xf);
+    ext_header_.frag_seq = (new_seq_num << 4) | (ext_header_.frag_seq & 0xf);
     #else
-    _ext_header.frag_seq = Endian::host_to_le<uint16_t>(new_seq_num << 4) | (_ext_header.frag_seq & 0xf00);
+    ext_header_.frag_seq = Endian::host_to_le<uint16_t>(new_seq_num << 4) | 
+                           (ext_header_.frag_seq & 0xf00);
     #endif
 }
 
-void Dot11ManagementFrame::addr4(const address_type &new_addr4) {
-    _addr4 = new_addr4;
+void Dot11ManagementFrame::addr4(const address_type& new_addr4) {
+    addr4_ = new_addr4;
 }
 
 void Dot11ManagementFrame::write_ext_header(OutputMemoryStream& stream) {
-    stream.write(_ext_header);
+    stream.write(ext_header_);
     if (from_ds() && to_ds()) {
-        stream.write(_addr4);
+        stream.write(addr4_);
     }
 }
 
-void Dot11ManagementFrame::ssid(const std::string &new_ssid) {
-    add_tagged_option(Dot11::SSID, static_cast<uint8_t>(new_ssid.size()), (const uint8_t*)new_ssid.c_str());
+void Dot11ManagementFrame::ssid(const string& new_ssid) {
+    add_tagged_option(
+        Dot11::SSID, 
+        static_cast<uint8_t>(new_ssid.size()),
+        (const uint8_t*)new_ssid.c_str()
+    );
 }
 
 void Dot11ManagementFrame::rsn_information(const RSNInformation& info) {
@@ -111,36 +123,36 @@ void Dot11ManagementFrame::rsn_information(const RSNInformation& info) {
     add_tagged_option(RSN, static_cast<uint8_t>(buffer.size()), &buffer[0]);
 }
 
-uint8_t *Dot11ManagementFrame::serialize_rates(const rates_type &rates) {
-    uint8_t *buffer = new uint8_t[rates.size()], *ptr = buffer;
-    for(rates_type::const_iterator it = rates.begin(); it != rates.end(); ++it) {
+vector<uint8_t> Dot11ManagementFrame::serialize_rates(const rates_type& rates) {
+    vector<uint8_t> buffer(rates.size());
+    uint8_t* ptr = &buffer[0];
+    for (rates_type::const_iterator it = rates.begin(); it != rates.end(); ++it) {
         uint8_t result = static_cast<uint8_t>(*it * 2);
-        if(result == 2 || result == 4 || result == 11 || result == 22)
+        if (result == 2 || result == 4 || result == 11 || result == 22) {
             result |= 0x80;
+        }
         *(ptr++) = result;
     }
     return buffer;
 }
 
-Dot11ManagementFrame::rates_type Dot11ManagementFrame::deserialize_rates(const option *opt) {
+Dot11ManagementFrame::rates_type Dot11ManagementFrame::deserialize_rates(const option* opt) {
     rates_type output;
-    const uint8_t *ptr = opt->data_ptr(), *end = ptr + opt->data_size();
-    while(ptr != end) {
+    const uint8_t* ptr = opt->data_ptr(), *end = ptr + opt->data_size();
+    while (ptr != end) {
         output.push_back(float(*(ptr++) & 0x7f) / 2);
     }
     return output;
 }
 
-void Dot11ManagementFrame::supported_rates(const rates_type &new_rates) {
-    uint8_t *buffer = serialize_rates(new_rates);
-    add_tagged_option(SUPPORTED_RATES, static_cast<uint8_t>(new_rates.size()), buffer);
-    delete[] buffer;
+void Dot11ManagementFrame::supported_rates(const rates_type& new_rates) {
+    vector<uint8_t> buffer = serialize_rates(new_rates);
+    add_tagged_option(SUPPORTED_RATES, static_cast<uint8_t>(buffer.size()), &buffer[0]);
 }
 
-void Dot11ManagementFrame::extended_supported_rates(const rates_type &new_rates) {
-    uint8_t *buffer = serialize_rates(new_rates);
-    add_tagged_option(EXT_SUPPORTED_RATES, static_cast<uint8_t>(new_rates.size()), buffer);
-    delete[] buffer;
+void Dot11ManagementFrame::extended_supported_rates(const rates_type& new_rates) {
+    vector<uint8_t> buffer = serialize_rates(new_rates);
+    add_tagged_option(EXT_SUPPORTED_RATES, static_cast<uint8_t>(buffer.size()), &buffer[0]);
 }
 
 void Dot11ManagementFrame::qos_capability(qos_capability_type new_qos_capability) {
@@ -154,10 +166,10 @@ void Dot11ManagementFrame::power_capability(uint8_t min_power, uint8_t max_power
     add_tagged_option(POWER_CAPABILITY, 2, buffer);
 }
 
-void Dot11ManagementFrame::supported_channels(const channels_type &new_channels) {
-    std::vector<uint8_t> buffer(new_channels.size() * 2);
+void Dot11ManagementFrame::supported_channels(const channels_type& new_channels) {
+    vector<uint8_t> buffer(new_channels.size() * 2);
     uint8_t* ptr = &buffer[0];
-    for(channels_type::const_iterator it = new_channels.begin(); it != new_channels.end(); ++it) {
+    for (channels_type::const_iterator it = new_channels.begin(); it != new_channels.end(); ++it) {
         *(ptr++) = it->first;
         *(ptr++) = it->second;
     }
@@ -166,13 +178,13 @@ void Dot11ManagementFrame::supported_channels(const channels_type &new_channels)
 
 void Dot11ManagementFrame::edca_parameter_set(uint32_t ac_be, uint32_t ac_bk, uint32_t ac_vi, uint32_t ac_vo) {
     uint8_t buffer[18];
-    buffer[0] = 0;
-    buffer[1] = 0;
-    uint32_t* ptr = (uint32_t*)(buffer + 2);
-    *(ptr++) = Endian::host_to_le(ac_be);
-    *(ptr++) = Endian::host_to_le(ac_bk);
-    *(ptr++) = Endian::host_to_le(ac_vi);
-    *(ptr++) = Endian::host_to_le(ac_vo);
+    OutputMemoryStream stream(buffer, sizeof(buffer));
+    stream.write<uint8_t>(0);
+    stream.write<uint8_t>(0);
+    stream.write_le(ac_be);
+    stream.write_le(ac_bk);
+    stream.write_le(ac_vi);
+    stream.write_le(ac_vo);
     add_tagged_option(EDCA, sizeof(buffer), buffer);
 }
 
@@ -180,30 +192,28 @@ void Dot11ManagementFrame::request_information(const request_info_type elements)
     add_tagged_option(REQUEST_INFORMATION, static_cast<uint8_t>(elements.size()), &elements[0]);
 }
 
-void Dot11ManagementFrame::fh_parameter_set(const fh_params_set &fh_params) {
-    uint8_t data[5];
-    uint16_t dwell = Endian::host_to_le(fh_params.dwell_time);
-    std::memcpy(data, &dwell, sizeof(dwell));
-    data[2] = fh_params.hop_set;
-    data[3] = fh_params.hop_pattern;
-    data[4] = fh_params.hop_index;
-    add_tagged_option(FH_SET, sizeof(data), data);
-
+void Dot11ManagementFrame::fh_parameter_set(const fh_params_set& fh_params) {
+    uint8_t buffer[5];
+    OutputMemoryStream stream(buffer, sizeof(buffer));
+    stream.write_le(fh_params.dwell_time);
+    stream.write(fh_params.hop_set);
+    stream.write(fh_params.hop_pattern);
+    stream.write(fh_params.hop_index);
+    add_tagged_option(FH_SET, sizeof(buffer), buffer);
 }
 
 void Dot11ManagementFrame::ds_parameter_set(uint8_t current_channel) {
     add_tagged_option(DS_SET, 1, &current_channel);
 }
 
-void Dot11ManagementFrame::cf_parameter_set(const cf_params_set &params) {
-    uint8_t data[6];
-    data[0] = params.cfp_count;
-    data[1] = params.cfp_period;
-    uint16_t dummy = Endian::host_to_le(params.cfp_max_duration);
-    std::memcpy(data + 2, &dummy, sizeof(uint16_t));
-    dummy = Endian::host_to_le(params.cfp_dur_remaining);
-    std::memcpy(data + 4, &dummy, sizeof(uint16_t));
-    add_tagged_option(CF_SET, sizeof(data), data);
+void Dot11ManagementFrame::cf_parameter_set(const cf_params_set& params) {
+    uint8_t buffer[6];
+    OutputMemoryStream stream(buffer, sizeof(buffer));
+    stream.write(params.cfp_count);
+    stream.write(params.cfp_period);
+    stream.write_le(params.cfp_max_duration);
+    stream.write_le(params.cfp_dur_remaining);
+    add_tagged_option(CF_SET, sizeof(buffer), buffer);
 }
 
 void Dot11ManagementFrame::ibss_parameter_set(uint16_t atim_window) {
@@ -211,35 +221,37 @@ void Dot11ManagementFrame::ibss_parameter_set(uint16_t atim_window) {
     add_tagged_option(IBSS_SET, 2, (uint8_t*)&atim_window);
 }
 
-void Dot11ManagementFrame::ibss_dfs(const ibss_dfs_params &params) {
+void Dot11ManagementFrame::ibss_dfs(const ibss_dfs_params& params) {
     const size_t sz = address_type::address_size + sizeof(uint8_t) + 
-                        sizeof(uint8_t) * 2 * params.channel_map.size();
-    std::vector<uint8_t> buffer(sz);
-    uint8_t* ptr_buffer = &buffer[0];
-
-    ptr_buffer = params.dfs_owner.copy(ptr_buffer);
-    *(ptr_buffer++) = params.recovery_interval;
+                      sizeof(uint8_t) * 2 * params.channel_map.size();
+    vector<uint8_t> buffer(sz);
+    OutputMemoryStream stream(buffer);
+    stream.write(params.dfs_owner);
+    stream.write(params.recovery_interval);
     for (channels_type::const_iterator it = params.channel_map.begin(); it != params.channel_map.end(); ++it) {
-        *(ptr_buffer++) = it->first;
-        *(ptr_buffer++) = it->second;
+        stream.write(it->first);
+        stream.write(it->second);
     }
 
     add_tagged_option(IBSS_DFS, static_cast<uint8_t>(buffer.size()), &buffer[0]);
 }
 
-void Dot11ManagementFrame::country(const country_params &params) {
+void Dot11ManagementFrame::country(const country_params& params) {
     if ((params.first_channel.size() != params.number_channels.size()) ||
-        (params.number_channels.size() != params.max_transmit_power.size()))
-        throw std::runtime_error("The length of the lists are distinct");
-    if(params.country.size() != 3)
-        throw std::runtime_error("Invalid country identifier length");
+        (params.number_channels.size() != params.max_transmit_power.size())) {
+        throw runtime_error("The length of the lists are distinct");
+    }
+    if (params.country.size() != 3) {
+        throw runtime_error("Invalid country identifier length");
+    }
     size_t sz = sizeof(uint8_t) * 3 * params.first_channel.size() + params.country.size();
     // Use 1 byte padding at the end if the length is odd.
-    if((sz & 1) == 1)
+    if ((sz & 1) == 1) {
         sz++;
-    std::vector<uint8_t> buffer(sz);
-    uint8_t *ptr = std::copy(params.country.begin(), params.country.end(), &buffer[0]);
-    for(size_t i(0); i < params.first_channel.size(); ++i) {
+    }
+    vector<uint8_t> buffer(sz);
+    uint8_t* ptr = copy(params.country.begin(), params.country.end(), &buffer[0]);
+    for (size_t i(0); i < params.first_channel.size(); ++i) {
         *(ptr++) = params.first_channel[i];
         *(ptr++) = params.number_channels[i];
         *(ptr++) = params.max_transmit_power[i];
@@ -254,16 +266,17 @@ void Dot11ManagementFrame::fh_parameters(uint8_t prime_radix, uint8_t number_cha
     add_tagged_option(HOPPING_PATTERN_PARAMS, 2, buffer);
 }
 
-void Dot11ManagementFrame::fh_pattern_table(const fh_pattern_type &params) {
-    std::vector<uint8_t> data(sizeof(uint8_t) * 4 + params.random_table.size());
-    uint8_t *ptr = &data[0];
+void Dot11ManagementFrame::fh_pattern_table(const fh_pattern_type& params) {
+    vector<uint8_t> data(sizeof(uint8_t) * 4 + params.random_table.size());
+    uint8_t* ptr = &data[0];
     *(ptr++) = params.flag;
     *(ptr++) = params.number_of_sets;
     *(ptr++) = params.modulus;
     *(ptr++) = params.offset;
     byte_array::const_iterator it(params.random_table.begin());
-    for(; it != params.random_table.end(); ++it)
+    for (; it != params.random_table.end(); ++it) {
         *(ptr++) = *it;
+    }
     add_tagged_option(HOPPING_PATTERN_TABLE, static_cast<uint8_t>(data.size()), &data[0]);
 }
 
@@ -271,7 +284,7 @@ void Dot11ManagementFrame::power_constraint(uint8_t local_power_constraint) {
     add_tagged_option(POWER_CONSTRAINT, 1, &local_power_constraint);
 }
 
-void Dot11ManagementFrame::channel_switch(const channel_switch_type &data) {
+void Dot11ManagementFrame::channel_switch(const channel_switch_type& data) {
     uint8_t buffer[3];
     buffer[0] = data.switch_mode;
     buffer[1] = data.new_channel;
@@ -280,14 +293,13 @@ void Dot11ManagementFrame::channel_switch(const channel_switch_type &data) {
 
 }
 
-void Dot11ManagementFrame::quiet(const quiet_type &data) {
+void Dot11ManagementFrame::quiet(const quiet_type& data) {
     uint8_t buffer[6];
-    uint16_t* ptr_buffer = (uint16_t*)(buffer + 2);
-
-    buffer[0] = data.quiet_count;
-    buffer[1] = data.quiet_period;
-    ptr_buffer[0] = Endian::host_to_le(data.quiet_duration);
-    ptr_buffer[1] = Endian::host_to_le(data.quiet_offset);
+    OutputMemoryStream stream(buffer, sizeof(buffer));
+    stream.write(data.quiet_count);
+    stream.write(data.quiet_period);
+    stream.write_le(data.quiet_duration);
+    stream.write_le(data.quiet_offset);
     add_tagged_option(QUIET, sizeof(buffer), buffer);
 }
 
@@ -303,7 +315,7 @@ void Dot11ManagementFrame::erp_information(uint8_t value) {
     add_tagged_option(ERP_INFORMATION, 1, &value);
 }
 
-void Dot11ManagementFrame::bss_load(const bss_load_type &data) {
+void Dot11ManagementFrame::bss_load(const bss_load_type& data) {
     uint8_t buffer[5];
     uint16_t dummy = Endian::host_to_le(data.station_count);
 
@@ -328,20 +340,21 @@ void Dot11ManagementFrame::bss_load(const bss_load_type &data) {
     add_tagged_option(BSS_LOAD, sizeof(buffer), buffer);
 }
 
-void Dot11ManagementFrame::tim(const tim_type &data) {
-    std::vector<uint8_t> buffer(sizeof(uint8_t) * 3 + data.partial_virtual_bitmap.size());
-    buffer[0] = data.dtim_count;
-    buffer[1] = data.dtim_period;
-    buffer[2] = data.bitmap_control;
-    std::copy(
+void Dot11ManagementFrame::tim(const tim_type& data) {
+    vector<uint8_t> buffer(sizeof(uint8_t) * 3 + data.partial_virtual_bitmap.size());
+    OutputMemoryStream stream(buffer);
+
+    stream.write(data.dtim_count);
+    stream.write(data.dtim_period);
+    stream.write(data.bitmap_control);
+    stream.write(
         data.partial_virtual_bitmap.begin(), 
-        data.partial_virtual_bitmap.end(),
-        &buffer[3]
+        data.partial_virtual_bitmap.end()
     );
     add_tagged_option(TIM, static_cast<uint8_t>(buffer.size()), &buffer[0]);
 }
 
-void Dot11ManagementFrame::challenge_text(const std::string &text) {
+void Dot11ManagementFrame::challenge_text(const string& text) {
     add_tagged_option(
         CHALLENGE_TEXT, 
         static_cast<uint8_t>(text.size()),
@@ -349,9 +362,9 @@ void Dot11ManagementFrame::challenge_text(const std::string &text) {
     );
 }
 
-void Dot11ManagementFrame::vendor_specific(const vendor_specific_type &data) {
+void Dot11ManagementFrame::vendor_specific(const vendor_specific_type& data) {
     byte_array buffer(3 + data.data.size());
-    std::copy(
+    copy(
         data.data.begin(),
         data.data.end(),
         data.oui.copy(buffer.begin())
@@ -365,14 +378,17 @@ RSNInformation Dot11ManagementFrame::rsn_information() const {
     return search_and_convert<RSNInformation>(RSN);
 }
 
-std::string Dot11ManagementFrame::ssid() const {
-    const Dot11::option *option = search_option(SSID);
-    if(!option)
+string Dot11ManagementFrame::ssid() const {
+    const Dot11::option* option = search_option(SSID);
+    if (!option) {
         throw option_not_found();
-    if(option->data_size() == 0 && this->subtype() == Dot11::PROBE_REQ)
+    }
+    if (option->data_size() == 0 && subtype() == Dot11::PROBE_REQ){
         return "BROADCAST";
-    else 
-        return std::string((const char*)option->data_ptr(), option->data_size());
+    }
+    else {
+        return string((const char*)option->data_ptr(), option->data_size());
+    }
 }
 
 Dot11ManagementFrame::rates_type Dot11ManagementFrame::supported_rates() const {
@@ -387,8 +403,8 @@ Dot11ManagementFrame::qos_capability_type Dot11ManagementFrame::qos_capability()
     return search_and_convert<uint8_t>(QOS_CAPABILITY);
 }
 
-std::pair<uint8_t, uint8_t> Dot11ManagementFrame::power_capability() const {
-    return search_and_convert<std::pair<uint8_t, uint8_t> >(POWER_CAPABILITY);
+pair<uint8_t, uint8_t> Dot11ManagementFrame::power_capability() const {
+    return search_and_convert<pair<uint8_t, uint8_t> >(POWER_CAPABILITY);
 }
 
 Dot11ManagementFrame::channels_type Dot11ManagementFrame::supported_channels() const {
@@ -423,8 +439,8 @@ Dot11ManagementFrame::country_params Dot11ManagementFrame::country() const {
     return search_and_convert<country_params>(COUNTRY);
 }
 
-std::pair<uint8_t, uint8_t> Dot11ManagementFrame::fh_parameters() const {
-    return search_and_convert<std::pair<uint8_t, uint8_t> >(HOPPING_PATTERN_PARAMS);
+pair<uint8_t, uint8_t> Dot11ManagementFrame::fh_parameters() const {
+    return search_and_convert<pair<uint8_t, uint8_t> >(HOPPING_PATTERN_PARAMS);
 }
 
 Dot11ManagementFrame::fh_pattern_type Dot11ManagementFrame::fh_pattern_table() const {
@@ -443,8 +459,8 @@ Dot11ManagementFrame::quiet_type Dot11ManagementFrame::quiet() const {
     return search_and_convert<quiet_type>(QUIET);
 }
 
-std::pair<uint8_t, uint8_t> Dot11ManagementFrame::tpc_report() const {
-    return search_and_convert<std::pair<uint8_t, uint8_t> >(TPC_REPORT);
+pair<uint8_t, uint8_t> Dot11ManagementFrame::tpc_report() const {
+    return search_and_convert<pair<uint8_t, uint8_t> >(TPC_REPORT);
 }
 
 uint8_t Dot11ManagementFrame::erp_information() const {
@@ -459,23 +475,26 @@ Dot11ManagementFrame::tim_type Dot11ManagementFrame::tim() const {
     return search_and_convert<tim_type>(TIM);
 }
 
-std::string Dot11ManagementFrame::challenge_text() const {
-    return search_and_convert<std::string>(CHALLENGE_TEXT);
+string Dot11ManagementFrame::challenge_text() const {
+    return search_and_convert<string>(CHALLENGE_TEXT);
 }
 
 Dot11ManagementFrame::vendor_specific_type Dot11ManagementFrame::vendor_specific() const {
-    const Dot11::option *option = search_option(VENDOR_SPECIFIC);
-    if(!option || option->data_size() < 3)
+    const Dot11::option* option = search_option(VENDOR_SPECIFIC);
+    if (!option || option->data_size() < 3) {
         throw option_not_found();
-    return vendor_specific_type::from_bytes(option->data_ptr(), 
-        static_cast<uint32_t>(option->data_size()));
+    }
+    return vendor_specific_type::from_bytes(
+        option->data_ptr(), 
+        static_cast<uint32_t>(option->data_size())
+    );
 }
 
 Dot11ManagementFrame::vendor_specific_type 
-  Dot11ManagementFrame::vendor_specific_type::from_bytes(const uint8_t *buffer, uint32_t sz) 
-{
-    if(sz < 3)
+Dot11ManagementFrame::vendor_specific_type::from_bytes(const uint8_t* buffer, uint32_t sz) {
+    if (sz < 3) {
         throw malformed_option();
+    }
     return vendor_specific_type(
         buffer, 
         byte_array(buffer + 3, buffer + sz)
@@ -484,75 +503,81 @@ Dot11ManagementFrame::vendor_specific_type
 
 // Options
 
-Dot11ManagementFrame::fh_params_set Dot11ManagementFrame::fh_params_set::from_option(const option &opt)
-{
-    if(opt.data_size() != 5)
+Dot11ManagementFrame::fh_params_set
+Dot11ManagementFrame::fh_params_set::from_option(const option& opt) {
+    if (opt.data_size() != 5) {
         throw malformed_option();
+    }
     fh_params_set output;
-    std::memcpy(&output.dwell_time, opt.data_ptr(), sizeof(uint16_t));
-    output.dwell_time = Endian::le_to_host(output.dwell_time);
-    output.hop_set = opt.data_ptr()[2];
-    output.hop_pattern = opt.data_ptr()[3];
-    output.hop_index = opt.data_ptr()[4];
+    InputMemoryStream stream(opt.data_ptr(), opt.data_size());
+    output.dwell_time = stream.read_le<uint16_t>();
+    output.hop_set = stream.read<uint8_t>();
+    output.hop_pattern = stream.read<uint8_t>();
+    output.hop_index = stream.read<uint8_t>();
     return output;
 }
 
-Dot11ManagementFrame::cf_params_set Dot11ManagementFrame::cf_params_set::from_option(const option &opt) 
-{
-    if(opt.data_size() != 6)
+Dot11ManagementFrame::cf_params_set
+Dot11ManagementFrame::cf_params_set::from_option(const option& opt) {
+    if (opt.data_size() != 6) {
         throw malformed_option();
+    }
     cf_params_set output;
-    output.cfp_count = *opt.data_ptr();
-    output.cfp_period = opt.data_ptr()[1];
-    std::memcpy(&output.cfp_max_duration, &opt.data_ptr()[2], sizeof(uint16_t));
-    std::memcpy(&output.cfp_dur_remaining, &opt.data_ptr()[4], sizeof(uint16_t));
-    output.cfp_max_duration = Endian::le_to_host(output.cfp_max_duration);
-    output.cfp_dur_remaining = Endian::le_to_host(output.cfp_dur_remaining);
+    InputMemoryStream stream(opt.data_ptr(), opt.data_size());
+    output.cfp_count = stream.read<uint8_t>();
+    output.cfp_period = stream.read<uint8_t>();
+    output.cfp_max_duration = stream.read_le<uint16_t>();
+    output.cfp_dur_remaining = stream.read_le<uint16_t>();
     return output;
 }
 
-Dot11ManagementFrame::ibss_dfs_params Dot11ManagementFrame::ibss_dfs_params::from_option(const option &opt)
-{
-    if(opt.data_size() < ibss_dfs_params::minimum_size)
+Dot11ManagementFrame::ibss_dfs_params
+Dot11ManagementFrame::ibss_dfs_params::from_option(const option& opt) {
+    if (opt.data_size() < ibss_dfs_params::minimum_size) {
         throw malformed_option();
+    }
     ibss_dfs_params output;
-    const uint8_t *ptr = opt.data_ptr(), *end = ptr + opt.data_size();
+    const uint8_t* ptr = opt.data_ptr(), *end = ptr + opt.data_size();
     output.dfs_owner = ptr;
     ptr += output.dfs_owner.size();
     output.recovery_interval = *(ptr++);
-    while(ptr != end) {
+    while (ptr != end) {
         uint8_t first = *(ptr++);
-        if(ptr == end)
-            throw option_not_found();
-        output.channel_map.push_back(std::make_pair(first, *(ptr++)));
+        if (ptr == end) {
+            throw malformed_option();
+        }
+        output.channel_map.push_back(make_pair(first, *(ptr++)));
     }
     return output;
 }
 
-Dot11ManagementFrame::country_params Dot11ManagementFrame::country_params::from_option(const option &opt)
-{
-    if(opt.data_size() < country_params::minimum_size)
+Dot11ManagementFrame::country_params
+Dot11ManagementFrame::country_params::from_option(const option& opt) {
+    if (opt.data_size() < country_params::minimum_size) {
         throw malformed_option();
+    }
     country_params output;
-    const uint8_t *ptr = opt.data_ptr(), *end = ptr + opt.data_size();
-    std::copy(ptr, ptr + 3, std::back_inserter(output.country));
+    const uint8_t* ptr = opt.data_ptr(), *end = ptr + opt.data_size();
+    copy(ptr, ptr + 3, back_inserter(output.country));
     ptr += output.country.size();
-    while(end - ptr >= 3) {
+    while (end - ptr >= 3) {
         output.first_channel.push_back(*(ptr++));
         output.number_channels.push_back(*(ptr++));
         output.max_transmit_power.push_back(*(ptr++));
     }
-    if(ptr != end)
+    if (ptr != end) {
         throw malformed_option();
+    }
     return output; 
 }
 
-Dot11ManagementFrame::fh_pattern_type Dot11ManagementFrame::fh_pattern_type::from_option(const option &opt)
-{
-    if(opt.data_size() < fh_pattern_type::minimum_size)
+Dot11ManagementFrame::fh_pattern_type
+Dot11ManagementFrame::fh_pattern_type::from_option(const option& opt) {
+    if (opt.data_size() < fh_pattern_type::minimum_size) {
         throw malformed_option();
+    }
     fh_pattern_type output;
-    const uint8_t *ptr = opt.data_ptr(), *end = ptr + opt.data_size();
+    const uint8_t* ptr = opt.data_ptr(), *end = ptr + opt.data_size();
     
     output.flag = *(ptr++);
     output.number_of_sets = *(ptr++);
@@ -563,11 +588,12 @@ Dot11ManagementFrame::fh_pattern_type Dot11ManagementFrame::fh_pattern_type::fro
     return output;
 }
 
-Dot11ManagementFrame::channel_switch_type Dot11ManagementFrame::channel_switch_type::from_option(const option &opt)
-{
-    if(opt.data_size() != sizeof(uint8_t) * 3)
+Dot11ManagementFrame::channel_switch_type 
+    Dot11ManagementFrame::channel_switch_type::from_option(const option& opt) {
+    if (opt.data_size() != sizeof(uint8_t) * 3) {
         throw malformed_option();
-    const uint8_t *ptr = opt.data_ptr();
+    }
+    const uint8_t* ptr = opt.data_ptr();
     channel_switch_type output;
     output.switch_mode = *(ptr++);
     output.new_channel = *(ptr++);
@@ -575,41 +601,39 @@ Dot11ManagementFrame::channel_switch_type Dot11ManagementFrame::channel_switch_t
     return output;
 }
 
-Dot11ManagementFrame::quiet_type Dot11ManagementFrame::quiet_type::from_option(const option &opt)
-{
-    if(opt.data_size() != (sizeof(uint8_t) * 2 + sizeof(uint16_t) * 2))
+Dot11ManagementFrame::quiet_type
+Dot11ManagementFrame::quiet_type::from_option(const option& opt) {
+    if (opt.data_size() != (sizeof(uint8_t) * 2 + sizeof(uint16_t) * 2)) {
         throw malformed_option();
-    const uint8_t *ptr = opt.data_ptr();
+    }
     quiet_type output;
+    InputMemoryStream stream(opt.data_ptr(), opt.data_size());
     
-    output.quiet_count = *(ptr++);
-    output.quiet_period = *(ptr++);
-    const uint16_t *ptr_16 = (const uint16_t*)ptr;
-    output.quiet_duration = Endian::le_to_host(*(ptr_16++));
-    output.quiet_offset = Endian::le_to_host(*ptr_16);
+    output.quiet_count = stream.read<uint8_t>();
+    output.quiet_period = stream.read<uint8_t>();
+    output.quiet_duration = stream.read_le<uint16_t>();
+    output.quiet_offset = stream.read_le<uint16_t>();
     return output;
 }
 
-Dot11ManagementFrame::bss_load_type Dot11ManagementFrame::bss_load_type::from_option(const option &opt)
-{
-    if(opt.data_size() != sizeof(uint8_t) + 2 * sizeof(uint16_t))
+Dot11ManagementFrame::bss_load_type 
+Dot11ManagementFrame::bss_load_type::from_option(const option& opt) {
+    if (opt.data_size() != sizeof(uint8_t) + 2 * sizeof(uint16_t)) {
         throw malformed_option();
+    }
     bss_load_type output;
-    
-    const uint8_t *ptr = opt.data_ptr();
-    std::memcpy(&output.station_count, ptr, sizeof(uint16_t));
-    std::memcpy(&output.available_capacity, ptr + 3, sizeof(uint16_t));
-    output.channel_utilization = ptr[2];
-    output.station_count = Endian::le_to_host(output.station_count);
-    output.available_capacity = Endian::le_to_host(output.available_capacity);
+    InputMemoryStream stream(opt.data_ptr(), opt.data_size());
+    output.station_count = stream.read_le<uint16_t>();
+    output.channel_utilization = stream.read<uint8_t>();
+    output.available_capacity = stream.read_le<uint16_t>();
     return output;
 }
 
-Dot11ManagementFrame::tim_type Dot11ManagementFrame::tim_type::from_option(const option &opt)
-{
-    if(opt.data_size() < 4 * sizeof(uint8_t))
+Dot11ManagementFrame::tim_type Dot11ManagementFrame::tim_type::from_option(const option& opt) {
+    if (opt.data_size() < 4 * sizeof(uint8_t)) {
         throw malformed_option();
-    const uint8_t *ptr = opt.data_ptr(), *end = ptr + opt.data_size();
+    }
+    const uint8_t* ptr = opt.data_ptr(), *end = ptr + opt.data_size();
     tim_type output;
     
     output.dtim_count = *(ptr++);
@@ -619,6 +643,7 @@ Dot11ManagementFrame::tim_type Dot11ManagementFrame::tim_type::from_option(const
     output.partial_virtual_bitmap.assign(ptr, end);
     return output;
 }
-} // namespace Tins
+
+} // Tins
 
 #endif // HAVE_DOT11
diff --git a/src/dot11/dot11_probe.cpp b/src/dot11/dot11_probe.cpp
index 233ff7a..dce8385 100644
--- a/src/dot11/dot11_probe.cpp
+++ b/src/dot11/dot11_probe.cpp
@@ -38,56 +38,54 @@ using Tins::Memory::InputMemoryStream;
 using Tins::Memory::OutputMemoryStream;
 
 namespace Tins {
-/* Probe Request */
 
-Dot11ProbeRequest::Dot11ProbeRequest(const address_type &dst_hw_addr, 
-  const address_type &src_hw_addr) 
-: Dot11ManagementFrame(dst_hw_addr, src_hw_addr) 
-{
-    this->subtype(Dot11::PROBE_REQ);
+// Probe Request
+
+Dot11ProbeRequest::Dot11ProbeRequest(const address_type& dst_hw_addr, 
+                                     const address_type& src_hw_addr) 
+: Dot11ManagementFrame(dst_hw_addr, src_hw_addr) {
+    subtype(Dot11::PROBE_REQ);
 }
 
-Dot11ProbeRequest::Dot11ProbeRequest(const uint8_t *buffer, uint32_t total_sz) 
-: Dot11ManagementFrame(buffer, total_sz) 
-{
+Dot11ProbeRequest::Dot11ProbeRequest(const uint8_t* buffer, uint32_t total_sz) 
+: Dot11ManagementFrame(buffer, total_sz) {
     InputMemoryStream stream(buffer, total_sz);
     stream.skip(management_frame_size());
     parse_tagged_parameters(stream);
 }
 
-/* Probe Response */
+// Probe Response
 
-Dot11ProbeResponse::Dot11ProbeResponse(const address_type &dst_hw_addr, 
-  const address_type &src_hw_addr) 
-: Dot11ManagementFrame(dst_hw_addr, src_hw_addr), _body()
-{
-    this->subtype(Dot11::PROBE_RESP);
+Dot11ProbeResponse::Dot11ProbeResponse(const address_type& dst_hw_addr, 
+                                       const address_type& src_hw_addr) 
+: Dot11ManagementFrame(dst_hw_addr, src_hw_addr), body_() {
+    subtype(Dot11::PROBE_RESP);
 }
 
-Dot11ProbeResponse::Dot11ProbeResponse(const uint8_t *buffer, uint32_t total_sz) 
-: Dot11ManagementFrame(buffer, total_sz) 
-{
+Dot11ProbeResponse::Dot11ProbeResponse(const uint8_t* buffer, uint32_t total_sz) 
+: Dot11ManagementFrame(buffer, total_sz) {
     InputMemoryStream stream(buffer, total_sz);
     stream.skip(management_frame_size());
-    stream.read(_body);
+    stream.read(body_);
     parse_tagged_parameters(stream);
 }
 
 void Dot11ProbeResponse::timestamp(uint64_t new_timestamp) {
-    this->_body.timestamp = Endian::host_to_le(new_timestamp);
+    body_.timestamp = Endian::host_to_le(new_timestamp);
 }
 
 void Dot11ProbeResponse::interval(uint16_t new_interval) {
-    this->_body.interval = Endian::host_to_le(new_interval);
+    body_.interval = Endian::host_to_le(new_interval);
 }
 
 uint32_t Dot11ProbeResponse::header_size() const {
-    return Dot11ManagementFrame::header_size() + sizeof(this->_body);
+    return Dot11ManagementFrame::header_size() + sizeof(body_);
 }
 
 void Dot11ProbeResponse::write_fixed_parameters(OutputMemoryStream& stream) {
-    stream.write(_body);
+    stream.write(body_);
 }
+
 } // namespace Tins
 
 #endif // HAVE_DOT11
diff --git a/src/dot1q.cpp b/src/dot1q.cpp
index 9eba9ff..f243bab 100644
--- a/src/dot1q.cpp
+++ b/src/dot1q.cpp
@@ -40,16 +40,14 @@ using Tins::Memory::OutputMemoryStream;
 namespace Tins {
 
 Dot1Q::Dot1Q(small_uint<12> tag_id, bool append_pad) 
-: _header(), _append_padding(append_pad)
-{
+: header_(), append_padding_(append_pad) {
     id(tag_id);
 }
 
-Dot1Q::Dot1Q(const uint8_t *buffer, uint32_t total_sz) 
-: _append_padding()
-{
+Dot1Q::Dot1Q(const uint8_t* buffer, uint32_t total_sz) 
+: append_padding_() {
     InputMemoryStream stream(buffer, total_sz);
-    stream.read(_header);
+    stream.read(header_);
     
     if (stream) {
         inner_pdu(
@@ -63,33 +61,33 @@ Dot1Q::Dot1Q(const uint8_t *buffer, uint32_t total_sz)
 }
 
 void Dot1Q::priority(small_uint<3> new_priority) {
-    _header.priority = new_priority;
+    header_.priority = new_priority;
 }
 
 void Dot1Q::cfi(small_uint<1> new_cfi) {
-    _header.cfi = new_cfi;
+    header_.cfi = new_cfi;
 }
 
 void Dot1Q::id(small_uint<12> new_id) {
     #if TINS_IS_LITTLE_ENDIAN
-    _header.idL = new_id & 0xff;
-    _header.idH = new_id >> 8;
+    header_.idL = new_id & 0xff;
+    header_.idH = new_id >> 8;
     #else
-    _header.id = new_id;
+    header_.id = new_id;
     #endif
 }
 
 void Dot1Q::payload_type(uint16_t new_type) {
-    _header.type = Endian::host_to_be(new_type);
+    header_.type = Endian::host_to_be(new_type);
 }
 
 uint32_t Dot1Q::header_size() const {
-    return sizeof(_header);
+    return sizeof(header_);
 }
 
 uint32_t Dot1Q::trailer_size() const {
-    if (_append_padding) {
-        uint32_t total_size = sizeof(_header);
+    if (append_padding_) {
+        uint32_t total_size = sizeof(header_);
         if (inner_pdu()) {
             total_size += inner_pdu()->size();
         }
@@ -100,7 +98,7 @@ uint32_t Dot1Q::trailer_size() const {
     }
 }
 
-void Dot1Q::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *) {
+void Dot1Q::write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU *) {
     OutputMemoryStream stream(buffer, total_sz);
     if (inner_pdu()) {
         // Set the appropriate payload type flag
@@ -109,7 +107,7 @@ void Dot1Q::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *)
         );
         payload_type(static_cast<uint16_t>(flag));
     }
-    stream.write(_header);
+    stream.write(header_);
 
     // Skip inner PDU size
     if (inner_pdu()) {
@@ -120,29 +118,31 @@ void Dot1Q::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *)
 }
 
 #if TINS_IS_LITTLE_ENDIAN
-    uint16_t Dot1Q::get_id(const dot1q_hdr *hdr) {
+    uint16_t Dot1Q::get_id(const dot1q_hdr* hdr) {
         return hdr->idL | (hdr->idH << 8);
     }
 #else
-    uint16_t Dot1Q::get_id(const dot1q_hdr *hdr) {
+    uint16_t Dot1Q::get_id(const dot1q_hdr* hdr) {
         return hdr->id;
     }
 #endif
 
 void Dot1Q::append_padding(bool value) {
-    _append_padding = value;
+    append_padding_ = value;
 }
 
-bool Dot1Q::matches_response(const uint8_t *ptr, uint32_t total_sz) const {
-    if(total_sz < sizeof(_header))
+bool Dot1Q::matches_response(const uint8_t* ptr, uint32_t total_sz) const {
+    if (total_sz < sizeof(header_)) {
         return false;
-    const dot1q_hdr *dot1q_ptr = (const dot1q_hdr*)ptr;
-    if(get_id(dot1q_ptr) == get_id(&_header)) {
-        ptr += sizeof(_header);
-        total_sz -= sizeof(_header);
+    }
+    const dot1q_hdr* dot1q_ptr = (const dot1q_hdr*)ptr;
+    if (get_id(dot1q_ptr) == get_id(&header_)) {
+        ptr += sizeof(header_);
+        total_sz -= sizeof(header_);
         return inner_pdu() ? inner_pdu()->matches_response(ptr, total_sz) : true;
     }
     return false;
     
 }
-}
+
+} // Tins
diff --git a/src/dot3.cpp b/src/dot3.cpp
index 2463afb..fa9450c 100644
--- a/src/dot3.cpp
+++ b/src/dot3.cpp
@@ -46,6 +46,9 @@
 #include "exceptions.h"
 #include "memory_helpers.h"
 
+using std::copy;
+using std::equal;
+
 using Tins::Memory::InputMemoryStream;
 using Tins::Memory::OutputMemoryStream;
 
@@ -53,44 +56,41 @@ namespace Tins {
 
 const Dot3::address_type Dot3::BROADCAST("ff:ff:ff:ff:ff:ff");
 
-Dot3::Dot3(const address_type &dst_hw_addr, const address_type &src_hw_addr)
-{
-    memset(&_eth, 0, sizeof(ethhdr));
+Dot3::Dot3(const address_type& dst_hw_addr, const address_type& src_hw_addr)
+: header_() {
     this->dst_addr(dst_hw_addr);
     this->src_addr(src_hw_addr);
-    this->_eth.length = 0;
-
 }
 
-Dot3::Dot3(const uint8_t *buffer, uint32_t total_sz) 
-{
+Dot3::Dot3(const uint8_t* buffer, uint32_t total_sz) {
     InputMemoryStream stream(buffer, total_sz);
-    stream.read(_eth);
+    stream.read(header_);
     if (stream) {
         inner_pdu(new Tins::LLC(stream.pointer(), stream.size()));
     }
 }
 
-void Dot3::dst_addr(const address_type &new_dst_mac) {
-    std::copy(new_dst_mac.begin(), new_dst_mac.end(), _eth.dst_mac);
+void Dot3::dst_addr(const address_type& address) {
+    copy(address.begin(), address.end(), header_.dst_mac);
 }
 
-void Dot3::src_addr(const address_type &new_src_mac) {
-    std::copy(new_src_mac.begin(), new_src_mac.end(), _eth.src_mac);
+void Dot3::src_addr(const address_type& address) {
+    copy(address.begin(), address.end(), header_.src_mac);
 }
 
-void Dot3::length(uint16_t new_length) {
-    this->_eth.length = Endian::host_to_be(new_length);
+void Dot3::length(uint16_t value) {
+    header_.length = Endian::host_to_be(value);
 }
 
 uint32_t Dot3::header_size() const {
-    return sizeof(ethhdr);
+    return sizeof(header_);
 }
 
 #if !defined(_WIN32) || defined(HAVE_PACKET_SENDER_PCAP_SENDPACKET)
-void Dot3::send(PacketSender &sender, const NetworkInterface &iface) {
-    if(!iface)
+void Dot3::send(PacketSender& sender, const NetworkInterface& iface) {
+    if (!iface) {
         throw invalid_interface();
+    }
         
     #if defined(BSD) || defined(__FreeBSD_kernel__) || defined(HAVE_PACKET_SENDER_PCAP_SENDPACKET)
         sender.send_l2(*this, 0, 0, iface);
@@ -103,39 +103,41 @@ void Dot3::send(PacketSender &sender, const NetworkInterface &iface) {
         addr.sll_protocol = Endian::host_to_be<uint16_t>(ETH_P_ALL);
         addr.sll_halen = address_type::address_size;
         addr.sll_ifindex = iface.id();
-        memcpy(&(addr.sll_addr), _eth.dst_mac, sizeof(_eth.dst_mac));
+        memcpy(&(addr.sll_addr), header_.dst_mac, sizeof(header_.dst_mac));
 
         sender.send_l2(*this, (struct sockaddr*)&addr, (uint32_t)sizeof(addr));
     #endif
 }
 #endif // !_WIN32 || HAVE_PACKET_SENDER_PCAP_SENDPACKET
 
-bool Dot3::matches_response(const uint8_t *ptr, uint32_t total_sz) const {
-    if(total_sz < sizeof(ethhdr))
+bool Dot3::matches_response(const uint8_t* ptr, uint32_t total_sz) const {
+    if (total_sz < sizeof(header_)) {
         return false;
+    }
     const size_t addr_sz = address_type::address_size;
-    const ethhdr *eth_ptr = (const ethhdr*)ptr;
-    if(std::equal(_eth.src_mac, _eth.src_mac + addr_sz, eth_ptr->dst_mac)) {
-        if(std::equal(_eth.src_mac, _eth.src_mac + addr_sz, eth_ptr->dst_mac) || dst_addr() == BROADCAST)
-        {
-            ptr += sizeof(ethhdr);
-            total_sz -= sizeof(ethhdr);
+    const dot3_header* eth_ptr = (const dot3_header*)ptr;
+    if (equal(header_.src_mac, header_.src_mac + addr_sz, eth_ptr->dst_mac)) {
+        if (equal(header_.src_mac, header_.src_mac + addr_sz, eth_ptr->dst_mac) || 
+           dst_addr() == BROADCAST) {
+            ptr += sizeof(dot3_header);
+            total_sz -= sizeof(dot3_header);
             return inner_pdu() ? inner_pdu()->matches_response(ptr, total_sz) : true;
         }
     }
     return false;
 }
 
-void Dot3::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent) {
+void Dot3::write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent) {
     OutputMemoryStream stream(buffer, total_sz);
-    _eth.length = Endian::host_to_be<uint16_t>(size() - sizeof(_eth));
-    stream.write(_eth);
+    header_.length = Endian::host_to_be<uint16_t>(size() - sizeof(header_));
+    stream.write(header_);
 }
 
 #ifndef _WIN32
-PDU *Dot3::recv_response(PacketSender &sender, const NetworkInterface &iface) {
-    if(!iface)
+PDU* Dot3::recv_response(PacketSender& sender, const NetworkInterface& iface) {
+    if (!iface) {
         throw invalid_interface();
+    }
     #if !defined(BSD) && !defined(__FreeBSD_kernel__)
         struct sockaddr_ll addr;
         memset(&addr, 0, sizeof(struct sockaddr_ll));
@@ -144,12 +146,14 @@ PDU *Dot3::recv_response(PacketSender &sender, const NetworkInterface &iface) {
         addr.sll_protocol = Endian::host_to_be<uint16_t>(ETH_P_802_3);
         addr.sll_halen = address_type::address_size;
         addr.sll_ifindex = iface.id();
-        memcpy(&(addr.sll_addr), _eth.dst_mac, sizeof(_eth.dst_mac));
+        memcpy(&(addr.sll_addr), header_.dst_mac, sizeof(header_.dst_mac));
 
         return sender.recv_l2(*this, (struct sockaddr*)&addr, (uint32_t)sizeof(addr));
     #else
         return sender.recv_l2(*this, 0, 0, iface);
     #endif
 }
+
 #endif // _WIN32
-}
+
+} // Tins
diff --git a/src/eapol.cpp b/src/eapol.cpp
index 22a453c..2da1df9 100644
--- a/src/eapol.cpp
+++ b/src/eapol.cpp
@@ -36,33 +36,36 @@
 #include "rawpdu.h"
 #include "memory_helpers.h"
 
+using std::copy;
+using std::min;
+using std::memset;
+using std::memcpy;
+
 using Tins::Memory::InputMemoryStream;
 using Tins::Memory::OutputMemoryStream;
 
 namespace Tins {
 
 EAPOL::EAPOL(uint8_t packet_type, EAPOLTYPE type) 
-: _header()
-{
-    _header.version = 1;
-    _header.packet_type = packet_type;
-    _header.type = (uint8_t)type;
+: header_() {
+    header_.version = 1;
+    header_.packet_type = packet_type;
+    header_.type = (uint8_t)type;
 }
 
-EAPOL::EAPOL(const uint8_t *buffer, uint32_t total_sz) 
-{
+EAPOL::EAPOL(const uint8_t* buffer, uint32_t total_sz) {
     InputMemoryStream stream(buffer, total_sz);
-    stream.read(_header);
+    stream.read(header_);
 }
 
-EAPOL *EAPOL::from_bytes(const uint8_t *buffer, uint32_t total_sz) {
-    if (total_sz < sizeof(eapolhdr)) {
+EAPOL* EAPOL::from_bytes(const uint8_t* buffer, uint32_t total_sz) {
+    if (total_sz < sizeof(eapol_header)) {
         throw malformed_packet();
     }
-    const eapolhdr *ptr = (const eapolhdr*)buffer;
+    const eapol_header* ptr = (const eapol_header*)buffer;
     uint32_t data_len = Endian::be_to_host<uint16_t>(ptr->length);
     // at least 4 for fields always present
-    total_sz = std::min(
+    total_sz = min(
         total_sz, 
         data_len + 4
     );
@@ -79,208 +82,203 @@ EAPOL *EAPOL::from_bytes(const uint8_t *buffer, uint32_t total_sz) {
 }
 
 void EAPOL::version(uint8_t new_version) {
-    _header.version = new_version;
+    header_.version = new_version;
 }
         
 void EAPOL::packet_type(uint8_t new_ptype) {
-    _header.packet_type = new_ptype;
+    header_.packet_type = new_ptype;
 }
 
 void EAPOL::length(uint16_t new_length) {
-    _header.length = Endian::host_to_be(new_length);
+    header_.length = Endian::host_to_be(new_length);
 }
 
 void EAPOL::type(uint8_t new_type) {
-    _header.type = new_type;
+    header_.type = new_type;
 }
 
-void EAPOL::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *) {
+void EAPOL::write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU *) {
     OutputMemoryStream stream(buffer, total_sz);
     length(total_sz - 4);
-    stream.write(_header);
-    std::memcpy(buffer, &_header, sizeof(_header));
+    stream.write(header_);
+    memcpy(buffer, &header_, sizeof(header_));
     write_body(stream);
 }
 
 /* RC4EAPOL */
 
 RC4EAPOL::RC4EAPOL() 
-: EAPOL(0x03, RC4) 
-{
-    std::memset(&_header, 0, sizeof(_header));
+: EAPOL(0x03, RC4) {
+    memset(&header_, 0, sizeof(header_));
 }
 
-RC4EAPOL::RC4EAPOL(const uint8_t *buffer, uint32_t total_sz) 
-: EAPOL(buffer, total_sz)
-{
+RC4EAPOL::RC4EAPOL(const uint8_t* buffer, uint32_t total_sz) 
+: EAPOL(buffer, total_sz) {
     InputMemoryStream stream(buffer, total_sz);
-    stream.skip(sizeof(eapolhdr));
-    stream.read(_header);
+    stream.skip(sizeof(eapol_header));
+    stream.read(header_);
     if (stream.size() >= key_length()) {
-        _key.assign(stream.pointer(), stream.pointer() + key_length());
-        stream.skip(key_length());
+        stream.read(key_, key_length());
         if (stream) {
             inner_pdu(new RawPDU(stream.pointer(), stream.size()));
         }
     }
 }
 
-void RC4EAPOL::key_length(uint16_t new_key_length) {
-    _header.key_length = Endian::host_to_be(new_key_length);
+void RC4EAPOL::key_length(uint16_t length) {
+    header_.key_length = Endian::host_to_be(length);
 }
         
-void RC4EAPOL::replay_counter(uint64_t new_replay_counter) {
-    _header.replay_counter = Endian::host_to_be(new_replay_counter);
+void RC4EAPOL::replay_counter(uint64_t value) {
+    header_.replay_counter = Endian::host_to_be(value);
 }
 
-void RC4EAPOL::key_iv(const uint8_t *new_key_iv) {
-    std::copy(new_key_iv, new_key_iv + sizeof(_header.key_iv), _header.key_iv);
+void RC4EAPOL::key_iv(const uint8_t* ptr) {
+    copy(ptr, ptr + sizeof(header_.key_iv), header_.key_iv);
 }
 
-void RC4EAPOL::key_flag(small_uint<1> new_key_flag) {
-    _header.key_flag = new_key_flag;
+void RC4EAPOL::key_flag(small_uint<1> flag) {
+    header_.key_flag = flag;
 }
 
 void RC4EAPOL::key_index(small_uint<7> new_key_index) {
-    _header.key_index = new_key_index;
+    header_.key_index = new_key_index;
 }
 
-void RC4EAPOL::key_sign(const uint8_t *new_key_sign) {
-    std::memcpy(_header.key_sign, new_key_sign, sizeof(_header.key_sign));
+void RC4EAPOL::key_sign(const uint8_t* ptr) {
+    memcpy(header_.key_sign, ptr, sizeof(header_.key_sign));
 }
 
-void RC4EAPOL::key(const key_type &new_key) {
-    _key = new_key;
+void RC4EAPOL::key(const key_type& new_key) {
+    key_ = new_key;
 }
 
 uint32_t RC4EAPOL::header_size() const {
-    return static_cast<uint32_t>(sizeof(eapolhdr) + sizeof(_header) + _key.size());
+    return static_cast<uint32_t>(sizeof(eapol_header) + sizeof(header_) + key_.size());
 }
 
 void RC4EAPOL::write_body(OutputMemoryStream& stream) {
-    if (_key.size()) {
-        _header.key_length = Endian::host_to_be(static_cast<uint16_t>(_key.size()));
+    if (key_.size()) {
+        header_.key_length = Endian::host_to_be(static_cast<uint16_t>(key_.size()));
     }
-    stream.write(_header);
-    stream.write(_key.begin(), _key.end());
+    stream.write(header_);
+    stream.write(key_.begin(), key_.end());
 }
 
 /* RSNEAPOL */
 
 
 RSNEAPOL::RSNEAPOL() 
-: EAPOL(0x03, RSN) 
-{
-    std::memset(&_header, 0, sizeof(_header));
+: EAPOL(0x03, RSN) {
+    memset(&header_, 0, sizeof(header_));
 }
 
-RSNEAPOL::RSNEAPOL(const uint8_t *buffer, uint32_t total_sz) 
-: EAPOL(buffer, total_sz)
-{
+RSNEAPOL::RSNEAPOL(const uint8_t* buffer, uint32_t total_sz) 
+: EAPOL(buffer, total_sz) {
     InputMemoryStream stream(buffer, total_sz);
-    stream.skip(sizeof(eapolhdr));
-    stream.read(_header);
+    stream.skip(sizeof(eapol_header));
+    stream.read(header_);
     if (stream.size() >= wpa_length()) {
-        _key.assign(stream.pointer(), stream.pointer() + wpa_length());
-        stream.skip(wpa_length());
+        stream.read(key_, wpa_length());
         if (stream) {
             inner_pdu(new RawPDU(stream.pointer(), stream.size()));
         }
     }
 }
 
-void RSNEAPOL::nonce(const uint8_t *new_nonce) {
-    std::copy(new_nonce, new_nonce + nonce_size, _header.nonce);
+void RSNEAPOL::nonce(const uint8_t* ptr) {
+    copy(ptr, ptr + nonce_size, header_.nonce);
 }
 
-void RSNEAPOL::rsc(const uint8_t *new_rsc) {
-    std::copy(new_rsc, new_rsc + rsc_size, _header.rsc);
+void RSNEAPOL::rsc(const uint8_t* ptr) {
+    copy(ptr, ptr + rsc_size, header_.rsc);
 }
 
-void RSNEAPOL::id(const uint8_t *new_id) {
-    std::copy(new_id, new_id + id_size, _header.id);
+void RSNEAPOL::id(const uint8_t* ptr) {
+    copy(ptr, ptr + id_size, header_.id);
 }
 
 void RSNEAPOL::replay_counter(uint64_t new_replay_counter) {
-    _header.replay_counter = Endian::host_to_be(new_replay_counter);
+    header_.replay_counter = Endian::host_to_be(new_replay_counter);
 }
 
-void RSNEAPOL::mic(const uint8_t *new_mic) {
-    std::copy(new_mic, new_mic + mic_size, _header.mic);
+void RSNEAPOL::mic(const uint8_t* ptr) {
+    copy(ptr, ptr + mic_size, header_.mic);
 }
 
-void RSNEAPOL::wpa_length(uint16_t new_wpa_length) {
-    _header.wpa_length = Endian::host_to_be(new_wpa_length);
+void RSNEAPOL::wpa_length(uint16_t length) {
+    header_.wpa_length = Endian::host_to_be(length);
 }
 
-void RSNEAPOL::key_iv(const uint8_t *new_key_iv) {
-    std::copy(new_key_iv, new_key_iv + sizeof(_header.key_iv), _header.key_iv);
+void RSNEAPOL::key_iv(const uint8_t* ptr) {
+    copy(ptr, ptr + sizeof(header_.key_iv), header_.key_iv);
 }
 
-void RSNEAPOL::key_length(uint16_t new_key_length) {
-    _header.key_length = Endian::host_to_be(new_key_length);
+void RSNEAPOL::key_length(uint16_t length) {
+    header_.key_length = Endian::host_to_be(length);
 }
 
-void RSNEAPOL::key(const key_type &new_key) {
-    _key = new_key;
-    _header.key_t = 0;
+void RSNEAPOL::key(const key_type& value) {
+    key_ = value;
+    header_.key_t = 0;
 }
 
-void RSNEAPOL::key_mic(small_uint<1> new_key_mic) {
-    _header.key_mic = new_key_mic;
+void RSNEAPOL::key_mic(small_uint<1> flag) {
+    header_.key_mic = flag;
 }
 
-void RSNEAPOL::secure(small_uint<1> new_secure) {
-    _header.secure = new_secure;
+void RSNEAPOL::secure(small_uint<1> flag) {
+    header_.secure = flag;
 }
 
-void RSNEAPOL::error(small_uint<1> new_error) {
-    _header.error = new_error;
+void RSNEAPOL::error(small_uint<1> flag) {
+    header_.error = flag;
 }
 
-void RSNEAPOL::request(small_uint<1> new_request) {
-    _header.request = new_request;
+void RSNEAPOL::request(small_uint<1> flag) {
+    header_.request = flag;
 }
 
-void RSNEAPOL::encrypted(small_uint<1 > new_encrypted) {
-    _header.encrypted = new_encrypted;
+void RSNEAPOL::encrypted(small_uint<1> flag) {
+    header_.encrypted = flag;
 }
 
 void RSNEAPOL::key_descriptor(small_uint<3> new_key_descriptor) {
-    _header.key_descriptor = new_key_descriptor;
+    header_.key_descriptor = new_key_descriptor;
 }
 
-void RSNEAPOL::key_t(small_uint<1> new_key_t) {
-    _header.key_t = new_key_t;
+void RSNEAPOL::key_t(small_uint<1> flag) {
+    header_.key_t = flag;
 }
 
-void RSNEAPOL::key_index(small_uint<2> new_key_index) {
-    _header.key_index = new_key_index;
+void RSNEAPOL::key_index(small_uint<2> value) {
+    header_.key_index = value;
 }
 
-void RSNEAPOL::install(small_uint<1> new_install) {
-    _header.install = new_install;
+void RSNEAPOL::install(small_uint<1> flag) {
+    header_.install = flag;
 }
 
-void RSNEAPOL::key_ack(small_uint<1> new_key_ack) {
-    _header.key_ack = new_key_ack;
+void RSNEAPOL::key_ack(small_uint<1> flag) {
+    header_.key_ack = flag;
 }
 
 uint32_t RSNEAPOL::header_size() const {
-    return static_cast<uint32_t>(sizeof(eapolhdr) + sizeof(_header) + _key.size());
+    return static_cast<uint32_t>(sizeof(eapol_header) + sizeof(header_) + key_.size());
 }
 
 void RSNEAPOL::write_body(OutputMemoryStream& stream) {
-    if (_key.size()) {
-        if (!_header.key_t && _header.install) {
-            _header.key_length = Endian::host_to_be<uint16_t>(32);
-            wpa_length(static_cast<uint16_t>(_key.size()));
+    if (key_.size()) {
+        if (!header_.key_t && header_.install) {
+            header_.key_length = Endian::host_to_be<uint16_t>(32);
+            wpa_length(static_cast<uint16_t>(key_.size()));
         }
-        else if (_key.size()) {
-            wpa_length(static_cast<uint16_t>(_key.size()));
+        else if (key_.size()) {
+            wpa_length(static_cast<uint16_t>(key_.size()));
         }
     }
-    stream.write(_header);
-    stream.write(_key.begin(), _key.end());
-}
+    stream.write(header_);
+    stream.write(key_.begin(), key_.end());
 }
+
+} // Tins
diff --git a/src/ethernetII.cpp b/src/ethernetII.cpp
index d14d172..42dd684 100644
--- a/src/ethernetII.cpp
+++ b/src/ethernetII.cpp
@@ -28,7 +28,6 @@
  */
 
 #include <cstring>
-#include <stdexcept>
 #include <algorithm>
 #include "macros.h"
 #ifndef _WIN32
@@ -53,6 +52,8 @@
 #include "exceptions.h"
 #include "memory_helpers.h"
 
+using std::equal;
+
 using Tins::Memory::InputMemoryStream;
 using Tins::Memory::OutputMemoryStream;
 
@@ -60,18 +61,16 @@ namespace Tins {
 
 const EthernetII::address_type EthernetII::BROADCAST("ff:ff:ff:ff:ff:ff");
 
-EthernetII::EthernetII(const address_type &dst_hw_addr, 
-const address_type &src_hw_addr) 
-: _eth()
-{
+EthernetII::EthernetII(const address_type& dst_hw_addr, 
+const address_type& src_hw_addr) 
+: header_() {
     dst_addr(dst_hw_addr);
     src_addr(src_hw_addr);
 }
 
-EthernetII::EthernetII(const uint8_t *buffer, uint32_t total_sz) 
-{
+EthernetII::EthernetII(const uint8_t* buffer, uint32_t total_sz) {
     InputMemoryStream stream(buffer, total_sz);
-    stream.read(_eth);
+    stream.read(header_);
     // If there's any size left
     if (stream) {
         inner_pdu(
@@ -82,28 +81,26 @@ EthernetII::EthernetII(const uint8_t *buffer, uint32_t total_sz)
             )
         );
     }
-
 }
 
-void EthernetII::dst_addr(const address_type &new_dst_addr) {
-    new_dst_addr.copy(_eth.dst_mac);
+void EthernetII::dst_addr(const address_type& new_dst_addr) {
+    new_dst_addr.copy(header_.dst_mac);
 }
 
-void EthernetII::src_addr(const address_type &new_src_addr) {
-    new_src_addr.copy(_eth.src_mac);
+void EthernetII::src_addr(const address_type& new_src_addr) {
+    new_src_addr.copy(header_.src_mac);
 }
 
 void EthernetII::payload_type(uint16_t new_payload_type) {
-    this->_eth.payload_type = Endian::host_to_be(new_payload_type);
+    header_.payload_type = Endian::host_to_be(new_payload_type);
 }
 
 uint32_t EthernetII::header_size() const {
-
-    return sizeof(ethhdr);
+    return sizeof(header_);
 }
 
 uint32_t EthernetII::trailer_size() const {
-    int32_t padding = 60 - sizeof(ethhdr); // EthernetII min size is 60, padding is sometimes needed
+    int32_t padding = 60 - sizeof(header_); // EthernetII min size is 60, padding is sometimes needed
     if (inner_pdu()) {
         padding -= inner_pdu()->size();
         padding = std::max(0, padding);
@@ -111,9 +108,10 @@ uint32_t EthernetII::trailer_size() const {
     return padding;
 }
 
-void EthernetII::send(PacketSender &sender, const NetworkInterface &iface) {
-    if(!iface)
+void EthernetII::send(PacketSender& sender, const NetworkInterface& iface) {
+    if (!iface) {
         throw invalid_interface();
+    }
     #if defined(HAVE_PACKET_SENDER_PCAP_SENDPACKET) || defined(BSD) || defined(__FreeBSD_kernel__)
         // Sending using pcap_sendpacket/BSD bpf packet mode is the same here
         sender.send_l2(*this, 0, 0, iface);
@@ -130,27 +128,30 @@ void EthernetII::send(PacketSender &sender, const NetworkInterface &iface) {
         addr.sll_protocol = Endian::host_to_be<uint16_t>(ETH_P_ALL);
         addr.sll_halen = address_type::address_size;
         addr.sll_ifindex = iface.id();
-        memcpy(&(addr.sll_addr), _eth.dst_mac, address_type::address_size);
+        memcpy(&(addr.sll_addr), header_.dst_mac, address_type::address_size);
 
         sender.send_l2(*this, (struct sockaddr*)&addr, (uint32_t)sizeof(addr));
     #endif
 }
 
-bool EthernetII::matches_response(const uint8_t *ptr, uint32_t total_sz) const {
-    if(total_sz < sizeof(ethhdr))
+bool EthernetII::matches_response(const uint8_t* ptr, uint32_t total_sz) const {
+    if (total_sz < sizeof(header_)) {
         return false;
+    }
     const size_t addr_sz = address_type::address_size;
-    const ethhdr *eth_ptr = (const ethhdr*)ptr;
-    if(std::equal(_eth.src_mac, _eth.src_mac + addr_sz, eth_ptr->dst_mac)) {
-        if(std::equal(_eth.src_mac, _eth.src_mac + addr_sz, eth_ptr->dst_mac) || !dst_addr().is_unicast())
-        {
-            return (inner_pdu()) ? inner_pdu()->matches_response(ptr + sizeof(_eth), total_sz - sizeof(_eth)) : true;
+    const ethernet_header* eth_ptr = (const ethernet_header*)ptr;
+    if (equal(header_.src_mac, header_.src_mac + addr_sz, eth_ptr->dst_mac)) {
+        if (equal(header_.src_mac, header_.src_mac + addr_sz, eth_ptr->dst_mac) || 
+           !dst_addr().is_unicast()) {
+            return inner_pdu() ? 
+                   inner_pdu()->matches_response(ptr + sizeof(header_), total_sz - sizeof(header_)) : 
+                   true;
         }
     }
     return false;
 }
 
-void EthernetII::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent) {
+void EthernetII::write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent) {
     OutputMemoryStream stream(buffer, total_sz);
     if (inner_pdu()) {
         Constants::Ethernet::e flag;
@@ -168,7 +169,7 @@ void EthernetII::write_serialization(uint8_t *buffer, uint32_t total_sz, const P
             payload_type(static_cast<uint16_t>(flag));
         }
     }
-    stream.write(_eth);
+    stream.write(header_);
     const uint32_t trailer = trailer_size();
     if (trailer) {
         if (inner_pdu()) {
@@ -180,7 +181,7 @@ void EthernetII::write_serialization(uint8_t *buffer, uint32_t total_sz, const P
 }
 
 #ifndef _WIN32
-PDU *EthernetII::recv_response(PacketSender &sender, const NetworkInterface &iface) {
+PDU* EthernetII::recv_response(PacketSender& sender, const NetworkInterface& iface) {
     #if !defined(BSD) && !defined(__FreeBSD_kernel__)
         struct sockaddr_ll addr;
         memset(&addr, 0, sizeof(struct sockaddr_ll));
@@ -189,7 +190,7 @@ PDU *EthernetII::recv_response(PacketSender &sender, const NetworkInterface &ifa
         addr.sll_protocol = Endian::host_to_be<uint16_t>(ETH_P_ALL);
         addr.sll_halen = address_type::address_size;
         addr.sll_ifindex = iface.id();
-        memcpy(&(addr.sll_addr), _eth.dst_mac, address_type::address_size);
+        memcpy(&(addr.sll_addr), header_.dst_mac, address_type::address_size);
 
         return sender.recv_l2(*this, (struct sockaddr*)&addr, (uint32_t)sizeof(addr));
     #else
diff --git a/src/handshake_capturer.cpp b/src/handshake_capturer.cpp
index 0baaa47..d6b0bd1 100644
--- a/src/handshake_capturer.cpp
+++ b/src/handshake_capturer.cpp
@@ -33,68 +33,77 @@
 
 #include "dot11/dot11_data.h"
 
+using std::max_element;
+using std::pair;
+
 namespace Tins {
-    bool RSNHandshakeCapturer::process_packet(const PDU &pdu) {
-        const RSNEAPOL *eapol = pdu.find_pdu<RSNEAPOL>();
-        const Dot11Data *dot11 = pdu.find_pdu<Dot11Data>();
-        if(!eapol || !dot11)
-            return false;
-        
-        
-        std::pair<address_type, address_type> addresses;
-        if(dot11->to_ds()) {
-            addresses.first = dot11->addr1();
-            addresses.second = dot11->addr2();
-        }
-        else if(dot11->from_ds()) {
-            addresses.first = dot11->addr2();
-            addresses.second = dot11->addr1();
-        }
-        else
-            return false;
-            
-        // 1st    
-        if(eapol->key_t() && eapol->key_ack() && !eapol->key_mic() && !eapol->install()) {
-            handshakes_[addresses].assign(eapol, eapol + 1);
-        }
-        else if(eapol->key_t() && eapol->key_mic() && !eapol->install() && !eapol->key_ack()) {
-            if(*std::max_element(eapol->nonce(), eapol->nonce() + RSNEAPOL::nonce_size) > 0)
-                do_insert(addresses, eapol, 1);
-            else if(do_insert(addresses, eapol, 3)) {
-                completed_handshakes_.push_back(
-                    handshake_type(
-                        addresses.first,
-                        addresses.second,
-                        handshakes_[addresses]
-                    )
-                );
-                handshakes_.erase(addresses);
-                return true;
-            }
-        }
-        else if(eapol->key_t() && eapol->install() && eapol->key_ack() && eapol->key_mic()) {
-            do_insert(addresses, eapol, 2);
-        }
+
+bool RSNHandshakeCapturer::process_packet(const PDU& pdu) {
+    const RSNEAPOL* eapol = pdu.find_pdu<RSNEAPOL>();
+    const Dot11Data* dot11 = pdu.find_pdu<Dot11Data>();
+    if (!eapol || !dot11) {
         return false;
     }
     
-    bool RSNHandshakeCapturer::do_insert(const handshake_map::key_type &key, 
-      const RSNEAPOL *eapol, size_t expected)
-    {
-        handshake_map::iterator iter = handshakes_.find(key);
-        if(iter != handshakes_.end()) {
-            if(iter->second.size() != expected) {
-                // skip repeated
-                if(iter->second.size() != expected + 1)
-                    iter->second.clear();
-            }
-            else {
-                iter->second.push_back(*eapol);
-                return true;
-            }
-        }
+    
+    pair<address_type, address_type> addresses;
+    if (dot11->to_ds()) {
+        addresses.first = dot11->addr1();
+        addresses.second = dot11->addr2();
+    }
+    else if (dot11->from_ds()) {
+        addresses.first = dot11->addr2();
+        addresses.second = dot11->addr1();
+    }
+    else {
         return false;
     }
+        
+    // 1st    
+    if (eapol->key_t() && eapol->key_ack() && !eapol->key_mic() && !eapol->install()) {
+        handshakes_[addresses].assign(eapol, eapol + 1);
+    }
+    else if (eapol->key_t() && eapol->key_mic() && !eapol->install() && !eapol->key_ack()) {
+        if (*max_element(eapol->nonce(), eapol->nonce() + RSNEAPOL::nonce_size) > 0) {
+            do_insert(addresses, eapol, 1);
+        }
+        else if (do_insert(addresses, eapol, 3)) {
+            completed_handshakes_.push_back(
+                handshake_type(
+                    addresses.first,
+                    addresses.second,
+                    handshakes_[addresses]
+                )
+            );
+            handshakes_.erase(addresses);
+            return true;
+        }
+    }
+    else if (eapol->key_t() && eapol->install() && eapol->key_ack() && eapol->key_mic()) {
+        do_insert(addresses, eapol, 2);
+    }
+    return false;
+}
+
+bool RSNHandshakeCapturer::do_insert(const handshake_map::key_type& key,
+                                     const RSNEAPOL* eapol,
+                                     size_t expected) {
+    handshake_map::iterator iter = handshakes_.find(key);
+    if (iter != handshakes_.end()) {
+        if (iter->second.size() != expected) {
+            // skip repeated
+            if (iter->second.size() != expected + 1) {
+                iter->second.clear();
+            }
+        }
+        else {
+            iter->second.push_back(*eapol);
+            return true;
+        }
+    }
+    return false;
+}
+
 } // namespace Tins;
 
 #endif // HAVE_DOT11
diff --git a/src/icmp.cpp b/src/icmp.cpp
index ef12b4b..7f9ac37 100644
--- a/src/icmp.cpp
+++ b/src/icmp.cpp
@@ -38,28 +38,29 @@
 #include "icmp.h"
 #include "memory_helpers.h"
 
+using std::memset;
+using std::max;
+
 using Tins::Memory::InputMemoryStream;
 using Tins::Memory::OutputMemoryStream;
 
 namespace Tins {
 
 ICMP::ICMP(Flags flag) 
-: _orig_timestamp_or_address_mask(), _recv_timestamp(), _trans_timestamp()
-{
-    std::memset(&_icmp, 0, sizeof(icmphdr));
+: orig_timestamp_or_address_mask_(), recv_timestamp_(), trans_timestamp_() {
+    memset(&header_, 0, sizeof(icmp_header));
     type(flag);
 }
 
-ICMP::ICMP(const uint8_t *buffer, uint32_t total_sz) 
-{
+ICMP::ICMP(const uint8_t* buffer, uint32_t total_sz) {
     InputMemoryStream stream(buffer, total_sz);
-    stream.read(_icmp);
-    if(type() == TIMESTAMP_REQUEST || type() == TIMESTAMP_REPLY) {
+    stream.read(header_);
+    if (type() == TIMESTAMP_REQUEST || type() == TIMESTAMP_REPLY) {
         original_timestamp(stream.read<uint32_t>());
         receive_timestamp(stream.read<uint32_t>());
         transmit_timestamp(stream.read<uint32_t>());
     }
-    else if(type() == ADDRESS_MASK_REQUEST || type() == ADDRESS_MASK_REPLY) {
+    else if (type() == ADDRESS_MASK_REQUEST || type() == ADDRESS_MASK_REPLY) {
         address_mask(address_type(stream.read<uint32_t>()));
     }
     // Attempt to parse ICMP extensions
@@ -70,61 +71,63 @@ ICMP::ICMP(const uint8_t *buffer, uint32_t total_sz)
 }
 
 void ICMP::code(uint8_t new_code) {
-    _icmp.code = new_code;
+    header_.code = new_code;
 }
 
 void ICMP::type(Flags new_type) {
-    _icmp.type = new_type;
+    header_.type = new_type;
 }
 
 void ICMP::checksum(uint16_t new_check) {
-    _icmp.check = Endian::host_to_be(new_check);
+    header_.check = Endian::host_to_be(new_check);
 }
 
 void ICMP::id(uint16_t new_id) {
-    _icmp.un.echo.id = Endian::host_to_be(new_id);
+    header_.un.echo.id = Endian::host_to_be(new_id);
 }
 
 void ICMP::sequence(uint16_t new_seq) {
-    _icmp.un.echo.sequence = Endian::host_to_be(new_seq);
+    header_.un.echo.sequence = Endian::host_to_be(new_seq);
 }
 
 void ICMP::gateway(address_type new_gw) {
-    _icmp.un.gateway = Endian::host_to_be(static_cast<uint32_t>(new_gw));
+    header_.un.gateway = Endian::host_to_be(static_cast<uint32_t>(new_gw));
 }
 
 void ICMP::mtu(uint16_t new_mtu) {
-    _icmp.un.frag.mtu = Endian::host_to_be(new_mtu);
+    header_.un.frag.mtu = Endian::host_to_be(new_mtu);
 }
 
 void ICMP::pointer(uint8_t new_pointer) {
-    _icmp.un.rfc4884.pointer = new_pointer;
+    header_.un.rfc4884.pointer = new_pointer;
 }
 
 void ICMP::original_timestamp(uint32_t new_timestamp) {
-    _orig_timestamp_or_address_mask = Endian::host_to_be(new_timestamp);
+    orig_timestamp_or_address_mask_ = Endian::host_to_be(new_timestamp);
 }
 
 void ICMP::receive_timestamp(uint32_t new_timestamp) {
-    _recv_timestamp = Endian::host_to_be(new_timestamp);
+    recv_timestamp_ = Endian::host_to_be(new_timestamp);
 }
 
 void ICMP::transmit_timestamp(uint32_t new_timestamp) {
-    _trans_timestamp = Endian::host_to_be(new_timestamp);
+    trans_timestamp_ = Endian::host_to_be(new_timestamp);
 }
 
 void ICMP::address_mask(address_type new_mask) {
-    _orig_timestamp_or_address_mask = Endian::host_to_be(static_cast<uint32_t>(new_mask));
+    orig_timestamp_or_address_mask_ = Endian::host_to_be(static_cast<uint32_t>(new_mask));
 }
 
 uint32_t ICMP::header_size() const {
     uint32_t extra = 0;
-    if(type() == TIMESTAMP_REQUEST || type() == TIMESTAMP_REPLY) 
+    if (type() == TIMESTAMP_REQUEST || type() == TIMESTAMP_REPLY) {
         extra = sizeof(uint32_t) * 3;
-    else if(type() == ADDRESS_MASK_REQUEST || type() == ADDRESS_MASK_REPLY) 
+    }
+    else if (type() == ADDRESS_MASK_REQUEST || type() == ADDRESS_MASK_REPLY)  {
         extra = sizeof(uint32_t);
+    }
 
-    return sizeof(icmphdr) + extra;
+    return sizeof(icmp_header) + extra;
 }
 
 uint32_t ICMP::trailer_size() const {
@@ -136,7 +139,7 @@ uint32_t ICMP::trailer_size() const {
             // If the next pdu size is lower than 128 bytes, then padding = 128 - pdu size
             // If the next pdu size is greater than 128 bytes, 
             // then padding = pdu size padded to next 32 bit boundary - pdu size
-            const uint32_t upper_bound = std::max(get_adjusted_inner_pdu_size(), 128U);
+            const uint32_t upper_bound = max(get_adjusted_inner_pdu_size(), 128U);
             output += upper_bound - inner_pdu()->size();
         }
     }
@@ -180,12 +183,13 @@ void ICMP::set_time_exceeded(bool ttl_exceeded) {
 
 void ICMP::set_param_problem(bool set_pointer, uint8_t bad_octet) {
     type(PARAM_PROBLEM);
-    if(set_pointer) {
+    if (set_pointer) {
         code(0);
         pointer(bad_octet);
     }
-    else
+    else {
         code(1);
+    }
 }
 
 void ICMP::set_source_quench() {
@@ -201,10 +205,10 @@ void ICMP::set_redirect(uint8_t icode, address_type address) {
 void ICMP::use_length_field(bool value) {
     // We just need a non 0 value here, we'll use the right value on 
     // write_serialization
-    _icmp.un.rfc4884.length = value ? 1 : 0;
+    header_.un.rfc4884.length = value ? 1 : 0;
 }
 
-void ICMP::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *) {
+void ICMP::write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU *) {
     OutputMemoryStream stream(buffer, total_sz);
 
     // If extensions are allowed and we have to set the length field
@@ -215,32 +219,32 @@ void ICMP::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *)
             if (length_value) {
                 // If we have extensions, we'll have at least 128 bytes.
                 // Otherwise, just use the length 
-                length_value = has_extensions() ? std::max(length_value, 128U) 
+                length_value = has_extensions() ? max(length_value, 128U) 
                                                 : length_value;
             }
             else {
                 length_value = 0;
             }
             // This field uses 32 bit words as the unit
-            _icmp.un.rfc4884.length = length_value / sizeof(uint32_t);
+            header_.un.rfc4884.length = length_value / sizeof(uint32_t);
         }
     }
 
     // Write the header using checksum 0
-    _icmp.check = 0;
-    stream.write(_icmp);
+    header_.check = 0;
+    stream.write(header_);
 
-    if(type() == TIMESTAMP_REQUEST || type() == TIMESTAMP_REPLY) {
+    if (type() == TIMESTAMP_REQUEST || type() == TIMESTAMP_REPLY) {
         stream.write(original_timestamp());
         stream.write(receive_timestamp());
         stream.write(transmit_timestamp());
     }
-    else if(type() == ADDRESS_MASK_REQUEST || type() == ADDRESS_MASK_REPLY) {
+    else if (type() == ADDRESS_MASK_REQUEST || type() == ADDRESS_MASK_REPLY) {
         stream.write(address_mask());
     }
 
     if (has_extensions()) {
-        uint8_t* extensions_ptr = buffer + sizeof(icmphdr);
+        uint8_t* extensions_ptr = buffer + sizeof(icmp_header);
         if (inner_pdu()) {
             // Get the size of the next pdu, padded to the next 32 bit boundary
             uint32_t inner_pdu_size = get_adjusted_inner_pdu_size();
@@ -267,8 +271,8 @@ void ICMP::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *)
         checksum = (checksum & 0xffff) + (checksum >> 16);
     }
     // Write back only the 2 checksum bytes
-    _icmp.check = ~checksum;
-    memcpy(buffer + 2, &_icmp.check, sizeof(uint16_t));
+    header_.check = ~checksum;
+    memcpy(buffer + 2, &header_.check, sizeof(uint16_t));
 }
 
 uint32_t ICMP::get_adjusted_inner_pdu_size() const {
@@ -288,15 +292,18 @@ bool ICMP::are_extensions_allowed() const {
     return type() == DEST_UNREACHABLE || type() == TIME_EXCEEDED || type() == PARAM_PROBLEM;
 }
 
-bool ICMP::matches_response(const uint8_t *ptr, uint32_t total_sz) const {
-    if(total_sz < sizeof(icmphdr))
+bool ICMP::matches_response(const uint8_t* ptr, uint32_t total_sz) const {
+    if (total_sz < sizeof(icmp_header)) {
         return false;
-    const icmphdr *icmp_ptr = (const icmphdr*)ptr;
-    if((_icmp.type == ECHO_REQUEST && icmp_ptr->type == ECHO_REPLY) || 
-        (_icmp.type == TIMESTAMP_REQUEST && icmp_ptr->type == TIMESTAMP_REPLY) ||
-        (_icmp.type == ADDRESS_MASK_REQUEST && icmp_ptr->type == ADDRESS_MASK_REPLY)) {
-        return icmp_ptr->un.echo.id == _icmp.un.echo.id && icmp_ptr->un.echo.sequence == _icmp.un.echo.sequence;
+    }
+    const icmp_header* icmp_ptr = (const icmp_header*)ptr;
+    if ((header_.type == ECHO_REQUEST && icmp_ptr->type == ECHO_REPLY) || 
+        (header_.type == TIMESTAMP_REQUEST && icmp_ptr->type == TIMESTAMP_REPLY) ||
+        (header_.type == ADDRESS_MASK_REQUEST && icmp_ptr->type == ADDRESS_MASK_REPLY)) {
+        return icmp_ptr->un.echo.id == header_.un.echo.id && 
+               icmp_ptr->un.echo.sequence == header_.un.echo.sequence;
     }
     return false;
 }
+
 } // namespace Tins
diff --git a/src/icmp_extension.cpp b/src/icmp_extension.cpp
index 0034068..f791000 100644
--- a/src/icmp_extension.cpp
+++ b/src/icmp_extension.cpp
@@ -60,7 +60,7 @@ ICMPExtension::ICMPExtension(uint8_t ext_class, uint8_t ext_type)
 ICMPExtension::ICMPExtension(const uint8_t* buffer, uint32_t total_sz) {
     InputMemoryStream stream(buffer, total_sz);
 
-    uint16_t length = Endian::be_to_host(stream.read<uint16_t>());
+    uint16_t length = stream.read_be<uint16_t>();
     extension_class_ = stream.read<uint8_t>();
     extension_type_ = stream.read<uint8_t>();
     // Length is BASE_HEADER_SIZE + payload size, make sure it's valid
@@ -68,7 +68,7 @@ ICMPExtension::ICMPExtension(const uint8_t* buffer, uint32_t total_sz) {
         throw malformed_packet();
     }
     length -= BASE_HEADER_SIZE;
-    payload_.assign(stream.pointer(), stream.pointer() + length);
+    stream.read(payload_, length);
 }
 
 void ICMPExtension::extension_class(uint8_t value) {
@@ -89,7 +89,7 @@ uint32_t ICMPExtension::size() const {
 
 void ICMPExtension::serialize(uint8_t* buffer, uint32_t buffer_size) const {
     OutputMemoryStream stream(buffer, buffer_size);
-    stream.write(Endian::host_to_be<uint16_t>(size()));
+    stream.write_be<uint16_t>(size());
     stream.write(extension_class_);
     stream.write(extension_type_);
     stream.write(payload_.begin(), payload_.end());
@@ -118,7 +118,7 @@ ICMPExtensionsStructure::ICMPExtensionsStructure(const uint8_t* buffer, uint32_t
     checksum_ = stream.read<uint16_t>();
     while (stream) {
         extensions_.push_back(ICMPExtension(stream.pointer(), stream.size()));
-        uint16_t size = Endian::be_to_host(stream.read<uint16_t>());
+        uint16_t size = stream.read_be<uint16_t>();
         stream.skip(size - sizeof(uint16_t));
     }
 }
diff --git a/src/icmpv6.cpp b/src/icmpv6.cpp
index b48827a..10c97f5 100644
--- a/src/icmpv6.cpp
+++ b/src/icmpv6.cpp
@@ -36,35 +36,38 @@
 #include "exceptions.h"
 #include "memory_helpers.h"
 
+using std::memset;
+using std::vector;
+using std::string;
+using std::max;
+
 using Tins::Memory::InputMemoryStream;
 using Tins::Memory::OutputMemoryStream;
 
 namespace Tins {
 
 ICMPv6::ICMPv6(Types tp)
-: _options_size(), reach_time(0), retrans_timer(0)
-{
-    std::memset(&_header, 0, sizeof(_header));
+: options_size_(), reach_time_(0), retrans_timer_(0) {
+    memset(&header_, 0, sizeof(header_));
     type(tp);
 }
 
-ICMPv6::ICMPv6(const uint8_t *buffer, uint32_t total_sz) 
-: _options_size(), reach_time(0), retrans_timer(0)
-{
+ICMPv6::ICMPv6(const uint8_t* buffer, uint32_t total_sz) 
+: options_size_(), reach_time_(0), retrans_timer_(0) {
     InputMemoryStream stream(buffer, total_sz);
-    stream.read(_header);
+    stream.read(header_);
     if (has_target_addr()) {
-        _target_address = stream.read<ipaddress_type>();
+        target_address_ = stream.read<ipaddress_type>();
     }
     if (has_dest_addr()) {
-        _dest_address = stream.read<ipaddress_type>();
+        dest_address_ = stream.read<ipaddress_type>();
     }
     if (type() == ROUTER_ADVERT) {
-        reach_time = stream.read<uint32_t>();
-        retrans_timer = stream.read<uint32_t>();
+        reach_time_ = stream.read<uint32_t>();
+        retrans_timer_ = stream.read<uint32_t>();
     }
     else if (type() == MLD2_REPORT) {
-        uint16_t record_count = Endian::be_to_host(_header.mlrm2.record_count);
+        uint16_t record_count = Endian::be_to_host(header_.mlrm2.record_count);
         for (uint16_t i = 0; i < record_count; ++i) {
             multicast_records_.push_back(
                 multicast_address_record(stream.pointer(), stream.size())
@@ -107,84 +110,84 @@ void ICMPv6::parse_options(InputMemoryStream& stream) {
 }
 
 void ICMPv6::type(Types new_type) {
-    _header.type = new_type;
+    header_.type = new_type;
 }
 
 void ICMPv6::code(uint8_t new_code) {
-    _header.code = new_code;
+    header_.code = new_code;
 }
 
 void ICMPv6::checksum(uint16_t new_cksum) {
-    _header.cksum = Endian::host_to_be(new_cksum);
+    header_.cksum = Endian::host_to_be(new_cksum);
 }
 
 void ICMPv6::identifier(uint16_t new_identifier) {
-    _header.u_echo.identifier = Endian::host_to_be(new_identifier);
+    header_.u_echo.identifier = Endian::host_to_be(new_identifier);
 }
 
 void ICMPv6::sequence(uint16_t new_sequence) {
-    _header.u_echo.sequence = Endian::host_to_be(new_sequence);
+    header_.u_echo.sequence = Endian::host_to_be(new_sequence);
 }
 
 void ICMPv6::override(small_uint<1> new_override) {
-    _header.u_nd_advt.override = new_override;
+    header_.u_nd_advt.override = new_override;
 }
 
 void ICMPv6::solicited(small_uint<1> new_solicited) {
-    _header.u_nd_advt.solicited = new_solicited;
+    header_.u_nd_advt.solicited = new_solicited;
 }
 
 void ICMPv6::router(small_uint<1> new_router) {
-    _header.u_nd_advt.router = new_router;
+    header_.u_nd_advt.router = new_router;
 }
 
 void ICMPv6::hop_limit(uint8_t new_hop_limit) {
-    _header.u_nd_ra.hop_limit = new_hop_limit;
+    header_.u_nd_ra.hop_limit = new_hop_limit;
 }
 
 void ICMPv6::router_pref(small_uint<2> new_router_pref) {
-    _header.u_nd_ra.router_pref = new_router_pref;
+    header_.u_nd_ra.router_pref = new_router_pref;
 }
 
 void ICMPv6::home_agent(small_uint<1> new_home_agent) {
-    _header.u_nd_ra.home_agent = new_home_agent;
+    header_.u_nd_ra.home_agent = new_home_agent;
 }
 
 void ICMPv6::other(small_uint<1> new_other) {
-    _header.u_nd_ra.other = new_other;
+    header_.u_nd_ra.other = new_other;
 }
 
 void ICMPv6::managed(small_uint<1> new_managed) {
-    _header.u_nd_ra.managed = new_managed;
+    header_.u_nd_ra.managed = new_managed;
 }
 
 void ICMPv6::router_lifetime(uint16_t new_router_lifetime) {
-    _header.u_nd_ra.router_lifetime = Endian::host_to_be(new_router_lifetime);
+    header_.u_nd_ra.router_lifetime = Endian::host_to_be(new_router_lifetime);
 }
 
 void ICMPv6::reachable_time(uint32_t new_reachable_time) {
-    reach_time = Endian::host_to_be(new_reachable_time);
+    reach_time_ = Endian::host_to_be(new_reachable_time);
 }
 
-void ICMPv6::retransmit_timer(uint32_t new_retrans_timer) {
-    retrans_timer = Endian::host_to_be(new_retrans_timer);
+void ICMPv6::retransmit_timer(uint32_t new_retrans_timer_) {
+    retrans_timer_ = Endian::host_to_be(new_retrans_timer_);
 }
 
 void ICMPv6::multicast_address_records(const multicast_address_records_list& records) {
     multicast_records_ = records;
 }
 
-void ICMPv6::target_addr(const ipaddress_type &new_target_addr) {
-    _target_address = new_target_addr;
+void ICMPv6::target_addr(const ipaddress_type& new_target_addr) {
+    target_address_ = new_target_addr;
 }
 
-void ICMPv6::dest_addr(const ipaddress_type &new_dest_addr) {
-    _dest_address = new_dest_addr;
+void ICMPv6::dest_addr(const ipaddress_type& new_dest_addr) {
+    dest_address_ = new_dest_addr;
 }
 
 uint32_t ICMPv6::header_size() const {
     uint32_t extra = 0;
-    if(type() == ROUTER_ADVERT) {
+    if (type() == ROUTER_ADVERT) {
         extra = sizeof(uint32_t) * 2;
     }
     else if (type() == MLD2_REPORT) {
@@ -194,7 +197,7 @@ uint32_t ICMPv6::header_size() const {
             extra += iter->size();
         }
     }
-    return sizeof(_header) + _options_size + extra + 
+    return sizeof(header_) + options_size_ + extra + 
         (has_target_addr() ? ipaddress_type::address_size : 0) +
         (has_dest_addr() ? ipaddress_type::address_size : 0);
 }
@@ -208,7 +211,7 @@ uint32_t ICMPv6::trailer_size() const {
             // If the next pdu size is lower than 128 bytes, then padding = 128 - pdu size
             // If the next pdu size is greater than 128 bytes, 
             // then padding = pdu size padded to next 32 bit boundary - pdu size
-            const uint32_t upper_bound = std::max(get_adjusted_inner_pdu_size(), 128U);
+            const uint32_t upper_bound = max(get_adjusted_inner_pdu_size(), 128U);
             output += upper_bound - inner_pdu()->size();
         }
     }
@@ -218,20 +221,22 @@ uint32_t ICMPv6::trailer_size() const {
 void ICMPv6::use_length_field(bool value) {
     // We just need a non 0 value here, we'll use the right value on 
     // write_serialization
-    _header.rfc4884.length = value ? 1 : 0;
+    header_.rfc4884.length = value ? 1 : 0;
 }
 
-bool ICMPv6::matches_response(const uint8_t *ptr, uint32_t total_sz) const {
-    if(total_sz < sizeof(icmp6hdr))
+bool ICMPv6::matches_response(const uint8_t* ptr, uint32_t total_sz) const {
+    if (total_sz < sizeof(header_)) {
         return false;
-    const icmp6hdr *hdr_ptr = (const icmp6hdr*)ptr;
-    if(type() == ECHO_REQUEST && hdr_ptr->type == ECHO_REPLY)
-        return hdr_ptr->u_echo.identifier == _header.u_echo.identifier &&
-                hdr_ptr->u_echo.sequence == _header.u_echo.sequence;
+    }
+    const icmp6_header* hdr_ptr = (const icmp6_header*)ptr;
+    if (type() == ECHO_REQUEST && hdr_ptr->type == ECHO_REPLY) {
+        return hdr_ptr->u_echo.identifier == header_.u_echo.identifier &&
+               hdr_ptr->u_echo.sequence == header_.u_echo.sequence;
+    }
     return false;
 }
 
-void ICMPv6::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent) {
+void ICMPv6::write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent) {
     OutputMemoryStream stream(buffer, total_sz);
 
     // If extensions are allowed and we have to set the length field
@@ -239,28 +244,28 @@ void ICMPv6::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *
         uint32_t length_value = get_adjusted_inner_pdu_size();
         // If the next pdu size is greater than 128, we are forced to set the length field
         if (length() != 0 || length_value > 128) {
-            length_value = length_value ? std::max(length_value, 128U) : 0;
+            length_value = length_value ? max(length_value, 128U) : 0;
             // This field uses 64 bit words as the unit
-            _header.rfc4884.length = length_value / sizeof(uint64_t);
+            header_.rfc4884.length = length_value / sizeof(uint64_t);
         }
     }
     // Initially set checksum to 0, we'll calculate it at the end
-    _header.cksum = 0;
+    header_.cksum = 0;
     // Update the MLRM record count before writing the header
     if (type() == MLD2_REPORT) {
-        _header.mlrm2.record_count = Endian::host_to_be<uint16_t>(multicast_records_.size());
+        header_.mlrm2.record_count = Endian::host_to_be<uint16_t>(multicast_records_.size());
     }
-    stream.write(_header);
+    stream.write(header_);
 
     if (has_target_addr()) {
-        stream.write(_target_address);
+        stream.write(target_address_);
     }
     if (has_dest_addr()) {
-        stream.write(_dest_address);
+        stream.write(dest_address_);
     }
     if (type() == ROUTER_ADVERT) {
-        stream.write(reach_time);
-        stream.write(retrans_timer);
+        stream.write(reach_time_);
+        stream.write(retrans_timer_);
     }
     else if (type() == MLD2_REPORT) {
         typedef multicast_address_records_list::const_iterator iterator;
@@ -270,7 +275,7 @@ void ICMPv6::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *
             stream.skip(iter->size());
         }
     }
-    for(options_type::const_iterator it = _options.begin(); it != _options.end(); ++it) {
+    for (options_type::const_iterator it = options_.begin(); it != options_.end(); ++it) {
         write_option(*it, stream);
     }
 
@@ -300,7 +305,7 @@ void ICMPv6::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *
         );
     }
 
-    const Tins::IPv6 *ipv6 = tins_cast<const Tins::IPv6*>(parent);
+    const Tins::IPv6* ipv6 = tins_cast<const Tins::IPv6*>(parent);
     if (ipv6) {
         uint32_t checksum = Utils::pseudoheader_checksum(
             ipv6->src_addr(),  
@@ -311,11 +316,19 @@ void ICMPv6::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *
         while (checksum >> 16) {
             checksum = (checksum & 0xffff) + (checksum >> 16);
         }
-        this->checksum(Endian::host_to_be<uint16_t>(~checksum));
-        memcpy(buffer + 2, &_header.cksum, sizeof(uint16_t));
+        header_.cksum = ~checksum & 0xffff;
+        memcpy(buffer + 2, &header_.cksum, sizeof(uint16_t));
     }
 }
 
+uint8_t ICMPv6::get_option_padding(uint32_t data_size) {
+    uint8_t padding = 8 - data_size % 8;
+    if (padding == 8) {
+        padding = 0;
+    }
+    return padding;
+}
+
 // can i haz more?
 bool ICMPv6::has_options() const {
     switch (type()) {
@@ -330,70 +343,68 @@ bool ICMPv6::has_options() const {
     }
 }
 
-void ICMPv6::add_option(const option &option) {
+void ICMPv6::add_option(const option& option) {
     internal_add_option(option);
-    _options.push_back(option);
+    options_.push_back(option);
 }
 
-void ICMPv6::internal_add_option(const option &option) {
-    _options_size += static_cast<uint32_t>(option.data_size() + sizeof(uint8_t) * 2);
+void ICMPv6::internal_add_option(const option& option) {
+    options_size_ += static_cast<uint32_t>(option.data_size() + sizeof(uint8_t) * 2);
 }
 
 bool ICMPv6::remove_option(OptionTypes type) {
     options_type::iterator iter = search_option_iterator(type);
-    if (iter == _options.end()) {
+    if (iter == options_.end()) {
         return false;
     }
-    _options_size -= static_cast<uint32_t>(iter->data_size() + sizeof(uint8_t) * 2);
-    _options.erase(iter);
+    options_size_ -= static_cast<uint32_t>(iter->data_size() + sizeof(uint8_t) * 2);
+    options_.erase(iter);
     return true;
 }
 
-void ICMPv6::write_option(const option &opt, OutputMemoryStream& stream) {
+void ICMPv6::write_option(const option& opt, OutputMemoryStream& stream) {
     stream.write(opt.option());
     stream.write<uint8_t>((opt.length_field() + sizeof(uint8_t) * 2) / 8);
     stream.write(opt.data_ptr(), opt.data_size());
 }
 
-const ICMPv6::option *ICMPv6::search_option(OptionTypes type) const {
+const ICMPv6::option* ICMPv6::search_option(OptionTypes type) const {
     // Search for the iterator. If we found something, return it, otherwise return nullptr.
     options_type::const_iterator iter = search_option_iterator(type);
-    return (iter != _options.end()) ? &*iter : 0;
+    return (iter != options_.end()) ? &*iter : 0;
 }
 
 ICMPv6::options_type::const_iterator ICMPv6::search_option_iterator(OptionTypes type) const {
     Internals::option_type_equality_comparator<option> comparator(type);
-    return find_if(_options.begin(), _options.end(), comparator);
+    return find_if(options_.begin(), options_.end(), comparator);
 }
 
 ICMPv6::options_type::iterator ICMPv6::search_option_iterator(OptionTypes type) {
     Internals::option_type_equality_comparator<option> comparator(type);
-    return find_if(_options.begin(), _options.end(), comparator);
+    return find_if(options_.begin(), options_.end(), comparator);
 }
 
 // ********************************************************************
 //                          Option setters
 // ********************************************************************
 
-void ICMPv6::source_link_layer_addr(const hwaddress_type &addr) {
+void ICMPv6::source_link_layer_addr(const hwaddress_type& addr) {
     add_option(option(SOURCE_ADDRESS, addr.begin(), addr.end()));
 }
 
-void ICMPv6::target_link_layer_addr(const hwaddress_type &addr) {
+void ICMPv6::target_link_layer_addr(const hwaddress_type& addr) {
     add_option(option(TARGET_ADDRESS, addr.begin(), addr.end()));
 }
 
 void ICMPv6::prefix_info(prefix_info_type info) {
     uint8_t buffer[2 + sizeof(uint32_t) * 3 + ipaddress_type::address_size];
-    buffer[0] = info.prefix_len;
-    buffer[1] = (info.L << 7) | (info.A << 6);
-    uint32_t uint32_t_buffer = Endian::host_to_be(info.valid_lifetime);
-    std::memcpy(buffer + 2, &uint32_t_buffer, sizeof(uint32_t));
-    uint32_t_buffer = Endian::host_to_be(info.preferred_lifetime);
-    std::memcpy(buffer + 2 + sizeof(uint32_t), &uint32_t_buffer, sizeof(uint32_t));
-    uint32_t_buffer = 0;
-    std::memcpy(buffer + 2 + sizeof(uint32_t) * 2, &uint32_t_buffer, sizeof(uint32_t));
-    info.prefix.copy(buffer + 2 + sizeof(uint32_t) * 3);
+    OutputMemoryStream stream(buffer, sizeof(buffer));
+    stream.write(info.prefix_len);
+    stream.write<uint8_t>((info.L << 7) | (info.A << 6));
+    stream.write_be(info.valid_lifetime);
+    stream.write_be(info.preferred_lifetime);
+    stream.write<uint32_t>(0);
+    stream.write(info.prefix);
     add_option(
         option(PREFIX_INFO, buffer, buffer + sizeof(buffer))
     );
@@ -404,262 +415,226 @@ void ICMPv6::redirect_header(const byte_array& data) {
 }
 
 void ICMPv6::mtu(const mtu_type& value) {
-    uint8_t buffer[sizeof(uint16_t) + sizeof(uint32_t)] = {0};
-    const uint16_t u16_tmp = value.first; 
-    const uint32_t u32_tmp = value.second; 
-    buffer[0] = u16_tmp >> 8;
-    buffer[1] = u16_tmp & 0xff;
-
-    buffer[2] = u32_tmp >> 24;
-    buffer[3] = u32_tmp >> 16;
-    buffer[4] = u32_tmp >> 8;
-    buffer[5] = u32_tmp & 0xff;
+    uint8_t buffer[sizeof(uint16_t) + sizeof(uint32_t)];
+    OutputMemoryStream stream(buffer, sizeof(buffer));
+    stream.write_be(value.first);
+    stream.write_be(value.second);
     add_option(option(MTU, sizeof(buffer), buffer));
 }
 
-void ICMPv6::shortcut_limit(const shortcut_limit_type &value) {
-    uint8_t buffer[sizeof(uint16_t) + sizeof(uint32_t)] = {0};
-    const uint32_t u32_tmp = value.reserved2; 
-    buffer[0] = value.limit;
-    buffer[1] = value.reserved1;
-    buffer[2] = u32_tmp >> 24;
-    buffer[3] = u32_tmp >> 16;
-    buffer[4] = u32_tmp >> 8;
-    buffer[5] = u32_tmp & 0xff;
+void ICMPv6::shortcut_limit(const shortcut_limit_type& value) {
+    uint8_t buffer[sizeof(uint16_t) + sizeof(uint32_t)];
+    OutputMemoryStream stream(buffer, sizeof(buffer));
+    stream.write(value.limit);
+    stream.write(value.reserved1);
+    stream.write_be(value.reserved2);
     add_option(option(NBMA_SHORT_LIMIT, sizeof(buffer), buffer));
 }
 
-void ICMPv6::new_advert_interval(const new_advert_interval_type &value) {
-    uint8_t buffer[sizeof(uint16_t) + sizeof(uint32_t)] = {0};
-    const uint16_t u16_tmp = value.reserved;
-    const uint32_t u32_tmp = value.interval;
-    buffer[0] = u16_tmp >> 8;
-    buffer[1] = u16_tmp & 0xff;
-
-    buffer[2] = u32_tmp >> 24;
-    buffer[3] = u32_tmp >> 16;
-    buffer[4] = u32_tmp >> 8;
-    buffer[5] = u32_tmp & 0xff;
+void ICMPv6::new_advert_interval(const new_advert_interval_type& value) {
+    uint8_t buffer[sizeof(uint16_t) + sizeof(uint32_t)];
+    OutputMemoryStream stream(buffer, sizeof(buffer));
+    stream.write_be(value.reserved);
+    stream.write_be(value.interval);
     add_option(option(ADVERT_INTERVAL, sizeof(buffer), buffer));
 }
 
-void ICMPv6::new_home_agent_info(const new_ha_info_type &value) {
-    if(value.size() != 3)
+void ICMPv6::new_home_agent_info(const new_ha_info_type& value) {
+    if (value.size() != 3) {
         throw malformed_option();
-    uint8_t buffer[sizeof(uint16_t) + sizeof(uint32_t)] = {0};
-    *((uint16_t*)(buffer + sizeof(uint16_t))) = Endian::host_to_be(value[0]);
-    *((uint16_t*)(buffer + sizeof(uint16_t))) = Endian::host_to_be(value[1]);
-    *((uint16_t*)(buffer + sizeof(uint16_t) * 2)) = Endian::host_to_be(value[2]);
+    }
+    uint8_t buffer[sizeof(uint16_t) * 3];
+    OutputMemoryStream stream(buffer, sizeof(buffer));
+    stream.write_be(value[0]);
+    stream.write_be(value[1]);
+    stream.write_be(value[2]);
     add_option(option(HOME_AGENT_INFO, sizeof(buffer), buffer));
 }
 
-void ICMPv6::source_addr_list(const addr_list_type &value) {
+void ICMPv6::source_addr_list(const addr_list_type& value) {
     add_addr_list(S_ADDRESS_LIST, value);
 }
 
-void ICMPv6::target_addr_list(const addr_list_type &value) {
+void ICMPv6::target_addr_list(const addr_list_type& value) {
     add_addr_list(T_ADDRESS_LIST, value);
 }
 
-void ICMPv6::add_addr_list(uint8_t type, const addr_list_type &value) {
-    typedef addr_list_type::addresses_type::const_iterator iterator;
-    
-    std::vector<uint8_t> buffer;
-    buffer.reserve(value.addresses.size() + 6);
-    buffer.insert(buffer.end(), value.reserved, value.reserved + 6);
-    for(iterator it = value.addresses.begin(); it != value.addresses.end(); ++it)
-        buffer.insert(buffer.end(), it->begin(), it->end());
+void ICMPv6::add_addr_list(uint8_t type, const addr_list_type& value) {
+    vector<uint8_t> buffer(value.addresses.size() * ipaddress_type::address_size + 6);
+    OutputMemoryStream stream(buffer);
+    stream.write(value.reserved, value.reserved + 6);
+    for (size_t i = 0; i < value.addresses.size(); ++i) {
+        stream.write(value.addresses[i]);
+    }
     add_option(option(type, buffer.begin(), buffer.end()));
 }
 
-void ICMPv6::rsa_signature(const rsa_sign_type &value) {
-    uint32_t total_sz = static_cast<uint32_t>(4 + sizeof(value.key_hash) + value.signature.size());
+void ICMPv6::rsa_signature(const rsa_sign_type& value) {
+    uint32_t total_sz = static_cast<uint32_t>(2 + sizeof(value.key_hash) + value.signature.size());
     uint8_t padding = 8 - total_sz % 8;
-    if(padding == 8)
+    if (padding == 8) {
         padding = 0;
-    std::vector<uint8_t> buffer;
-    buffer.reserve(total_sz + padding);
-    buffer.insert(buffer.end(), 2, 0);
-    buffer.insert(buffer.end(), value.key_hash, value.key_hash + sizeof(value.key_hash));
-    buffer.insert(buffer.end(), value.signature.begin(), value.signature.end());
-    buffer.insert(buffer.end(), padding, 0);
+    }
+    vector<uint8_t> buffer(total_sz + padding);
+    OutputMemoryStream stream(buffer);
+    stream.write<uint16_t>(0);
+    stream.write(value.key_hash, value.key_hash + sizeof(value.key_hash));
+    stream.write(value.signature.begin(), value.signature.end());
+    stream.fill(padding, 0);
     add_option(option(RSA_SIGN, buffer.begin(), buffer.end()));
 }
 
-void ICMPv6::timestamp(const timestamp_type &value) {
-    std::vector<uint8_t> buffer(6 + sizeof(uint64_t));
-    std::copy(value.reserved, value.reserved + 6, buffer.begin());
-    uint64_t uint64_t_buffer = Endian::host_to_be(value.timestamp);
-    memcpy(&buffer[6], &uint64_t_buffer, sizeof(uint64_t));
+void ICMPv6::timestamp(const timestamp_type& value) {
+    vector<uint8_t> buffer(6 + sizeof(uint64_t));
+    OutputMemoryStream stream(buffer);
+    stream.write(value.reserved, value.reserved + 6);
+    stream.write_be(value.timestamp);
     add_option(option(TIMESTAMP, buffer.begin(), buffer.end()));
 }
 
-void ICMPv6::nonce(const nonce_type &value) {
+void ICMPv6::nonce(const nonce_type& value) {
     add_option(option(NONCE, value.begin(), value.end()));
 }
 
-void ICMPv6::ip_prefix(const ip_prefix_type &value) {
-    std::vector<uint8_t> buffer;
-    buffer.reserve(6 + ipaddress_type::address_size);
-    buffer.push_back(value.option_code);
-    buffer.push_back(value.prefix_len);
+void ICMPv6::ip_prefix(const ip_prefix_type& value) {
+    vector<uint8_t> buffer(6 + ipaddress_type::address_size);
+    OutputMemoryStream stream(buffer);
+    stream.write(value.option_code);
+    stream.write(value.prefix_len);
     // reserved
-    buffer.insert(buffer.end(), sizeof(uint32_t), 0);
-    buffer.insert(buffer.end(), value.address.begin(), value.address.end());
+    stream.write<uint32_t>(0);
+    stream.write(value.address);
     add_option(option(IP_PREFIX, buffer.begin(), buffer.end()));
 }
 
 void ICMPv6::link_layer_addr(lladdr_type value) {
     value.address.insert(value.address.begin(), value.option_code);
-    uint8_t padding = 8 - (2 + value.address.size()) % 8;
-    if(padding == 8)
-        padding = 0;
+    uint8_t padding = get_option_padding(2 + value.address.size());
     value.address.insert(value.address.end(), padding, 0);
     add_option(option(LINK_ADDRESS, value.address.begin(), value.address.end()));
 }
 
-void ICMPv6::naack(const naack_type &value) {
+void ICMPv6::naack(const naack_type& value) {
     uint8_t buffer[6];
-    buffer[0] = value.code;
-    buffer[1] = value.status;
-    std::copy(value.reserved, value.reserved + 4, buffer + 2);
+    OutputMemoryStream stream(buffer, sizeof(buffer));
+    stream.write(value.code);
+    stream.write(value.status);
+    stream.write(value.reserved, value.reserved + 4);
     add_option(option(NAACK, buffer, buffer + sizeof(buffer)));
 }
 
-void ICMPv6::map(const map_type &value) {
+void ICMPv6::map(const map_type& value) {
     uint8_t buffer[sizeof(uint8_t) * 2 + sizeof(uint32_t) + ipaddress_type::address_size];
-    buffer[0] = value.dist << 4 | value.pref;
-    buffer[1] = value.r << 7;
-    uint32_t uint32_t_buffer = Endian::host_to_be(value.valid_lifetime);
-    std::memcpy(buffer + 2, &uint32_t_buffer, sizeof(uint32_t));
-    value.address.copy(buffer + 2 + sizeof(uint32_t));
+    OutputMemoryStream stream(buffer, sizeof(buffer));
+    stream.write<uint8_t>(value.dist << 4 | value.pref);
+    stream.write<uint8_t>(value.r << 7);
+    stream.write_be(value.valid_lifetime);
+    stream.write(value.address);
     add_option(option(MAP, buffer, buffer + sizeof(buffer)));
 }
 
-void ICMPv6::route_info(const route_info_type &value) {
-    uint8_t padding = 8 - value.prefix.size() % 8;
-    if(padding == 8)
-        padding = 0;
-    std::vector<uint8_t> buffer(2 + sizeof(uint32_t) + value.prefix.size() + padding);
-    buffer[0] = value.prefix_len;
-    buffer[1] = value.pref << 3;
-    uint32_t uint32_t_buffer = Endian::host_to_be(value.route_lifetime);
-    std::memcpy(&buffer[2], &uint32_t_buffer, sizeof(uint32_t));
+void ICMPv6::route_info(const route_info_type& value) {
+    uint8_t padding = get_option_padding(value.prefix.size());
+    vector<uint8_t> buffer(2 + sizeof(uint32_t) + value.prefix.size() + padding);
+    OutputMemoryStream stream(buffer);
+    stream.write(value.prefix_len);
+    stream.write<uint8_t>(value.pref << 3);
+    stream.write_be(value.route_lifetime);
     // copy the prefix and then fill with padding
-    buffer.insert(
-        std::copy(value.prefix.begin(), value.prefix.end(), buffer.begin() + 2 + sizeof(uint32_t)),
-        padding, 
-        0
-    );
+    stream.write(value.prefix.begin(), value.prefix.end());
+    stream.fill(padding, 0);
     add_option(option(ROUTE_INFO, buffer.begin(), buffer.end()));
 }
 
-void ICMPv6::recursive_dns_servers(const recursive_dns_type &value) {
-    std::vector<uint8_t> buffer(
+void ICMPv6::recursive_dns_servers(const recursive_dns_type& value) {
+    vector<uint8_t> buffer(
         2 + sizeof(uint32_t) + value.servers.size() * ipaddress_type::address_size
     );
+    OutputMemoryStream stream(buffer);
+    stream.write<uint8_t>(0);
+    stream.write<uint8_t>(0);
+    stream.write_be(value.lifetime);
     
-    buffer[0] = buffer[1] = 0;
-    uint32_t tmp_lifetime = Endian::host_to_be(value.lifetime);
-    std::memcpy(&buffer[2], &tmp_lifetime, sizeof(uint32_t));
-    std::vector<uint8_t>::iterator out = buffer.begin() + 2 + sizeof(uint32_t);
     typedef recursive_dns_type::servers_type::const_iterator iterator;
-    for(iterator it = value.servers.begin(); it != value.servers.end(); ++it)
-        out = it->copy(out);
+    for (iterator it = value.servers.begin(); it != value.servers.end(); ++it) {
+        stream.write(*it);
+    }
     add_option(option(RECURSIVE_DNS_SERV, buffer.begin(), buffer.end()));
 }
 
-void ICMPv6::handover_key_request(const handover_key_req_type &value) {
-    uint8_t padding = 8 - (value.key.size() + 4) % 8;
-    if(padding == 8)
-        padding = 0;
-    std::vector<uint8_t> buffer(2 + value.key.size() + padding);
-    buffer[0] = padding;
-    buffer[1] = value.AT << 4;
+void ICMPv6::handover_key_request(const handover_key_req_type& value) {
+    uint8_t padding = get_option_padding(value.key.size() + 4);
+    vector<uint8_t> buffer(2 + value.key.size() + padding);
+    OutputMemoryStream stream(buffer);
+    stream.write(padding);
+    stream.write<uint8_t>(value.AT << 4);
     // copy the key, and fill with padding
-    std::fill(
-        std::copy(value.key.begin(), value.key.end(), buffer.begin() + 2),
-        buffer.end(),
-        0
-    );
+    stream.write(value.key.begin(), value.key.end());
+    stream.fill(padding, 0);
     add_option(option(HANDOVER_KEY_REQ, buffer.begin(), buffer.end()));
 }
 
-void ICMPv6::handover_key_reply(const handover_key_reply_type &value) {
+void ICMPv6::handover_key_reply(const handover_key_reply_type& value) {
     const uint32_t data_size = static_cast<uint32_t>(value.key.size() + 2 + sizeof(uint16_t));
-    uint8_t padding = 8 - (data_size+2) % 8;
-    if(padding == 8)
-        padding = 0;
-    std::vector<uint8_t> buffer(data_size + padding);
-    buffer[0] = padding;
-    buffer[1] = value.AT << 4;
-    uint16_t tmp_lifetime = Endian::host_to_be(value.lifetime);
-    std::memcpy(&buffer[2], &tmp_lifetime, sizeof(uint16_t));
+    uint8_t padding = get_option_padding(data_size+2);
+    vector<uint8_t> buffer(data_size + padding);
+    OutputMemoryStream stream(buffer);
+    stream.write(padding);
+    stream.write<uint8_t>(value.AT << 4);
+    stream.write_be(value.lifetime);
     // copy the key, and fill with padding
-    std::fill(
-        std::copy(value.key.begin(), value.key.end(), buffer.begin() + 2 + sizeof(uint16_t)),
-        buffer.end(),
-        0
-    );
+    stream.write(value.key.begin(), value.key.end());
+    stream.fill(padding, 0);
     add_option(option(HANDOVER_KEY_REPLY, buffer.begin(), buffer.end()));
 }
 
-void ICMPv6::handover_assist_info(const handover_assist_info_type &value) {
+void ICMPv6::handover_assist_info(const handover_assist_info_type& value) {
     const uint32_t data_size = static_cast<uint32_t>(value.hai.size() + 2);
-    uint8_t padding = 8 - (data_size+2) % 8;
-    if(padding == 8)
-        padding = 0;
-    std::vector<uint8_t> buffer(data_size + padding);
-    buffer[0] = value.option_code;
-    buffer[1] = static_cast<uint8_t>(value.hai.size());
+    uint8_t padding = get_option_padding(data_size+2);
+    vector<uint8_t> buffer(data_size + padding);
+    OutputMemoryStream stream(buffer);
+    stream.write(value.option_code);
+    stream.write<uint8_t>(value.hai.size());
     // copy hai + padding
-    buffer.insert(
-        std::copy(value.hai.begin(), value.hai.end(), buffer.begin() + 2),
-        padding,
-        0
-    );
+    stream.write(value.hai.begin(), value.hai.end());
+    stream.fill(padding, 0);
     add_option(option(HANDOVER_ASSIST_INFO, buffer.begin(), buffer.end()));
 }
 
-void ICMPv6::mobile_node_identifier(const mobile_node_id_type &value) {
+void ICMPv6::mobile_node_identifier(const mobile_node_id_type& value) {
     const uint32_t data_size = static_cast<uint32_t>(value.mn.size() + 2);
-    uint8_t padding = 8 - (data_size+2) % 8;
-    if(padding == 8)
-        padding = 0;
-    std::vector<uint8_t> buffer(data_size + padding);
-    buffer[0] = value.option_code;
-    buffer[1] = static_cast<uint8_t>(value.mn.size());
+    uint8_t padding = get_option_padding(data_size+2);
+    vector<uint8_t> buffer(data_size + padding);
+    OutputMemoryStream stream(buffer);
+    stream.write(value.option_code);
+    stream.write<uint8_t>(value.mn.size());
     // copy mn + padding
-    buffer.insert(
-        std::copy(value.mn.begin(), value.mn.end(), buffer.begin() + 2),
-        padding,
-        0
-    );
+    stream.write(value.mn.begin(), value.mn.end());
+    stream.fill(padding, 0);
     add_option(option(MOBILE_NODE_ID, buffer.begin(), buffer.end()));
 }
 
-void ICMPv6::dns_search_list(const dns_search_list_type &value) {
+void ICMPv6::dns_search_list(const dns_search_list_type& value) {
     // at least it's got this size
-    std::vector<uint8_t> buffer(2 + sizeof(uint32_t));
-    uint32_t tmp_lifetime = Endian::host_to_be(value.lifetime);
-    std::memcpy(&buffer[2], &tmp_lifetime, sizeof(uint32_t));
+    vector<uint8_t> buffer(2 + sizeof(uint32_t));
+    OutputMemoryStream stream(buffer);
+    stream.skip(2);
+    stream.write_be(value.lifetime);
     typedef dns_search_list_type::domains_type::const_iterator iterator;
-    for(iterator it = value.domains.begin(); it != value.domains.end(); ++it) {
+    for (iterator it = value.domains.begin(); it != value.domains.end(); ++it) {
         size_t prev = 0, index;
         do {
             index = it->find('.', prev);
-            std::string::const_iterator end = (index == std::string::npos) ? it->end() : (it->begin() + index);
+            string::const_iterator end = (index == string::npos) ? 
+                                         it->end() : (it->begin() + index);
             buffer.push_back(static_cast<uint8_t>(end - (it->begin() + prev)));
             buffer.insert(buffer.end(), it->begin() + prev, end);
             prev = index + 1;
-        } while(index != std::string::npos);
+        } while (index != string::npos);
         // delimiter
         buffer.push_back(0);
     }
-    uint8_t padding = 8 - (buffer.size() + 2) % 8;
-    if (padding == 8) {
-        padding = 0;
-    }
+    uint8_t padding = get_option_padding(buffer.size() + 2);
     buffer.insert(buffer.end(), padding, 0);
     add_option(option(DNS_SEARCH_LIST, buffer.begin(), buffer.end()));
 }
@@ -787,257 +762,251 @@ ICMPv6::dns_search_list_type ICMPv6::dns_search_list() const {
 
 // Options stuff
 
-ICMPv6::addr_list_type ICMPv6::addr_list_type::from_option(const option &opt) 
-{
-    if(opt.data_size() < 6 + ipaddress_type::address_size || (opt.data_size() - 6) % ipaddress_type::address_size != 0)
+ICMPv6::addr_list_type ICMPv6::addr_list_type::from_option(const option& opt) {
+    if (opt.data_size() < 6 + ipaddress_type::address_size || 
+        (opt.data_size() - 6) % ipaddress_type::address_size != 0) {
         throw malformed_option();
+    }
     addr_list_type output;
-    const uint8_t *ptr = opt.data_ptr(), *end = opt.data_ptr() + opt.data_size();
-    std::copy(ptr, ptr + 6, output.reserved);
-    ptr += 6;
-    while(ptr < end) {
-        output.addresses.push_back(ICMPv6::ipaddress_type(ptr));
-        ptr += ICMPv6::ipaddress_type::address_size;
+    InputMemoryStream stream(opt.data_ptr(), opt.data_size());
+    stream.read(output.reserved, 6);
+    while (stream) {
+        output.addresses.push_back(stream.read<ICMPv6::ipaddress_type>());
     }
     return output;
 }
 
-ICMPv6::naack_type ICMPv6::naack_type::from_option(const option &opt) 
-{
-    if(opt.data_size() != 6)
+ICMPv6::naack_type ICMPv6::naack_type::from_option(const option& opt) {
+    if (opt.data_size() != 6) {
         throw malformed_option();
+    }
     return naack_type(*opt.data_ptr(), opt.data_ptr()[1]);
 }
 
-ICMPv6::lladdr_type ICMPv6::lladdr_type::from_option(const option &opt)
-{
-    if(opt.data_size() < 2)
+ICMPv6::lladdr_type ICMPv6::lladdr_type::from_option(const option& opt) {
+    if (opt.data_size() < 2) {
         throw malformed_option();
-    const uint8_t *ptr = opt.data_ptr();
+    }
+    const uint8_t* ptr = opt.data_ptr();
     lladdr_type output(*ptr++);
     output.address.assign(ptr, opt.data_ptr() + opt.data_size());
     return output;
 }
 
-ICMPv6::prefix_info_type ICMPv6::prefix_info_type::from_option(const option &opt) 
-{
-    if(opt.data_size() != 2 + sizeof(uint32_t) * 3 + ICMPv6::ipaddress_type::address_size)
+ICMPv6::prefix_info_type ICMPv6::prefix_info_type::from_option(const option& opt) {
+    if (opt.data_size() != 2 + sizeof(uint32_t) * 3 + ICMPv6::ipaddress_type::address_size) {
         throw malformed_option();
-    const uint8_t *ptr = opt.data_ptr();
+    }
     prefix_info_type output;
-    output.prefix_len = *ptr++;
-    output.L = (*ptr >> 7) & 0x1;
-    output.A = (*ptr++ >> 6) & 0x1;
-    std::memcpy(&output.valid_lifetime, ptr, sizeof(uint32_t));
-    output.valid_lifetime = Endian::be_to_host(output.valid_lifetime);
-    ptr += sizeof(uint32_t);
-    std::memcpy(&output.preferred_lifetime, ptr, sizeof(uint32_t));
-    output.preferred_lifetime = Endian::be_to_host(output.preferred_lifetime);
-    output.prefix = ptr + sizeof(uint32_t) * 2;
+    InputMemoryStream stream(opt.data_ptr(), opt.data_size());
+    output.prefix_len = stream.read<uint8_t>();
+    output.L = (*stream.pointer() >> 7) & 0x1;
+    output.A = (stream.read<uint8_t>() >> 6) & 0x1;
+    output.valid_lifetime = stream.read_be<uint32_t>();
+    output.preferred_lifetime = stream.read_be<uint32_t>();
+    stream.skip(sizeof(uint32_t));
+    output.prefix = stream.read<ICMPv6::ipaddress_type>();
     return output;
 }
 
-ICMPv6::rsa_sign_type ICMPv6::rsa_sign_type::from_option(const option &opt)
-{
+ICMPv6::rsa_sign_type ICMPv6::rsa_sign_type::from_option(const option& opt) {
     // 2 bytes reserved + at least 1 byte signature.
     // 16 == sizeof(rsa_sign_type::key_hash), removed the sizeof
     // expression since gcc 4.2 doesn't like it
-    if(opt.data_size() < 2 + 16 + 1)
+    if (opt.data_size() < 2 + 16 + 1) {
         throw malformed_option();
-    const uint8_t *ptr = opt.data_ptr() + 2;
+    }
     rsa_sign_type output;
-    std::copy(ptr, ptr + sizeof(output.key_hash), output.key_hash);
-    ptr += sizeof(output.key_hash);
-    output.signature.assign(ptr, opt.data_ptr() + opt.data_size());
+    InputMemoryStream stream(opt.data_ptr(), opt.data_size());
+    stream.skip(2);
+    stream.read(output.key_hash, sizeof(output.key_hash));
+    output.signature.assign(stream.pointer(), stream.pointer() + stream.size());
     return output;
 }
 
-ICMPv6::ip_prefix_type ICMPv6::ip_prefix_type::from_option(const option &opt)
-{
+ICMPv6::ip_prefix_type ICMPv6::ip_prefix_type::from_option(const option& opt) {
     // 2 bytes + 4 padding + ipv6 address
-    if(opt.data_size() != 2 + 4 + ICMPv6::ipaddress_type::address_size)
+    if (opt.data_size() != 2 + 4 + ICMPv6::ipaddress_type::address_size) {
         throw malformed_option();
-    const uint8_t *ptr = opt.data_ptr();
+    }
     ip_prefix_type output;
-    output.option_code = *ptr++;
-    output.prefix_len = *ptr++;
+    InputMemoryStream stream(opt.data_ptr(), opt.data_size());
+    output.option_code = stream.read<uint8_t>();
+    output.prefix_len = stream.read<uint8_t>();
     // skip padding
-    ptr += sizeof(uint32_t);
-    output.address = ICMPv6::ipaddress_type(ptr);
+    stream.skip(sizeof(uint32_t));
+    stream.read(output.address);
     return output;
 }
 
-ICMPv6::map_type ICMPv6::map_type::from_option(const option &opt)
-{
-    if(opt.data_size() != 2 + sizeof(uint32_t) + ipaddress_type::address_size)
+ICMPv6::map_type ICMPv6::map_type::from_option(const option& opt) {
+    if (opt.data_size() != 2 + sizeof(uint32_t) + ipaddress_type::address_size) {
         throw malformed_option();
-    const uint8_t *ptr = opt.data_ptr();
+    }
     map_type output;
-    output.dist = (*ptr >> 4) & 0x0f;
-    output.pref = *ptr++ & 0x0f;
-    output.r = (*ptr++ >> 7) & 0x01;
-    std::memcpy(&output.valid_lifetime, ptr, sizeof(uint32_t));
-    ptr += sizeof(uint32_t);
-    output.address = ptr;
+    InputMemoryStream stream(opt.data_ptr(), opt.data_size());
+    output.dist = (*stream.pointer() >> 4) & 0x0f;
+    output.pref = stream.read<uint8_t>() & 0x0f;
+    output.r = (stream.read<uint8_t>() >> 7) & 0x01;
+    output.valid_lifetime = stream.read_be<uint32_t>();
+    stream.read(output.address);
     return output;
 }
 
-ICMPv6::route_info_type ICMPv6::route_info_type::from_option(const option &opt) 
-{
-    if(opt.data_size() < 2 + sizeof(uint32_t))
+ICMPv6::route_info_type ICMPv6::route_info_type::from_option(const option& opt)  {
+    if (opt.data_size() < 2 + sizeof(uint32_t)) {
         throw malformed_option();
-    const uint8_t *ptr = opt.data_ptr();
+    }
     route_info_type output;
-    output.prefix_len = *ptr++;
-    output.pref = (*ptr++ >> 3) & 0x3;
-    std::memcpy(&output.route_lifetime, ptr, sizeof(uint32_t));
-    output.route_lifetime = Endian::be_to_host(output.route_lifetime);
-    ptr += sizeof(uint32_t);
-    output.prefix.assign(ptr, opt.data_ptr() + opt.data_size());
+    InputMemoryStream stream(opt.data_ptr(), opt.data_size());
+    output.prefix_len = stream.read<uint8_t>();
+    output.pref = (stream.read<uint8_t>() >> 3) & 0x3;
+    output.route_lifetime = stream.read_be<uint32_t>();
+    output.prefix.assign(stream.pointer(), stream.pointer() + stream.size());
     return output;
 }
 
-ICMPv6::recursive_dns_type ICMPv6::recursive_dns_type::from_option(const option &opt)
-{
-    if(opt.data_size() < 2 + sizeof(uint32_t) + ICMPv6::ipaddress_type::address_size)
+ICMPv6::recursive_dns_type ICMPv6::recursive_dns_type::from_option(const option& opt) {
+    if (opt.data_size() < 2 + sizeof(uint32_t) + ICMPv6::ipaddress_type::address_size) {
         throw malformed_option();
-    const uint8_t *ptr = opt.data_ptr() + 2, *end = opt.data_ptr() + opt.data_size();
+    }
     recursive_dns_type output;
-    std::memcpy(&output.lifetime, ptr, sizeof(uint32_t));
-    output.lifetime = Endian::be_to_host(output.lifetime);
-    ptr += sizeof(uint32_t);
-    while(ptr < end) {
-        if(ptr + ICMPv6::ipaddress_type::address_size > end)
-            throw option_not_found();
-        output.servers.push_back(ptr);
-        ptr += ICMPv6::ipaddress_type::address_size;
+    InputMemoryStream stream(opt.data_ptr(), opt.data_size());
+    stream.skip(2);
+    output.lifetime = stream.read_be<uint32_t>();
+    while (stream) {
+        output.servers.push_back(stream.read<ICMPv6::ipaddress_type>());
     }
     return output;
 }
 
-ICMPv6::handover_key_req_type ICMPv6::handover_key_req_type::from_option(const option &opt)
-{
-    if(opt.data_size() < 2 + sizeof(uint32_t))
+ICMPv6::handover_key_req_type ICMPv6::handover_key_req_type::from_option(const option& opt) {
+    if (opt.data_size() < 2 + sizeof(uint32_t)) {
         throw option_not_found();
-    const uint8_t *ptr = opt.data_ptr() + 1, *end = opt.data_ptr() + opt.data_size();
+    }
     handover_key_req_type output;
-    output.AT = (*ptr++ >> 4) & 0x3;
+    InputMemoryStream stream(opt.data_ptr(), opt.data_size());
+    stream.skip(1);
+    output.AT = (stream.read<uint8_t>() >> 4) & 0x3;
     // is there enough size for the indicated padding?
-    if(end - ptr < *opt.data_ptr())
+    if (!stream.can_read(*opt.data_ptr())) {
         throw malformed_option();
-    output.key.assign(ptr, ptr + ((end - ptr) - *opt.data_ptr()));
+    }
+    output.key.assign(stream.pointer(), stream.pointer() + stream.size() - *opt.data_ptr());
     return output;
 }
 
-ICMPv6::handover_key_reply_type ICMPv6::handover_key_reply_type::from_option(const option &opt)
-{
-    if(opt.data_size() < 2 + sizeof(uint32_t))
+ICMPv6::handover_key_reply_type ICMPv6::handover_key_reply_type::from_option(const option& opt) {
+    if (opt.data_size() < 2 + sizeof(uint32_t)) {
         throw malformed_option();
-    const uint8_t *ptr = opt.data_ptr() + 1, *end = opt.data_ptr() + opt.data_size();
+    }
     handover_key_reply_type output;
-    output.AT = (*ptr++ >> 4) & 0x3;
-    std::memcpy(&output.lifetime, ptr, sizeof(uint16_t));
-    output.lifetime = Endian::be_to_host(output.lifetime);
-    ptr += sizeof(uint16_t);
+    InputMemoryStream stream(opt.data_ptr(), opt.data_size());
+    stream.skip(1);
+    output.AT = (stream.read<uint8_t>() >> 4) & 0x3;
+    output.lifetime = stream.read_be<uint16_t>();
     // is there enough size for the indicated padding?
-    if(end - ptr < *opt.data_ptr())
+    if (!stream.can_read(*opt.data_ptr())) {
         throw malformed_option();
-    output.key.assign(ptr, ptr + ((end - ptr) - *opt.data_ptr()));
+    }
+    output.key.assign(stream.pointer(), stream.pointer() + stream.size() - *opt.data_ptr());
     return output;
 }
 
-ICMPv6::handover_assist_info_type ICMPv6::handover_assist_info_type::from_option(const option &opt)
-{
-    if(opt.data_size() < 2)
+ICMPv6::handover_assist_info_type ICMPv6::handover_assist_info_type::from_option(const option& opt) {
+    if (opt.data_size() < 2) {
         throw malformed_option();
-    const uint8_t *ptr = opt.data_ptr(), *end = ptr + opt.data_size();
+    }
+    const uint8_t* ptr = opt.data_ptr(), *end = ptr + opt.data_size();
     handover_assist_info_type output;
     output.option_code = *ptr++;
-    if((end - ptr - 1) < *ptr)
+    if ((end - ptr - 1) <* ptr) {
         throw malformed_option();
+    }
     output.hai.assign(ptr + 1, ptr + 1 + *ptr);
     return output;
 }
 
-ICMPv6::mobile_node_id_type ICMPv6::mobile_node_id_type::from_option(const option &opt)
-{
-    if(opt.data_size() < 2)
+ICMPv6::mobile_node_id_type ICMPv6::mobile_node_id_type::from_option(const option& opt) {
+    if (opt.data_size() < 2) {
         throw malformed_option();
-    const uint8_t *ptr = opt.data_ptr(), *end = ptr + opt.data_size();
+    }
+    const uint8_t* ptr = opt.data_ptr(), *end = ptr + opt.data_size();
     mobile_node_id_type output;
     output.option_code = *ptr++;
-    if((end - ptr - 1) < *ptr)
+    if ((end - ptr - 1) <* ptr) {
         throw malformed_option();
+    }
     output.mn.assign(ptr + 1, ptr + 1 + *ptr);
     return output;
 }
 
-ICMPv6::dns_search_list_type ICMPv6::dns_search_list_type::from_option(const option &opt)
-{
-    if(opt.data_size() < 2 + sizeof(uint32_t))
+ICMPv6::dns_search_list_type ICMPv6::dns_search_list_type::from_option(const option& opt) {
+    if (opt.data_size() < 2 + sizeof(uint32_t)) {
         throw malformed_option();
-    const uint8_t *ptr = opt.data_ptr(), *end = ptr + opt.data_size();
+    }
+    const uint8_t* ptr = opt.data_ptr(), *end = ptr + opt.data_size();
     dns_search_list_type output;
-    std::memcpy(&output.lifetime, ptr + 2, sizeof(uint32_t));
+    memcpy(&output.lifetime, ptr + 2, sizeof(uint32_t));
     output.lifetime = Endian::be_to_host(output.lifetime);
     ptr += 2 + sizeof(uint32_t);
-    while(ptr < end && *ptr) {
-        std::string domain;
-        while(ptr < end && *ptr && *ptr < (end - ptr)) {
-            if(!domain.empty())
+    while (ptr < end && *ptr) {
+        string domain;
+        while (ptr < end && *ptr && *ptr < (end - ptr)) {
+            if (!domain.empty()) {
                 domain.push_back('.');
+            }
             domain.insert(domain.end(), ptr + 1, ptr + *ptr + 1);
             ptr += *ptr + 1;
         }
         // not enough size
-        if(ptr < end && *ptr != 0)
+        if (ptr < end && *ptr != 0) {
             throw option_not_found();
+        }
         output.domains.push_back(domain);
         ptr++;
     }
     return output;
 }
 
-ICMPv6::timestamp_type ICMPv6::timestamp_type::from_option(const option &opt)
-{
-    if(opt.data_size() != 6 + sizeof(uint64_t))
+ICMPv6::timestamp_type ICMPv6::timestamp_type::from_option(const option& opt) {
+    if (opt.data_size() != 6 + sizeof(uint64_t)) {
         throw malformed_option();
-    uint64_t uint64_t_buffer;
-    std::memcpy(&uint64_t_buffer, opt.data_ptr() + 6, sizeof(uint64_t));
-    timestamp_type output(Endian::be_to_host(uint64_t_buffer));
-    std::copy(opt.data_ptr(), opt.data_ptr() + 6, output.reserved);
+    }
+    InputMemoryStream stream(opt.data_ptr(), opt.data_size());
+    timestamp_type output;
+    stream.read(output.reserved, 6);
+    output.timestamp = stream.read_be<uint64_t>();
     return output;
 }
 
-ICMPv6::shortcut_limit_type ICMPv6::shortcut_limit_type::from_option(const option &opt)
-{
-    if(opt.data_size() != 6)
+ICMPv6::shortcut_limit_type ICMPv6::shortcut_limit_type::from_option(const option& opt) {
+    if (opt.data_size() != 6) {
         throw malformed_option();
-    const uint8_t *ptr = opt.data_ptr();
-    shortcut_limit_type output(*ptr++);
-    output.reserved1 = *ptr++;
-    std::memcpy(&output.reserved2, ptr, sizeof(uint32_t));
-    output.reserved2 = Endian::be_to_host(output.reserved2);
+    }
+    shortcut_limit_type output;
+    InputMemoryStream stream(opt.data_ptr(), opt.data_size());
+    output.limit = stream.read<uint8_t>();
+    output.reserved1 = stream.read<uint8_t>();
+    output.reserved2 = stream.read_be<uint32_t>();
     return output;
 }
 
-ICMPv6::new_advert_interval_type ICMPv6::new_advert_interval_type::from_option(const option &opt)
-{
-    if(opt.data_size() != 6)
+ICMPv6::new_advert_interval_type ICMPv6::new_advert_interval_type::from_option(const option& opt) {
+    if (opt.data_size() != 6) {
         throw malformed_option();
+    }
     new_advert_interval_type output;
-    std::memcpy(&output.reserved, opt.data_ptr(), sizeof(uint16_t));
-    output.reserved = Endian::be_to_host(output.reserved);
-    std::memcpy(&output.interval, opt.data_ptr() + sizeof(uint16_t), sizeof(uint32_t));
-    output.interval = Endian::be_to_host(output.interval);
+    InputMemoryStream stream(opt.data_ptr(), opt.data_size());
+    output.reserved = stream.read_be<uint16_t>();
+    output.interval = stream.read_be<uint32_t>();
     return output;
 }
 
 // multicast_address_record
 
 ICMPv6::multicast_address_record::multicast_address_record(const uint8_t* buffer, 
-    uint32_t total_sz) 
-{
+                                                           uint32_t total_sz) {
     InputMemoryStream stream(buffer, total_sz);
     stream.read(type);
     int aux_data_len = stream.read<uint8_t>() * sizeof(uint32_t);
@@ -1052,8 +1021,7 @@ ICMPv6::multicast_address_record::multicast_address_record(const uint8_t* buffer
     aux_data.assign(stream.pointer(), stream.pointer() + aux_data_len);
 }
 
-void ICMPv6::multicast_address_record::serialize(uint8_t* buffer, uint32_t total_sz) const
-{
+void ICMPv6::multicast_address_record::serialize(uint8_t* buffer, uint32_t total_sz) const {
     OutputMemoryStream stream(buffer, total_sz);
     stream.write(type);
     stream.write<uint8_t>(aux_data.size() / sizeof(uint32_t));
@@ -1065,8 +1033,7 @@ void ICMPv6::multicast_address_record::serialize(uint8_t* buffer, uint32_t total
     stream.write(aux_data.begin(), aux_data.end());
 }
 
-uint32_t ICMPv6::multicast_address_record::size() const 
-{
+uint32_t ICMPv6::multicast_address_record::size() const  {
     return sizeof(uint8_t) * 2 + sizeof(uint16_t) + ipaddress_type::address_size +
            sources.size() * ipaddress_type::address_size +
            aux_data.size();
diff --git a/src/internals.cpp b/src/internals.cpp
index d057b7b..bc5704f 100644
--- a/src/internals.cpp
+++ b/src/internals.cpp
@@ -62,33 +62,38 @@ using Tins::Memory::InputMemoryStream;
 namespace Tins {
 namespace Internals {
 
-bool from_hex(const string &str, uint32_t &result) {
+bool from_hex(const string& str, uint32_t& result) {
     unsigned i(0);
     result = 0;
-    while(i < str.size()) {
+    while (i < str.size()) {
         uint8_t tmp;
-        if(str[i] >= 'A' && str[i] <= 'F')
+        if (str[i] >= 'A' && str[i] <= 'F') {
             tmp = (str[i] - 'A' + 10);
-        else if(str[i] >= '0' && str[i] <= '9')
+        }
+        else if (str[i] >= '0' && str[i] <= '9') {
             tmp = (str[i] - '0');
-        else
+        }
+        else {
             return false;
+        }
         result = (result << 4) | tmp;
         i++;
     }
     return true;
 }
 
-void skip_line(std::istream &input) {
+void skip_line(std::istream& input) {
     int c = 0;
-    while(c != '\n' && input)
-         c = input.get();
+    while (c != '\n' && input) {
+        c = input.get();
+    }
 }
 
-Tins::PDU *pdu_from_flag(Constants::Ethernet::e flag, const uint8_t *buffer, 
-  uint32_t size, bool rawpdu_on_no_match) 
-{
-    switch(flag) {
+Tins::PDU* pdu_from_flag(Constants::Ethernet::e flag,
+                         const uint8_t* buffer,
+                         uint32_t size,
+                         bool rawpdu_on_no_match) {
+    switch (flag) {
         case Tins::Constants::Ethernet::IP:
             return new IP(buffer, size);
         case Constants::Ethernet::IPV6:
@@ -106,22 +111,24 @@ Tins::PDU *pdu_from_flag(Constants::Ethernet::e flag, const uint8_t *buffer,
             return new MPLS(buffer, size);
         default:
             {
-                PDU *pdu = Internals::allocate<EthernetII>(
+                PDU* pdu = Internals::allocate<EthernetII>(
                     static_cast<uint16_t>(flag),
                     buffer, 
                     size
                 );
-                if(pdu)
+                if (pdu) {
                     return pdu;
+                }
             }
             return rawpdu_on_no_match ? new RawPDU(buffer, size) : 0;
     };
 }
 
-Tins::PDU *pdu_from_flag(Constants::IP::e flag, const uint8_t *buffer, 
-  uint32_t size, bool rawpdu_on_no_match) 
-{
-    switch(flag) {
+Tins::PDU* pdu_from_flag(Constants::IP::e flag, 
+                         const uint8_t* buffer, 
+                         uint32_t size,
+                         bool rawpdu_on_no_match) {
+    switch (flag) {
         case Constants::IP::PROTO_IPIP:
             return new Tins::IP(buffer, size);
         case Constants::IP::PROTO_TCP:
@@ -141,14 +148,16 @@ Tins::PDU *pdu_from_flag(Constants::IP::e flag, const uint8_t *buffer,
         default:
             break;
     }
-    if(rawpdu_on_no_match)
+    if (rawpdu_on_no_match) {
         return new Tins::RawPDU(buffer, size);
+    }
     return 0;
 }
 
-PDU *pdu_from_dlt_flag(int flag, const uint8_t *buffer, 
-  uint32_t size, bool rawpdu_on_no_match)
-{
+PDU* pdu_from_dlt_flag(int flag, 
+                       const uint8_t* buffer, 
+                       uint32_t size,
+                       bool rawpdu_on_no_match) {
     switch (flag) {
         case DLT_EN10MB:
             return new EthernetII(buffer, size);
@@ -175,8 +184,7 @@ PDU *pdu_from_dlt_flag(int flag, const uint8_t *buffer,
     };
 }
 
-Tins::PDU *pdu_from_flag(PDU::PDUType type, const uint8_t *buffer, uint32_t size) 
-{
+Tins::PDU* pdu_from_flag(PDU::PDUType type, const uint8_t* buffer, uint32_t size) {
     switch(type) {
         case Tins::PDU::ETHERNET_II:
             return new Tins::EthernetII(buffer, size);
@@ -240,10 +248,11 @@ Constants::Ethernet::e pdu_flag_to_ether_type(PDU::PDUType flag) {
         case PDU::RC4EAPOL:
             return Constants::Ethernet::EAPOL;
         default:
-            if(Internals::pdu_type_registered<EthernetII>(flag)) 
+            if (Internals::pdu_type_registered<EthernetII>(flag)) {
                 return static_cast<Constants::Ethernet::e>(
                     Internals::pdu_type_to_id<EthernetII>(flag)
                 );
+            }
             return Constants::Ethernet::UNKNOWN;
     }
 }
@@ -284,8 +293,9 @@ uint32_t get_padded_icmp_inner_pdu_size(const PDU* inner_pdu, uint32_t pad_align
     }
 }
 
-void try_parse_icmp_extensions(InputMemoryStream& stream, uint32_t payload_length, 
-    ICMPExtensionsStructure& extensions) {
+void try_parse_icmp_extensions(InputMemoryStream& stream, 
+                               uint32_t payload_length, 
+                               ICMPExtensionsStructure& extensions) {
     if (!stream) {
         return;
     }
@@ -315,40 +325,41 @@ void try_parse_icmp_extensions(InputMemoryStream& stream, uint32_t payload_lengt
     }
 }
 
-bool increment(IPv4Address &addr) {
+bool increment(IPv4Address& addr) {
     uint32_t addr_int = Endian::be_to_host<uint32_t>(addr);
     bool reached_end = ++addr_int == 0xffffffff;
     addr = IPv4Address(Endian::be_to_host<uint32_t>(addr_int));
     return reached_end;
 }
 
-bool increment(IPv6Address &addr) {
+bool increment(IPv6Address& addr) {
     return increment_buffer(addr);
 }
 
-bool decrement(IPv4Address &addr) {
+bool decrement(IPv4Address& addr) {
     uint32_t addr_int = Endian::be_to_host<uint32_t>(addr);
     bool reached_end = --addr_int == 0;
     addr = IPv4Address(Endian::be_to_host<uint32_t>(addr_int));
     return reached_end;
 }
 
-bool decrement(IPv6Address &addr) {
+bool decrement(IPv6Address& addr) {
     return decrement_buffer(addr);
 }
 
 IPv4Address last_address_from_mask(IPv4Address addr, IPv4Address mask) {
     uint32_t addr_int = Endian::be_to_host<uint32_t>(addr),
-            mask_int = Endian::be_to_host<uint32_t>(mask);
+             mask_int = Endian::be_to_host<uint32_t>(mask);
     return IPv4Address(Endian::host_to_be(addr_int | ~mask_int));
 }
 
-IPv6Address last_address_from_mask(IPv6Address addr, const IPv6Address &mask) {
+IPv6Address last_address_from_mask(IPv6Address addr, const IPv6Address& mask) {
     IPv6Address::iterator addr_iter = addr.begin();
-    for(IPv6Address::const_iterator it = mask.begin(); it != mask.end(); ++it, ++addr_iter) {
+    for (IPv6Address::const_iterator it = mask.begin(); it != mask.end(); ++it, ++addr_iter) {
         *addr_iter = *addr_iter | ~*it;
     }
     return addr;
 }
+
 } // namespace Internals
 } // namespace Tins
diff --git a/src/ip.cpp b/src/ip.cpp
index a8f6037..7d88356 100644
--- a/src/ip.cpp
+++ b/src/ip.cpp
@@ -48,6 +48,9 @@
 #include "memory_helpers.h"
 
 using std::list;
+using std::min;
+using std::memcmp;
+using std::vector;
 
 using Tins::Memory::InputMemoryStream;
 using Tins::Memory::OutputMemoryStream;
@@ -56,22 +59,20 @@ namespace Tins {
 
 const uint8_t IP::DEFAULT_TTL = 128;
 
-IP::IP(address_type ip_dst, address_type ip_src) 
-{
+IP::IP(address_type ip_dst, address_type ip_src) {
     init_ip_fields();
     this->dst_addr(ip_dst);
     this->src_addr(ip_src); 
 }
 
-IP::IP(const uint8_t *buffer, uint32_t total_sz)
-: _options_size(0)
-{
+IP::IP(const uint8_t* buffer, uint32_t total_sz)
+: options_size_(0) {
     InputMemoryStream stream(buffer, total_sz);
-    stream.read(_ip);
+    stream.read(ip_);
 
     // 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(iphdr)) {
+        head_len() * sizeof(uint32_t) < sizeof(ip_)) {
         throw malformed_packet();
     }
     const uint8_t* options_end = buffer + head_len() * sizeof(uint32_t);
@@ -91,15 +92,15 @@ IP::IP(const uint8_t *buffer, uint32_t total_sz)
                 if (stream.pointer() + data_size > options_end) {
                     throw malformed_packet();
                 }
-                _ip_options.push_back(
+                ip_options_.push_back(
                     option(opt_type, stream.pointer(), stream.pointer() + data_size)
                 );
                 stream.skip(data_size);
             }
             else {
-                _ip_options.push_back(option(opt_type));
+                ip_options_.push_back(option(opt_type));
             }
-            _options_size += option_size;
+            options_size_ += option_size;
         }
         else if (opt_type == END) {
             // If the end option found, we're done
@@ -110,18 +111,17 @@ IP::IP(const uint8_t *buffer, uint32_t total_sz)
             break;
         }
         else {
-            _ip_options.push_back(option(opt_type));
-            _options_size++;
+            ip_options_.push_back(option(opt_type));
+            options_size_++;
         }
     }
-    uint8_t padding = _options_size % 4;
-    _padded_options_size = padding ? (_options_size - padding + 4) : _options_size;
+    update_padded_options_size();
     if (stream) {
         // Don't avoid consuming more than we should if tot_len is 0,
         // since this is the case when using TCP segmentation offload
         if (tot_len() != 0) {
             const uint32_t advertised_length = (uint32_t)tot_len() - head_len() * sizeof(uint32_t);
-            total_sz = std::min(stream.size(), advertised_length);
+            total_sz = min(stream.size(), advertised_length);
         }
         else {
             total_sz = stream.size();
@@ -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>(ip_.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,
+                        ip_.protocol,
                         stream.pointer(), 
                         total_sz
                     )
@@ -158,74 +158,72 @@ IP::IP(const uint8_t *buffer, uint32_t total_sz)
 }
 
 void IP::init_ip_fields() {
-    memset(&_ip, 0, sizeof(iphdr));
-    _ip.version = 4;
+    memset(&ip_, 0, sizeof(ip_));
+    ip_.version = 4;
     ttl(DEFAULT_TTL);
     id(1);
-    _options_size = 0;
-    _padded_options_size = 0;
+    options_size_ = 0;
+    padded_options_size_ = 0;
 }
 
 bool IP::is_fragmented() const {
     return flags() == IP::MORE_FRAGMENTS || fragment_offset() != 0;
 }
 
-/* Setters */
+// Setters
 
 void IP::tos(uint8_t new_tos) {
-    _ip.tos = new_tos;
+    ip_.tos = new_tos;
 }
 
 void IP::tot_len(uint16_t new_tot_len) {
-    _ip.tot_len = Endian::host_to_be(new_tot_len);
+    ip_.tot_len = Endian::host_to_be(new_tot_len);
 }
 
 void IP::id(uint16_t new_id) {
-    _ip.id = Endian::host_to_be(new_id);
+    ip_.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);
+    ip_.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(ip_.frag_off) & 0xe000) | new_frag_off;
+    ip_.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(ip_.frag_off) & 0x1fff) | (new_flags << 13);
+    ip_.frag_off = Endian::host_to_be(value);
 }
 
 void IP::ttl(uint8_t new_ttl) {
-    _ip.ttl = new_ttl;
+    ip_.ttl = new_ttl;
 }
 
 void IP::protocol(uint8_t new_protocol) {
-    _ip.protocol = new_protocol;
+    ip_.protocol = new_protocol;
 }
 
 void IP::checksum(uint16_t new_check) {
-    _ip.check = Endian::host_to_be(new_check);
+    ip_.check = Endian::host_to_be(new_check);
 }
 
-
 void IP::src_addr(address_type ip) {
-    _ip.saddr = ip;
+    ip_.saddr = ip;
 }
 
-
 void IP::dst_addr(address_type ip) {
-    _ip.daddr = ip;
+    ip_.daddr = ip;
 }
 
 void IP::head_len(small_uint<4> new_head_len) {
-    _ip.ihl = new_head_len;
+    ip_.ihl = new_head_len;
 }
 
 void IP::version(small_uint<4> ver) {
-    _ip.version = ver;
+    ip_.version = ver;
 }
 
 void IP::eol() {
@@ -236,16 +234,16 @@ void IP::noop() {
     add_option(option_identifier(IP::NOOP, IP::CONTROL, 0));
 }
 
-void IP::security(const security_type &data) {
+void IP::security(const security_type& data) {
     uint8_t array[9];
-    uint16_t *ptr = reinterpret_cast<uint16_t*>(array);
+    OutputMemoryStream stream(array, sizeof(array));
     uint32_t value = data.transmission_control;
-    *ptr++ = Endian::host_to_be(data.security);
-    *ptr++ = Endian::host_to_be(data.compartments);
-    *ptr++ = Endian::host_to_be(data.handling_restrictions);
-    array[8] = (value & 0xff);
-    array[7] = ((value >> 8) & 0xff);
-    array[6] = ((value >> 16) & 0xff);
+    stream.write_be(data.security);
+    stream.write_be(data.compartments);
+    stream.write_be(data.handling_restrictions);
+    stream.write<uint8_t>((value >> 16) & 0xff);
+    stream.write<uint8_t>((value >> 8) & 0xff);
+    stream.write<uint8_t>(value & 0xff);
     
     add_option(
         option(
@@ -258,7 +256,7 @@ void IP::security(const security_type &data) {
 
 void IP::stream_identifier(uint16_t stream_id) {
     stream_id = Endian::host_to_be(stream_id);
-        add_option(
+    add_option(
         option(
             136,
             sizeof(uint16_t),
@@ -267,10 +265,10 @@ void IP::stream_identifier(uint16_t stream_id) {
     );
 }
 
-void IP::add_route_option(option_identifier id, const generic_route_option_type &data) {
-    std::vector<uint8_t> opt_data(1 + sizeof(uint32_t) * data.routes.size());
+void IP::add_route_option(option_identifier id, const generic_route_option_type& data) {
+    vector<uint8_t> opt_data(1 + sizeof(uint32_t) * data.routes.size());
     opt_data[0] = data.pointer;
-    for(size_t i(0); i < data.routes.size(); ++i) {
+    for (size_t i(0); i < data.routes.size(); ++i) {
         uint32_t ip = data.routes[i];
         #if TINS_IS_BIG_ENDIAN
             ip = Endian::change_endian(ip);
@@ -290,68 +288,71 @@ void IP::add_route_option(option_identifier id, const generic_route_option_type
 }
 
 IP::generic_route_option_type IP::search_route_option(option_identifier id) const {
-    const option *opt = search_option(id);
-    if(!opt)
+    const option* opt = search_option(id);
+    if (!opt) {
         throw option_not_found();
+    }
     return opt->to<generic_route_option_type>();
 }
 
 IP::security_type IP::security() const {
-    const option *opt = search_option(130);
-    if(!opt)
+    const option* opt = search_option(130);
+    if (!opt) {
         throw option_not_found();
+    }
     return opt->to<security_type>();
 }
 
 uint16_t IP::stream_identifier() const {
-    const option *opt = search_option(136);
-    if(!opt)
+    const option* opt = search_option(136);
+    if (!opt) {
         throw option_not_found();
+    }
     return opt->to<uint16_t>();
 }
 
-void IP::add_option(const option &opt) {
+void IP::add_option(const option& opt) {
     internal_add_option(opt);
-    _ip_options.push_back(opt);
+    ip_options_.push_back(opt);
 }
 
 void IP::update_padded_options_size() {
-    uint8_t padding = _options_size % 4;
-    _padded_options_size = padding ? (_options_size - padding + 4) : _options_size;
+    uint8_t padding = options_size_ % 4;
+    padded_options_size_ = padding ? (options_size_ - padding + 4) : options_size_;
 }
 
-void IP::internal_add_option(const option &opt) {
-    _options_size += static_cast<uint16_t>(1 + opt.data_size());
+void IP::internal_add_option(const option& opt) {
+    options_size_ += static_cast<uint16_t>(1 + opt.data_size());
     update_padded_options_size();
 }
 
 bool IP::remove_option(option_identifier id) {
     options_type::iterator iter = search_option_iterator(id);
-    if (iter == _ip_options.end()) {
+    if (iter == ip_options_.end()) {
         return false;
     }
-    _options_size -= static_cast<uint16_t>(1 + iter->data_size());
-    _ip_options.erase(iter);
+    options_size_ -= static_cast<uint16_t>(1 + iter->data_size());
+    ip_options_.erase(iter);
     update_padded_options_size();
     return true;
 }
 
-const IP::option *IP::search_option(option_identifier id) const {
+const IP::option* IP::search_option(option_identifier id) const {
     options_type::const_iterator iter = search_option_iterator(id);
-    return (iter != _ip_options.end()) ? &*iter : 0;
+    return (iter != ip_options_.end()) ? &*iter : 0;
 }
 
 IP::options_type::const_iterator IP::search_option_iterator(option_identifier id) const {
     Internals::option_type_equality_comparator<option> comparator(id);
-    return find_if(_ip_options.begin(), _ip_options.end(), comparator);
+    return find_if(ip_options_.begin(), ip_options_.end(), comparator);
 }
 
 IP::options_type::iterator IP::search_option_iterator(option_identifier id) {
     Internals::option_type_equality_comparator<option> comparator(id);
-    return find_if(_ip_options.begin(), _ip_options.end(), comparator);
+    return find_if(ip_options_.begin(), ip_options_.end(), comparator);
 }
 
-void IP::write_option(const option &opt, OutputMemoryStream& stream) {
+void IP::write_option(const option& opt, OutputMemoryStream& stream) {
     stream.write(opt.option());
     // Check what we wrote. We'll do this for any option != [END, NOOP]
     if (*(stream.pointer() - 1) > NOOP) {
@@ -364,10 +365,10 @@ void IP::write_option(const option &opt, OutputMemoryStream& stream) {
     }
 }
 
-/* Virtual method overriding. */
+// Virtual method overriding
 
 uint32_t IP::header_size() const {
-    return sizeof(iphdr) + _padded_options_size;
+    return sizeof(ip_) + padded_options_size_;
 }
 
 PacketSender::SocketType pdu_type_to_sender_type(PDU::PDUType type) {
@@ -388,31 +389,33 @@ 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;
-    if(inner_pdu())
+    link_addr.sin_addr.s_addr = ip_.daddr;
+    if (inner_pdu()) {
         type = pdu_type_to_sender_type(inner_pdu()->pdu_type());
+    }
 
     sender.send_l3(*this, (struct sockaddr*)&link_addr, sizeof(link_addr), type);
 }
 
-PDU *IP::recv_response(PacketSender &sender, const NetworkInterface &) {
+PDU* IP::recv_response(PacketSender& sender, const NetworkInterface &) {
     sockaddr_in link_addr;
     PacketSender::SocketType type = PacketSender::IP_RAW_SOCKET;
-    std::memset(&link_addr, 0, sizeof(link_addr));
-    if(inner_pdu())
+    memset(&link_addr, 0, sizeof(link_addr));
+    if (inner_pdu()) {
         type = pdu_type_to_sender_type(inner_pdu()->pdu_type());
+    }
 
     return sender.recv_l3(*this, 0, sizeof(link_addr), type);
 }
 
-void IP::prepare_for_serialize(const PDU *parent) {
-    if(!parent && _ip.saddr == 0) {
+void IP::prepare_for_serialize(const PDU* parent) {
+    if (!parent && ip_.saddr == 0) {
         NetworkInterface iface(dst_addr());
         src_addr(iface.addresses().ip_addr);
     }
 }
 
-void IP::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU* parent) {
+void IP::write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent) {
     OutputMemoryStream stream(buffer, total_sz);
     checksum(0);
     if (inner_pdu()) {
@@ -428,51 +431,54 @@ void IP::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU* pare
     }
     
     #if __FreeBSD__ || defined(__FreeBSD_kernel__) || __APPLE__
-        if(!parent) {
+        if (!parent) {
             total_sz = Endian::host_to_be<uint16_t>(total_sz);
         }
     #endif
     tot_len(total_sz);
     head_len(static_cast<uint8_t>(header_size() / sizeof(uint32_t)));
 
-    stream.write(_ip);
+    stream.write(ip_);
 
-    for(options_type::const_iterator it = _ip_options.begin(); it != _ip_options.end(); ++it) {
+    for (options_type::const_iterator it = ip_options_.begin(); it != ip_options_.end(); ++it) {
         write_option(*it, stream);
     }
     // Add option padding
-    stream.fill(_padded_options_size - _options_size, 0);
+    stream.fill(padded_options_size_ - options_size_, 0);
 
-    uint32_t check = Utils::do_checksum(buffer, buffer + sizeof(_ip) + _padded_options_size);
+    uint32_t check = Utils::do_checksum(buffer, stream.pointer());
     while (check >> 16) {
         check = (check & 0xffff) + (check >> 16);
     }
     checksum(~check);
-    ((iphdr*)buffer)->check = _ip.check;
+    ((ip_header*)buffer)->check = ip_.check;
 }
 
-bool IP::matches_response(const uint8_t *ptr, uint32_t total_sz) const {
-    if(total_sz < sizeof(iphdr))
+bool IP::matches_response(const uint8_t* ptr, uint32_t total_sz) const {
+    if (total_sz < sizeof(ip_)) {
         return false;
-    const iphdr *ip_ptr = (const iphdr*)ptr;
+    }
+    const ip_header* ip_ptr = (const ip_header*)ptr;
     // dest unreachable?
-    if(ip_ptr->protocol == Constants::IP::PROTO_ICMP) {
-        const uint8_t *pkt_ptr = ptr + sizeof(iphdr);
-        uint32_t pkt_sz = total_sz - sizeof(iphdr);
+    if (ip_ptr->protocol == Constants::IP::PROTO_ICMP) {
+        const uint8_t* pkt_ptr = ptr + sizeof(ip_header);
+        uint32_t pkt_sz = total_sz - sizeof(ip_header);
         // It's an ICMP dest unreachable
-        if(pkt_sz > 4 && pkt_ptr[0] == 3) {
+        if (pkt_sz > 4 && pkt_ptr[0] == 3) {
             pkt_ptr += 4;
             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(iphdr) && std::memcmp(&_ip, pkt_ptr, sizeof(iphdr))) 
+            if (pkt_sz >= sizeof(ip_) && memcmp(&ip_, 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)) {
-        uint32_t sz = std::min<uint32_t>(header_size(), total_sz);
+    if ((ip_.saddr == ip_ptr->daddr && 
+        (ip_.daddr == ip_ptr->saddr || dst_addr().is_broadcast())) ||
+        (dst_addr().is_broadcast() && ip_.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;
     }
     return false;
@@ -480,41 +486,38 @@ bool IP::matches_response(const uint8_t *ptr, uint32_t total_sz) const {
 
 // Option static constructors from options
 
-IP::security_type IP::security_type::from_option(const option &opt) 
-{
-    if(opt.data_size() != 9)
+IP::security_type IP::security_type::from_option(const option& opt)  {
+    if (opt.data_size() != 9) {
         throw malformed_option();
+    }
     security_type output;
-
-    memcpy(&output.security, opt.data_ptr(), sizeof(uint16_t));
-    output.security = Endian::be_to_host(output.security);
-    memcpy(&output.compartments, opt.data_ptr() + sizeof(uint16_t), sizeof(uint16_t));
-    output.compartments = Endian::be_to_host(output.compartments);
-    memcpy(&output.handling_restrictions, opt.data_ptr() + 2 * sizeof(uint16_t), sizeof(uint16_t));
-    output.handling_restrictions = Endian::be_to_host(output.handling_restrictions);
-    uint32_t tcc = opt.data_ptr()[6];
-    tcc = (tcc << 8) | opt.data_ptr()[7];
-    tcc = (tcc << 8) | opt.data_ptr()[8];
+    InputMemoryStream stream(opt.data_ptr(), opt.data_size());
+    output.security = stream.read_be<uint16_t>();
+    output.compartments = stream.read_be<uint16_t>();
+    output.handling_restrictions = stream.read_be<uint16_t>();
+    uint32_t tcc = stream.read<uint8_t>();
+    tcc = (tcc << 8) | stream.read<uint8_t>();
+    tcc = (tcc << 8) | stream.read<uint8_t>();
     output.transmission_control = tcc;
     return output;
 }
 
-IP::generic_route_option_type IP::generic_route_option_type::from_option(
-  const option &opt) 
-{
-    if(opt.data_size() < 1 + sizeof(uint32_t) || ((opt.data_size() - 1) % sizeof(uint32_t)) != 0)
+IP::generic_route_option_type IP::generic_route_option_type::from_option(const option& opt)  {
+    if (opt.data_size() < 1 + sizeof(uint32_t) || ((opt.data_size() - 1) % sizeof(uint32_t)) != 0) {
         throw malformed_option();
+    }
     generic_route_option_type output;
     output.pointer = *opt.data_ptr();
-    const uint8_t *route = opt.data_ptr() + 1;
-    const uint8_t *end = route + opt.data_size() - 1;
+    const uint8_t* route = opt.data_ptr() + 1;
+    const uint8_t* end = route + opt.data_size() - 1;
 
     uint32_t uint32_t_buffer;
-    while(route < end) {
+    while (route < end) {
         memcpy(&uint32_t_buffer, route, sizeof(uint32_t));
         output.routes.push_back(address_type(uint32_t_buffer));
         route += sizeof(uint32_t);
     }
     return output;
 }
-}
+
+} // Tins
diff --git a/src/ip_address.cpp b/src/ip_address.cpp
index ce3e06e..4a1460e 100644
--- a/src/ip_address.cpp
+++ b/src/ip_address.cpp
@@ -40,6 +40,8 @@
 #include "address_range.h"
 
 using std::string;
+using std::ostringstream;
+using std::ostream;
 
 namespace Tins{
 const IPv4Address IPv4Address::broadcast("255.255.255.255");
@@ -54,66 +56,68 @@ const AddressRange<IPv4Address> loopback_range = IPv4Address("127.0.0.0") / 8;
 const AddressRange<IPv4Address> multicast_range = IPv4Address("224.0.0.0") / 4;
     
 IPv4Address::IPv4Address(uint32_t ip) 
-: ip_addr(Endian::be_to_host(ip)) {
+: ip_addr_(Endian::be_to_host(ip)) {
     
 }
 
-IPv4Address::IPv4Address(const char *ip) {
-    ip_addr = ip ? ip_to_int(ip) : 0; 
+IPv4Address::IPv4Address(const char* ip) {
+    ip_addr_ = ip ? ip_to_int(ip) : 0; 
 }
 
-IPv4Address::IPv4Address(const std::string &ip) 
-: ip_addr(ip_to_int(ip.c_str())) {
+IPv4Address::IPv4Address(const std::string& ip) 
+: ip_addr_(ip_to_int(ip.c_str())) {
       
 } 
 
 IPv4Address::operator uint32_t() const { 
-    return Endian::host_to_be(ip_addr); 
+    return Endian::host_to_be(ip_addr_); 
 }
 
-std::string IPv4Address::to_string() const {
-    std::ostringstream oss;
-    oss << *this;
+string IPv4Address::to_string() const {
+    ostringstream oss;
+    oss <<* this;
     return oss.str();
 }
 
 uint32_t IPv4Address::ip_to_int(const char* ip) {
     #ifdef _WIN32
         in_addr addr;
-        if(InetPtonA(AF_INET, ip, &addr)) {
+        if (InetPtonA(AF_INET, ip, &addr)) {
             return Endian::be_to_host(addr.s_addr);
         }
         else {
-            throw std::runtime_error("Invalid ip address");
+            throw invalid_address();
         }
     #else // _WIN32
         in_addr addr;
-        if(inet_pton(AF_INET, ip, &addr) == 1) {
+        if (inet_pton(AF_INET, ip, &addr) == 1) {
             return Endian::be_to_host(addr.s_addr);
         }
         else {
-            throw std::runtime_error("Invalid ip address");
+            throw invalid_address();
         }
     #endif // _WIN32
 }
 
-std::ostream &operator<<(std::ostream &output, const IPv4Address &addr) {
+ostream& operator<<(ostream& output, const IPv4Address& addr) {
     int mask(24);
-    uint32_t ip_addr = addr.ip_addr;
-    while(mask >=0) {
-        output << ((ip_addr >> mask) & 0xff);
-        if(mask)
+    uint32_t ip_addr_ = addr.ip_addr_;
+    while (mask >=0) {
+        output << ((ip_addr_ >> mask) & 0xff);
+        if (mask) {
             output <<  '.';
+        }
         mask -= 8;
     }
     return output;;
 }
 
 bool IPv4Address::is_private() const {
-    const AddressRange<IPv4Address> *iter = private_ranges;
-    while(iter != private_ranges + 3) {
-        if(iter->contains(*this))
+    const AddressRange<IPv4Address>* iter = private_ranges;
+    while (iter != private_ranges + 3) {
+        if (iter->contains(*this)) {
             return true;
+        }
         ++iter;
     }
     return false;
@@ -132,6 +136,7 @@ bool IPv4Address::is_unicast() const {
 }
 
 bool IPv4Address::is_broadcast() const {
-    return *this == broadcast;
-}
+    return* this == broadcast;
 }
+
+} // Tins
diff --git a/src/ip_reassembler.cpp b/src/ip_reassembler.cpp
index 1cb3cbf..4560984 100644
--- a/src/ip_reassembler.cpp
+++ b/src/ip_reassembler.cpp
@@ -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
diff --git a/src/ipsec.cpp b/src/ipsec.cpp
index f0ff1ac..d24942d 100644
--- a/src/ipsec.cpp
+++ b/src/ipsec.cpp
@@ -31,31 +31,39 @@
 #include "ipsec.h"
 #include "internals.h"
 #include "rawpdu.h"
+#include "memory_helpers.h"
+
+using std::memcpy;
+using std::copy;
+
+using Tins::Memory::InputMemoryStream;
+using Tins::Memory::OutputMemoryStream;
 
 namespace Tins {
 
 IPSecAH::IPSecAH() 
-: _header(), _icv(4) {
+: header_(), icv_(4) {
     length(2);
 }
 
-IPSecAH::IPSecAH(const uint8_t *buffer, uint32_t total_sz) {
-    // At least size for the header + 32bits of ICV
-    if(total_sz < sizeof(_header) + sizeof(uint32_t))
-        throw malformed_packet();
-    std::memcpy(&_header, buffer, sizeof(_header));
+IPSecAH::IPSecAH(const uint8_t* buffer, uint32_t total_sz) {
+    InputMemoryStream stream(buffer, total_sz);
+    stream.read(header_);
     const uint32_t ah_len = 4 * (static_cast<uint16_t>(length()) + 2);
-    if(ah_len > total_sz)
+    if (ah_len < sizeof(header_)) {
         throw malformed_packet();
-    _icv.assign(buffer + sizeof(_header), buffer + ah_len);
-    buffer += ah_len;
-    total_sz -= ah_len;
-    if(total_sz) {
+    }
+    const uint32_t icv_length = ah_len - sizeof(header_);
+    if (!stream.can_read(icv_length)) {
+        throw malformed_packet();
+    }
+    stream.read(icv_, icv_length);
+    if (stream) {
         inner_pdu(
             Internals::pdu_from_flag(
                 static_cast<Constants::IP::e>(next_header()),
-                buffer, 
-                total_sz,
+                stream.pointer(), 
+                stream.size(), 
                 true
             )
         );
@@ -63,73 +71,69 @@ IPSecAH::IPSecAH(const uint8_t *buffer, uint32_t total_sz) {
 }
 
 void IPSecAH::next_header(uint8_t new_next_header) {
-    _header.next_header = new_next_header;
+    header_.next_header = new_next_header;
 }
 
 void IPSecAH::length(uint8_t new_length) {
-    _header.length = new_length;
+    header_.length = new_length;
 }
 
 void IPSecAH::spi(uint32_t new_spi) {
-    _header.spi = Endian::host_to_be(new_spi);
+    header_.spi = Endian::host_to_be(new_spi);
 }
 
 void IPSecAH::seq_number(uint32_t new_seq_number) {
-    _header.seq_number = Endian::host_to_be(new_seq_number);
+    header_.seq_number = Endian::host_to_be(new_seq_number);
 }
 
-void IPSecAH::icv(const byte_array &new_icv) {
-    _icv = new_icv;
+void IPSecAH::icv(const byte_array& newicv_) {
+    icv_ = newicv_;
 }
 
 uint32_t IPSecAH::header_size() const {
-    return static_cast<uint32_t>(sizeof(_header) + _icv.size());
+    return static_cast<uint32_t>(sizeof(header_) + icv_.size());
 }
 
-void IPSecAH::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *) {
-    if(inner_pdu())
+void IPSecAH::write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU *) {
+    if (inner_pdu()) {
         next_header(Internals::pdu_flag_to_ip_type(inner_pdu()->pdu_type()));
-    std::memcpy(buffer, &_header, sizeof(_header));
-    std::copy(  
-        _icv.begin(),
-        _icv.end(),
-        buffer + sizeof(_header)
-    );
+    }
+    length(header_size() / sizeof(uint32_t) - 2);
+    OutputMemoryStream output(buffer, total_sz);
+    output.write(header_);
+    output.write(icv_.begin(), icv_.end());
 }
 
 // IPSecESP
 
 IPSecESP::IPSecESP() 
-: _header()
-{
+: header_() {
 
 }
 
-IPSecESP::IPSecESP(const uint8_t *buffer, uint32_t total_sz) {
-    if(total_sz < sizeof(_header))
-        throw malformed_packet();
-    std::memcpy(&_header, buffer, sizeof(_header));
-    buffer += sizeof(_header);
-    total_sz -= sizeof(_header);
-    if(total_sz) {
-        inner_pdu(new RawPDU(buffer, total_sz));
+IPSecESP::IPSecESP(const uint8_t* buffer, uint32_t total_sz) {
+    InputMemoryStream stream(buffer, total_sz);
+    stream.read(header_);
+    if (stream) {
+        inner_pdu(new RawPDU(stream.pointer(), stream.size()));
     }
 }
 
 void IPSecESP::spi(uint32_t new_spi) {
-    _header.spi = Endian::host_to_be(new_spi);
+    header_.spi = Endian::host_to_be(new_spi);
 }
 
 void IPSecESP::seq_number(uint32_t new_seq_number) {
-    _header.seq_number = Endian::host_to_be(new_seq_number);
+    header_.seq_number = Endian::host_to_be(new_seq_number);
 }
 
 uint32_t IPSecESP::header_size() const {
-    return sizeof(_header);
+    return sizeof(header_);
 }
 
-void IPSecESP::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *) {
-    std::memcpy(buffer, &_header, sizeof(_header));
+void IPSecESP::write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU *) {
+    OutputMemoryStream output(buffer, total_sz);
+    output.write(header_);
 }
 
-}
+} // Tins
diff --git a/src/ipv6.cpp b/src/ipv6.cpp
index e3025f3..6656ed4 100644
--- a/src/ipv6.cpp
+++ b/src/ipv6.cpp
@@ -44,27 +44,27 @@
 #include "internals.h"
 #include "memory_helpers.h"
 
+using std::copy;
+
 using Tins::Memory::InputMemoryStream;
 using Tins::Memory::OutputMemoryStream;
 
 namespace Tins {
 
-IPv6::IPv6(address_type ip_dst, address_type ip_src, PDU *child) 
-: _header(), headers_size(0)
-{
+IPv6::IPv6(address_type ip_dst, address_type ip_src, PDU* child) 
+: header_(), headers_size_(0) {
     version(6);
     dst_addr(ip_dst);
     src_addr(ip_src);
 }
 
-IPv6::IPv6(const uint8_t *buffer, uint32_t total_sz) 
-: headers_size(0) 
-{
+IPv6::IPv6(const uint8_t* buffer, uint32_t total_sz) 
+: headers_size_(0) {
     InputMemoryStream stream(buffer, total_sz);
-    stream.read(_header);
-    uint8_t current_header = _header.next_header;
+    stream.read(header_);
+    uint8_t current_header = header_.next_header;
     while (stream) {
-        if(is_extension_header(current_header)) {
+        if (is_extension_header(current_header)) {
             const uint8_t ext_type = stream.read<uint8_t>();
             // every ext header is at least 8 bytes long
             // minus one, from the next_header field.
@@ -88,7 +88,7 @@ IPv6::IPv6(const uint8_t *buffer, uint32_t total_sz)
                     false
                 )
             );
-            if(!inner_pdu()) {
+            if (!inner_pdu()) {
                 inner_pdu(
                     Internals::allocate<IPv6>(
                         current_header,
@@ -96,7 +96,7 @@ IPv6::IPv6(const uint8_t *buffer, uint32_t total_sz)
                         stream.size()
                     )
                 );
-                if(!inner_pdu()) {
+                if (!inner_pdu()) {
                     inner_pdu(new Tins::RawPDU(stream.pointer(), stream.size()));
                 }
             }
@@ -114,81 +114,85 @@ bool IPv6::is_extension_header(uint8_t header_id) {
 }
 
 void IPv6::version(small_uint<4> new_version) {
-    _header.version = new_version;
+    header_.version = new_version;
 }
 
 void IPv6::traffic_class(uint8_t new_traffic_class) {
     #if TINS_IS_LITTLE_ENDIAN
-    _header.traffic_class = (new_traffic_class >> 4) & 0xf;
-    _header.flow_label[0] = (_header.flow_label[0] & 0x0f) | ((new_traffic_class << 4) & 0xf0);
+    header_.traffic_class = (new_traffic_class >> 4) & 0xf;
+    header_.flow_label[0] = (header_.flow_label[0] & 0x0f) | ((new_traffic_class << 4) & 0xf0);
     #else
-    _header.traffic_class = new_traffic_class;
+    header_.traffic_class = new_traffic_class;
     #endif
 }
 
 void IPv6::flow_label(small_uint<20> new_flow_label) {
     #if TINS_IS_LITTLE_ENDIAN
     uint32_t value = Endian::host_to_be<uint32_t>(new_flow_label);
-    _header.flow_label[2] = (value >> 24) & 0xff;
-    _header.flow_label[1] = (value >> 16) & 0xff;
-    _header.flow_label[0] = ((value >> 8) & 0x0f) | (_header.flow_label[0] & 0xf0);
+    header_.flow_label[2] = (value >> 24) & 0xff;
+    header_.flow_label[1] = (value >> 16) & 0xff;
+    header_.flow_label[0] = ((value >> 8) & 0x0f) | (header_.flow_label[0] & 0xf0);
     #else
-    _header.flow_label = new_flow_label;
+    header_.flow_label = new_flow_label;
     #endif
 }
 
 void IPv6::payload_length(uint16_t new_payload_length) {
-    _header.payload_length = Endian::host_to_be(new_payload_length);
+    header_.payload_length = Endian::host_to_be(new_payload_length);
 }
 
 void IPv6::next_header(uint8_t new_next_header) {
-    _header.next_header = new_next_header;
+    header_.next_header = new_next_header;
 }
 
 void IPv6::hop_limit(uint8_t new_hop_limit) {
-    _header.hop_limit = new_hop_limit;
+    header_.hop_limit = new_hop_limit;
 }
 
-void IPv6::src_addr(const address_type &new_src_addr) {
-    new_src_addr.copy(_header.src_addr);
+void IPv6::src_addr(const address_type& new_src_addr) {
+    new_src_addr.copy(header_.src_addr);
 }
 
-void IPv6::dst_addr(const address_type &new_dst_addr) {
-    new_dst_addr.copy(_header.dst_addr);
+void IPv6::dst_addr(const address_type& new_dst_addr) {
+    new_dst_addr.copy(header_.dst_addr);
 }
 
 uint32_t IPv6::header_size() const {
-    return sizeof(_header) + headers_size;
+    return sizeof(header_) + headers_size_;
 }
 
-bool IPv6::matches_response(const uint8_t *ptr, uint32_t total_sz) const {
-    if(total_sz < sizeof(ipv6_header))
+bool IPv6::matches_response(const uint8_t* ptr, uint32_t total_sz) const {
+    if (total_sz < sizeof(ipv6_header)) {
         return false;
-    const ipv6_header *hdr_ptr = (const ipv6_header*)ptr;
+    }
+    const ipv6_header* hdr_ptr = (const ipv6_header*)ptr;
     // checks for ff02 multicast
-    if(src_addr() == hdr_ptr->dst_addr && 
-        (dst_addr() == hdr_ptr->src_addr || (_header.dst_addr[0] == 0xff && _header.dst_addr[1] == 0x02))) {
+    if (src_addr() == hdr_ptr->dst_addr && 
+        (dst_addr() == hdr_ptr->src_addr || (header_.dst_addr[0] == 0xff && header_.dst_addr[1] == 0x02))) {
         // is this OK? there's no inner pdu, simple dst/src addr match should suffice
-        if(!inner_pdu())
+        if (!inner_pdu()) {
             return true;
+        }
         ptr += sizeof(ipv6_header);
         total_sz -= sizeof(ipv6_header);
         uint8_t current = hdr_ptr->next_header;
         // 8 == minimum header size
-        while(total_sz > 8 && is_extension_header(current)) {
-            if(static_cast<uint32_t>(ptr[1] + 1) * 8 > total_sz)
+        while (total_sz > 8 && is_extension_header(current)) {
+            if (static_cast<uint32_t>(ptr[1] + 1) * 8 > total_sz) {
                 return false;
+            }
             current = ptr[0];
             total_sz -= (ptr[1] + 1) * 8;
             ptr += (ptr[1] + 1) * 8;
         }
-        if(!is_extension_header(current)) 
+        if (!is_extension_header(current)) {
             return inner_pdu()->matches_response(ptr, total_sz);
+        }
     }
     return false;
 }
 
-void IPv6::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent) {
+void IPv6::write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent) {
     OutputMemoryStream stream(buffer, total_sz);
     if (inner_pdu()) {
         uint8_t new_flag = Internals::pdu_flag_to_ip_type(inner_pdu()->pdu_type());
@@ -199,52 +203,56 @@ void IPv6::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *pa
         }
         set_last_next_header(new_flag);
     }
-    payload_length(static_cast<uint16_t>(total_sz - sizeof(_header)));
-    stream.write(_header);
-    for(headers_type::const_iterator it = ext_headers.begin(); it != ext_headers.end(); ++it) {
+    payload_length(static_cast<uint16_t>(total_sz - sizeof(header_)));
+    stream.write(header_);
+    for (headers_type::const_iterator it = ext_headers_.begin(); it != ext_headers_.end(); ++it) {
         write_header(*it, stream);
     }
 }
 
 #ifndef BSD
-void IPv6::send(PacketSender &sender, const NetworkInterface &) {
+void IPv6::send(PacketSender& sender, const NetworkInterface &) {
     struct sockaddr_in6 link_addr;
     PacketSender::SocketType type = PacketSender::IPV6_SOCKET;
     link_addr.sin6_family = AF_INET6;
     link_addr.sin6_port = 0;
-    std::copy(_header.dst_addr, _header.dst_addr + address_type::address_size, (uint8_t*)&link_addr.sin6_addr);
-    if(inner_pdu() && inner_pdu()->pdu_type() == PDU::ICMP)
+    copy(header_.dst_addr, header_.dst_addr + address_type::address_size, (uint8_t*)&link_addr.sin6_addr);
+    if (inner_pdu() && inner_pdu()->pdu_type() == PDU::ICMP) {
         type = PacketSender::ICMP_SOCKET;
+    }
 
     sender.send_l3(*this, (struct sockaddr*)&link_addr, sizeof(link_addr), type);
 }
 #endif
 
-void IPv6::add_ext_header(const ext_header &header) {
-    ext_headers.push_back(header);
-    headers_size += static_cast<uint32_t>(header.data_size() + sizeof(uint8_t) * 2);
+void IPv6::add_ext_header(const ext_header& header) {
+    ext_headers_.push_back(header);
+    headers_size_ += static_cast<uint32_t>(header.data_size() + sizeof(uint8_t) * 2);
 }
 
-const IPv6::ext_header *IPv6::search_header(ExtensionHeader id) const {
-    uint8_t current_header = _header.next_header;
-    headers_type::const_iterator it = ext_headers.begin();
-    while(it != ext_headers.end() && current_header != id) {
+const IPv6::ext_header* IPv6::search_header(ExtensionHeader id) const {
+    uint8_t current_header = header_.next_header;
+    headers_type::const_iterator it = ext_headers_.begin();
+    while (it != ext_headers_.end() && current_header != id) {
         current_header = it->option();
         ++it;
     }
-    if(it == ext_headers.end())
+    if (it == ext_headers_.end()) {
         return 0;
+    }
     return &*it;
 }
 
 void IPv6::set_last_next_header(uint8_t value) {
-    if(ext_headers.empty())
-        _header.next_header = value;
-    else 
-        ext_headers.back().option(value);
+    if (ext_headers_.empty()) {
+        header_.next_header = value;
+    }
+    else {
+        ext_headers_.back().option(value);
+    }
 }
 
-void IPv6::write_header(const ext_header &header, OutputMemoryStream& stream) {
+void IPv6::write_header(const ext_header& header, OutputMemoryStream& stream) {
     const uint8_t length = header.length_field() / 8;
     stream.write(header.option());
     stream.write(length);
diff --git a/src/ipv6_address.cpp b/src/ipv6_address.cpp
index 44b9ac0..655f5f5 100644
--- a/src/ipv6_address.cpp
+++ b/src/ipv6_address.cpp
@@ -42,61 +42,72 @@
 #include <sstream>
 #include "ipv6_address.h"
 #include "address_range.h"
+#include "exceptions.h"
+
+using std::fill;
+using std::string;
 
 namespace Tins {
+
 const IPv6Address loopback_address = "::1";
 const AddressRange<IPv6Address> multicast_range = IPv6Address("ff00::") / 8;
 
 IPv6Address::IPv6Address() {
-    std::fill(address, address + address_size, 0);
+    fill(address_, address_ + address_size, 0);
 }
 
-IPv6Address::IPv6Address(const char *addr) {
+IPv6Address::IPv6Address(const char* addr) {
     init(addr);
 }
 
 IPv6Address::IPv6Address(const_iterator ptr) {
-    std::copy(ptr, ptr + address_size, address);
+    std::copy(ptr, ptr + address_size, address_);
 }
 
-IPv6Address::IPv6Address(const std::string &addr) {
+IPv6Address::IPv6Address(const std::string& addr) {
     init(addr.c_str());
 }
 
-void IPv6Address::init(const char *addr) {
+void IPv6Address::init(const char* addr) {
     #ifdef _WIN32
         // mingw on linux somehow doesn't have InetPton
         #ifdef _MSC_VER
-            if(InetPtonA(AF_INET6, addr, address) != 1)
-                throw malformed_address();
+            if (InetPtonA(AF_INET6, addr, address_) != 1) {
+                throw invalid_address();
+            }
         #else
             ULONG dummy1;
             USHORT dummy2;
             // Maybe change this, mingw doesn't have any other conversion function
-            if(RtlIpv6StringToAddressExA(addr, (IN6_ADDR*)address, &dummy1, &dummy2) != NO_ERROR)
-                throw malformed_address();
+            if (RtlIpv6StringToAddressExA(addr, (IN6_ADDR*)address_, &dummy1, &dummy2) != NO_ERROR) {
+                throw invalid_address();
+            }
         #endif
     #else
-        if(inet_pton(AF_INET6, addr, address) == 0)
-            throw malformed_address();
+        if (inet_pton(AF_INET6, addr, address_) == 0) {
+            throw invalid_address();
+        }
     #endif            
 }
 
-std::string IPv6Address::to_string() const {
+string IPv6Address::to_string() const {
     char buffer[INET6_ADDRSTRLEN];
     #ifdef _WIN32
         // mingw on linux somehow doesn't have InetNtop
         #ifdef _MSC_VER
-            if(InetNtopA(AF_INET6, (PVOID)address, buffer, sizeof(buffer)) == 0)
-                throw malformed_address();
+            if (InetNtopA(AF_INET6, (PVOID)address_, buffer, sizeof(buffer)) == 0) {
+                throw invalid_address();
+            }
         #else
             ULONG sz = sizeof(buffer);
-            if(RtlIpv6AddressToStringExA((const IN6_ADDR*)address, 0, 0, buffer, &sz) != NO_ERROR)
-                throw malformed_address();
+            if (RtlIpv6AddressToStringExA((const IN6_ADDR*)address_, 0, 0, buffer, &sz) != NO_ERROR) {
+                throw invalid_address();
+            }
         #endif
     #else
-        if(inet_ntop(AF_INET6, address, buffer, sizeof(buffer)) == 0)
-            throw malformed_address();
+        if (inet_ntop(AF_INET6, address_, buffer, sizeof(buffer)) == 0) {
+            throw invalid_address();
+        }
     #endif
     return buffer;
 }
@@ -108,5 +119,5 @@ bool IPv6Address::is_loopback() const {
 bool IPv6Address::is_multicast() const {
     return multicast_range.contains(*this);
 }
-}
 
+} // Tins
diff --git a/src/llc.cpp b/src/llc.cpp
index 45c5bce..868fee8 100644
--- a/src/llc.cpp
+++ b/src/llc.cpp
@@ -44,28 +44,26 @@ const uint8_t LLC::GLOBAL_DSAP_ADDR = 0xFF;
 const uint8_t LLC::NULL_ADDR = 0x00;
 
 LLC::LLC()
-: _header(), control_field(), _type(LLC::INFORMATION) 
-{
-	control_field_length = 2;
-	information_field_length = 0;
+: header_(), control_field(), type_(LLC::INFORMATION) {
+	control_field_length_ = 2;
+	information_field_length_ = 0;
 }
 
 LLC::LLC(uint8_t dsap, uint8_t ssap) 
-: control_field(), _type(LLC::INFORMATION) 
-{
-	_header.dsap = dsap;
-	_header.ssap = ssap;
-	control_field_length = 2;
-	information_field_length = 0;
+: control_field(), type_(LLC::INFORMATION) {
+	header_.dsap = dsap;
+	header_.ssap = ssap;
+	control_field_length_ = 2;
+	information_field_length_ = 0;
 }
 
-LLC::LLC(const uint8_t *buffer, uint32_t total_sz) {
+LLC::LLC(const uint8_t* buffer, uint32_t total_sz) {
     InputMemoryStream stream(buffer, total_sz);
-    stream.read(_header);
+    stream.read(header_);
     if (!stream) {
         throw malformed_packet();
     }
-	information_field_length = 0;
+	information_field_length_ = 0;
 	if ((*stream.pointer() & 0x03) == LLC::UNNUMBERED) {
 		type(LLC::UNNUMBERED);
         stream.read(control_field.unnumbered);
@@ -73,7 +71,7 @@ LLC::LLC(const uint8_t *buffer, uint32_t total_sz) {
 	}
 	else {
 		type((Format)(*stream.pointer() & 0x03));
-		control_field_length = 2;
+		control_field_length_ = 2;
 		stream.read(control_field.info);
 	}
     if (stream) {
@@ -88,51 +86,52 @@ LLC::LLC(const uint8_t *buffer, uint32_t total_sz) {
 
 void LLC::group(bool value) {
 	if (value) {
-		_header.dsap |= 0x01;
+		header_.dsap |= 0x01;
 	}
 	else {
-		_header.dsap &= 0xFE;
+		header_.dsap &= 0xFE;
 	}
 }
 
 void LLC::dsap(uint8_t new_dsap) {
-	_header.dsap = new_dsap;
+	header_.dsap = new_dsap;
 }
 
 void LLC::response(bool value) {
 	if (value) {
-		_header.ssap |= 0x01;
+		header_.ssap |= 0x01;
 	}
 	else {
-		_header.ssap &= 0xFE;
+		header_.ssap &= 0xFE;
 	}
 }
 
 void LLC::ssap(uint8_t new_ssap) {
-	_header.ssap = new_ssap;
+	header_.ssap = new_ssap;
 }
 
 void LLC::type(LLC::Format type) {
-	_type = type;
+	type_ = type;
 	switch (type) {
 		case LLC::INFORMATION:
-			control_field_length = 2;
+			control_field_length_ = 2;
 			control_field.info.type_bit = 0;
 			break;
 		case LLC::SUPERVISORY:
-			control_field_length = 2;
+			control_field_length_ = 2;
 			control_field.super.type_bit = 1;
 			break;
 		case LLC::UNNUMBERED:
-			control_field_length = 1;
+			control_field_length_ = 1;
 			control_field.unnumbered.type_bits = 3;
 			break;
 	}
 }
 
 void LLC::send_seq_number(uint8_t seq_number) {
-	if (type() != LLC::INFORMATION)
+	if (type() != LLC::INFORMATION) {
 		return;
+    }
 	control_field.info.send_seq_num = seq_number;
 }
 
@@ -165,14 +164,16 @@ void LLC::poll_final(bool value) {
 }
 
 void LLC::supervisory_function(LLC::SupervisoryFunctions new_func) {
-	if (type() != LLC::SUPERVISORY)
+	if (type() != LLC::SUPERVISORY) {
 		return;
+    }
 	control_field.super.supervisory_func = new_func;
 }
 
 void LLC::modifier_function(LLC::ModifierFunctions mod_func) {
-	if (type() != LLC::UNNUMBERED)
+	if (type() != LLC::UNNUMBERED) {
 		return;
+    }
 	control_field.unnumbered.mod_func1 = mod_func >> 3;
 	control_field.unnumbered.mod_func2 = mod_func & 0x07;
 }
@@ -182,26 +183,26 @@ void LLC::add_xid_information(uint8_t xid_id, uint8_t llc_type_class, uint8_t re
     xid[0] = xid_id;
     xid[1] = llc_type_class;
     xid[2] = receive_window;
-	information_field_length += static_cast<uint8_t>(xid.size());
-    information_fields.push_back(xid);
+	information_field_length_ += static_cast<uint8_t>(xid.size());
+    information_fields_.push_back(xid);
 }
 
 uint32_t LLC::header_size() const {
-	return sizeof(_header) + control_field_length + information_field_length;
+	return sizeof(header_) + control_field_length_ + information_field_length_;
 }
 
 void LLC::clear_information_fields() {
-	information_field_length = 0;
-	information_fields.clear();
+	information_field_length_ = 0;
+	information_fields_.clear();
 }
 
-void LLC::write_serialization(uint8_t *buffer, uint32_t total_sz, const Tins::PDU *parent) {
+void LLC::write_serialization(uint8_t* buffer, uint32_t total_sz, const Tins::PDU* parent) {
     OutputMemoryStream stream(buffer, total_sz);
     if (inner_pdu() && inner_pdu()->pdu_type() == PDU::STP) {
         dsap(0x42);
         ssap(0x42);
     }
-    stream.write(_header);
+    stream.write(header_);
 	switch (type()) {
 		case LLC::UNNUMBERED:
             stream.write(control_field.unnumbered);
@@ -214,9 +215,9 @@ void LLC::write_serialization(uint8_t *buffer, uint32_t total_sz, const Tins::PD
 			break;
 	}
 
-	for (field_list::const_iterator it = information_fields.begin(); it != information_fields.end(); it++) {
+	for (field_list::const_iterator it = information_fields_.begin(); it != information_fields_.end(); it++) {
         stream.write(it->begin(), it->end());
 	}
 }
 
-}
+} // Tins
diff --git a/src/loopback.cpp b/src/loopback.cpp
index 6e5a0e3..80d8fdc 100644
--- a/src/loopback.cpp
+++ b/src/loopback.cpp
@@ -58,18 +58,16 @@ using Tins::Memory::OutputMemoryStream;
 namespace Tins {
 
 Loopback::Loopback()
-: _family()
-{
+: family_() {
     
 }
 
-Loopback::Loopback(const uint8_t *buffer, uint32_t total_sz) 
-{
+Loopback::Loopback(const uint8_t* buffer, uint32_t total_sz) {
     InputMemoryStream stream(buffer, total_sz);
-    _family = stream.read<uint32_t>();
+    family_ = stream.read<uint32_t>();
     #ifndef _WIN32
     if (total_sz) {
-        switch (_family) {
+        switch (family_) {
             case PF_INET:
                 inner_pdu(new Tins::IP(stream.pointer(), stream.size()));
                 break;
@@ -85,44 +83,46 @@ Loopback::Loopback(const uint8_t *buffer, uint32_t total_sz)
 }
     
 void Loopback::family(uint32_t family_id) {
-    _family = family_id;
+    family_ = family_id;
 }
 
 uint32_t Loopback::header_size() const {
-    return sizeof(_family);
+    return sizeof(family_);
 }
 
-void Loopback::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *) {
+void Loopback::write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU *) {
     OutputMemoryStream stream(buffer, total_sz);
     #ifndef _WIN32
     if (tins_cast<const Tins::IP*>(inner_pdu())) {
-        _family = PF_INET;
+        family_ = PF_INET;
     }
     else if (tins_cast<const Tins::LLC*>(inner_pdu())) {
-        _family = PF_LLC;
+        family_ = PF_LLC;
     }
-    stream.write(_family);
+    stream.write(family_);
     #endif // _WIN32
 }
 
-bool Loopback::matches_response(const uint8_t *ptr, uint32_t total_sz) const {
-    if(total_sz < sizeof(_family)) {
+bool Loopback::matches_response(const uint8_t* ptr, uint32_t total_sz) const {
+    if (total_sz < sizeof(family_)) {
         return false;
     }
     // If there's an inner_pdu, check if the inner pdu matches.
     // Otherwise, just check this loopback family.
     
     return inner_pdu() ? 
-        inner_pdu()->matches_response(ptr + sizeof(_family), total_sz - sizeof(_family)) :
-        (_family == *reinterpret_cast<const uint32_t*>(ptr));
+           inner_pdu()->matches_response(ptr + sizeof(family_), total_sz - sizeof(family_)) :
+           (family_ == *reinterpret_cast<const uint32_t*>(ptr));
 }
 
 #ifdef BSD
-void Loopback::send(PacketSender &sender, const NetworkInterface &iface) {
-    if(!iface)
+void Loopback::send(PacketSender& sender, const NetworkInterface& iface) {
+    if (!iface) {
         throw invalid_interface();
+    }
     
     sender.send_l2(*this, 0, 0, iface);
 }
 #endif // _WIN32
-}
+
+} // Tins
diff --git a/src/mpls.cpp b/src/mpls.cpp
index 1854a5b..cd0b057 100644
--- a/src/mpls.cpp
+++ b/src/mpls.cpp
@@ -29,6 +29,8 @@
 
 #include "mpls.h"
 #include "ip.h"
+#include "ipv6.h"
+#include "rawpdu.h"
 #include "memory_helpers.h"
 #include "icmp_extension.h"
 
@@ -52,7 +54,16 @@ MPLS::MPLS(const uint8_t* buffer, uint32_t total_sz) {
     if (stream) {
         // If this is the last MPLS, then construct an IP
         if (bottom_of_stack()) {
-            inner_pdu(new Tins::IP(stream.pointer(), stream.size()));
+            uint8_t version = (*stream.pointer() >> 4) & 0x0f;
+            if (version == 4) {
+                inner_pdu(new Tins::IP(stream.pointer(), stream.size()));
+            }
+            else if (version == 6) {
+                inner_pdu(new Tins::IPv6(stream.pointer(), stream.size()));
+            }
+            else {
+                inner_pdu(new Tins::RawPDU(stream.pointer(), stream.size()));
+            }
         }
         else {
             inner_pdu(new MPLS(stream.pointer(), stream.size()));
@@ -80,7 +91,7 @@ uint32_t MPLS::header_size() const {
     return sizeof(header_);
 }
 
-void MPLS::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent) {
+void MPLS::write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent) {
     OutputMemoryStream stream(buffer, total_sz);
     // If we have a parent PDU, we might set the bottom-of-stack field
     if (parent) {
diff --git a/src/network_interface.cpp b/src/network_interface.cpp
index ab1dc76..aea6b99 100644
--- a/src/network_interface.cpp
+++ b/src/network_interface.cpp
@@ -48,59 +48,65 @@
 #include "network_interface.h"
 #include "utils.h"
 #include "endianness.h"
+#include "exceptions.h"
 
 using std::string;
 using std::vector;
 using std::set;
+using std::copy;
 
 /** \cond */
 struct InterfaceInfoCollector {
     typedef Tins::NetworkInterface::Info info_type;
-    info_type *info;
+    info_type* info;
     int iface_id;
     const char* iface_name;
     bool found_hw;
     bool found_ip;
 
-    InterfaceInfoCollector(info_type *res, int id, const char* if_name) 
+    InterfaceInfoCollector(info_type* res, int id, const char* if_name) 
     : info(res), iface_id(id), iface_name(if_name), found_hw(false), found_ip(false) { }
     
     #ifndef WIN32
-    bool operator() (const struct ifaddrs *addr) {
+    bool operator() (const struct ifaddrs* addr) {
         using Tins::Endian::host_to_be;
-            using Tins::IPv4Address;
+        using Tins::IPv4Address;
         #if defined(BSD) || defined(__FreeBSD_kernel__)
             const struct sockaddr_dl* addr_ptr = ((struct sockaddr_dl*)addr->ifa_addr);
             
-            if(addr->ifa_addr->sa_family == AF_LINK && addr_ptr->sdl_index == iface_id) {
+            if (addr->ifa_addr->sa_family == AF_LINK && addr_ptr->sdl_index == iface_id) {
                 info->hw_addr = (const uint8_t*)LLADDR(addr_ptr); // mmmm
                 found_hw = true;
             }
-            else if(addr->ifa_addr->sa_family == AF_INET && !std::strcmp(addr->ifa_name, iface_name)) {
+            else if (addr->ifa_addr->sa_family == AF_INET && !std::strcmp(addr->ifa_name, iface_name)) {
                 info->ip_addr = IPv4Address(((struct sockaddr_in *)addr->ifa_addr)->sin_addr.s_addr);
                 info->netmask = IPv4Address(((struct sockaddr_in *)addr->ifa_netmask)->sin_addr.s_addr);
-                if((addr->ifa_flags & (IFF_BROADCAST | IFF_POINTOPOINT)))
+                if ((addr->ifa_flags & (IFF_BROADCAST | IFF_POINTOPOINT))) {
                     info->bcast_addr = IPv4Address(((struct sockaddr_in *)addr->ifa_dstaddr)->sin_addr.s_addr);
-                else
+                }
+                else {
                     info->bcast_addr = 0;
+                }
                 info->is_up = (addr->ifa_flags & IFF_UP);
                 found_ip = true;
             }
         #else
             const struct sockaddr_ll* addr_ptr = ((struct sockaddr_ll*)addr->ifa_addr);
             
-            if(addr->ifa_addr) {
-                if(addr->ifa_addr->sa_family == AF_PACKET && addr_ptr->sll_ifindex == iface_id) {
+            if (addr->ifa_addr) {
+                if (addr->ifa_addr->sa_family == AF_PACKET && addr_ptr->sll_ifindex == iface_id) {
                     info->hw_addr = addr_ptr->sll_addr;
                     found_hw = true;
                 }
-                else if(addr->ifa_addr->sa_family == AF_INET && !std::strcmp(addr->ifa_name, iface_name)) {
+                else if (addr->ifa_addr->sa_family == AF_INET && !std::strcmp(addr->ifa_name, iface_name)) {
                     info->ip_addr = IPv4Address(((struct sockaddr_in *)addr->ifa_addr)->sin_addr.s_addr);
                     info->netmask = IPv4Address(((struct sockaddr_in *)addr->ifa_netmask)->sin_addr.s_addr);
-                    if((addr->ifa_flags & (IFF_BROADCAST | IFF_POINTOPOINT)))
+                    if ((addr->ifa_flags & (IFF_BROADCAST | IFF_POINTOPOINT))) {
                         info->bcast_addr = IPv4Address(((struct sockaddr_in *)addr->ifa_broadaddr)->sin_addr.s_addr);
-                    else
+                    }
+                    else {
                         info->bcast_addr = 0;
+                    }
                     info->is_up = (addr->ifa_flags & IFF_UP);
                     found_ip = true;
                 }
@@ -110,13 +116,13 @@ struct InterfaceInfoCollector {
         return found_ip && found_hw;
     }
     #else // WIN32
-    bool operator() (const IP_ADAPTER_ADDRESSES *iface) {
+    bool operator() (const IP_ADAPTER_ADDRESSES* iface) {
         using Tins::IPv4Address;
         using Tins::Endian::host_to_be;
-        if(iface_id == uint32_t(iface->IfIndex)) {
-            std::copy(iface->PhysicalAddress, iface->PhysicalAddress + 6, info->hw_addr.begin());
-            const IP_ADAPTER_UNICAST_ADDRESS *unicast = iface->FirstUnicastAddress;
-            if(unicast) {
+        if (iface_id == uint32_t(iface->IfIndex)) {
+            copy(iface->PhysicalAddress, iface->PhysicalAddress + 6, info->hw_addr.begin());
+            const IP_ADAPTER_UNICAST_ADDRESS* unicast = iface->FirstUnicastAddress;
+            if (unicast) {
                 info->ip_addr = IPv4Address(((const struct sockaddr_in *)unicast->Address.lpSockaddr)->sin_addr.s_addr);
                 info->netmask = IPv4Address(host_to_be<uint32_t>(0xffffffff << (32 - unicast->OnLinkPrefixLength)));
                 info->bcast_addr = IPv4Address((info->ip_addr & info->netmask) | ~info->netmask);
@@ -132,6 +138,7 @@ struct InterfaceInfoCollector {
 /** \endcond */
 
 namespace Tins {
+
 // static
 NetworkInterface NetworkInterface::default_interface() {
     return NetworkInterface(IPv4Address(uint32_t(0)));
@@ -140,77 +147,82 @@ NetworkInterface NetworkInterface::default_interface() {
 vector<NetworkInterface> NetworkInterface::all() {
     const set<string> interfaces = Utils::network_interfaces();
     vector<NetworkInterface> output;
-    for(set<string>::const_iterator it = interfaces.begin(); it != interfaces.end(); ++it) {
+    for (set<string>::const_iterator it = interfaces.begin(); it != interfaces.end(); ++it) {
         output.push_back(*it);
     }
     return output;
 }
     
-NetworkInterface::NetworkInterface() : iface_id(0) {
+NetworkInterface::NetworkInterface()
+: iface_id_(0) {
 
 }
 
 NetworkInterface NetworkInterface::from_index(id_type identifier) {
     NetworkInterface iface;
-    iface.iface_id = identifier;
+    iface.iface_id_ = identifier;
     return iface;
 }
 
-NetworkInterface::NetworkInterface(const char *name) {
-    iface_id = name ? resolve_index(name) : 0;
+NetworkInterface::NetworkInterface(const char* name) {
+    iface_id_ = name ? resolve_index(name) : 0;
 }    
 
-NetworkInterface::NetworkInterface(const std::string &name) {
-    iface_id = resolve_index(name.c_str());
+NetworkInterface::NetworkInterface(const std::string& name) {
+    iface_id_ = resolve_index(name.c_str());
 }
 
-NetworkInterface::NetworkInterface(IPv4Address ip) : iface_id(0) {
-    typedef std::vector<Utils::RouteEntry> entries_type;
+NetworkInterface::NetworkInterface(IPv4Address ip) 
+: iface_id_(0) {
+    typedef vector<Utils::RouteEntry> entries_type;
     
-    if(ip == "127.0.0.1")
+    if (ip == "127.0.0.1") {
         #if defined(BSD) || defined(__FreeBSD_kernel__)
-        iface_id = resolve_index("lo0");
+        iface_id_ = resolve_index("lo0");
         #else
-        iface_id = resolve_index("lo");
+        iface_id_ = resolve_index("lo");
         #endif
+    }
     else {
-        const Utils::RouteEntry *best_match = 0;
+        const Utils::RouteEntry* best_match = 0;
         entries_type entries;
         uint32_t ip_int = ip;
         Utils::route_entries(std::back_inserter(entries));
-        for(entries_type::const_iterator it(entries.begin()); it != entries.end(); ++it) {
-            if((ip_int & it->mask) == it->destination) {
-                if(!best_match || it->mask > best_match->mask || it->metric < best_match->metric) {
+        for (entries_type::const_iterator it(entries.begin()); it != entries.end(); ++it) {
+            if ((ip_int & it->mask) == it->destination) {
+                if (!best_match || it->mask > best_match->mask || it->metric < best_match->metric) {
                     best_match = &*it;
                 }
             }
         }
-        if(!best_match)
-            throw std::runtime_error("Error looking up interface");
-        iface_id = resolve_index(best_match->interface.c_str());
+        if (!best_match) {
+            throw invalid_interface();
+        }
+        iface_id_ = resolve_index(best_match->interface.c_str());
     }
 }
 
-std::string NetworkInterface::name() const {
+string NetworkInterface::name() const {
     #ifndef WIN32
     char iface_name[IF_NAMESIZE];
-    if(!if_indextoname(iface_id, iface_name))
-        throw std::runtime_error("Error fetching this interface's name");
+    if (!if_indextoname(iface_id_, iface_name)) {
+        throw invalid_interface();
+    }
     return iface_name;
     #else // WIN32
     ULONG size;
     ::GetAdaptersAddresses(AF_INET, 0, 0, 0, &size);
-    std::vector<uint8_t> buffer(size);
+    vector<uint8_t> buffer(size);
     if (::GetAdaptersAddresses(AF_INET, 0, 0, (IP_ADAPTER_ADDRESSES *)&buffer[0], &size) == ERROR_SUCCESS) {
         PIP_ADAPTER_ADDRESSES iface = (IP_ADAPTER_ADDRESSES *)&buffer[0];
         while (iface) {
-            if (iface->IfIndex == iface_id) {
+            if (iface->IfIndex == iface_id_) {
                 return iface->AdapterName;
             }
             iface = iface->Next;
         }
     }
-    throw std::runtime_error("Failed to find interface name");
+    throw invalid_interface();
     #endif // WIN32
 }
 
@@ -219,15 +231,15 @@ NetworkInterface::Info NetworkInterface::addresses() const {
 }
 
 NetworkInterface::Info NetworkInterface::info() const {
-    const std::string &iface_name = name();
+    const std::string& iface_name = name();
     Info info;
-    InterfaceInfoCollector collector(&info, iface_id, iface_name.c_str());
+    InterfaceInfoCollector collector(&info, iface_id_, iface_name.c_str());
     info.is_up = false;
     Utils::generic_iface_loop(collector);
     
      // If we didn't even get the hw address or ip address, this went wrong
-    if(!collector.found_hw && !collector.found_ip) {
-        throw std::runtime_error("Error looking up interface address");
+    if (!collector.found_hw && !collector.found_ip) {
+        throw invalid_interface();
     }
 
     return info;
@@ -241,16 +253,17 @@ bool NetworkInterface::is_up() const {
     return addresses().is_up;
 }
 
-NetworkInterface::id_type NetworkInterface::resolve_index(const char *name) {
+NetworkInterface::id_type NetworkInterface::resolve_index(const char* name) {
     #ifndef WIN32
     id_type id = if_nametoindex(name);
-    if(!id)
-        throw std::runtime_error("Invalid interface");
+    if (!id) {
+        throw invalid_interface();
+    }
     return id;
     #else // Win32
     ULONG size;
     ::GetAdaptersAddresses(AF_INET, 0, 0, 0, &size);
-    std::vector<uint8_t> buffer(size);
+    vector<uint8_t> buffer(size);
     if (::GetAdaptersAddresses(AF_INET, 0, 0, (IP_ADAPTER_ADDRESSES *)&buffer[0], &size) == ERROR_SUCCESS) {
         PIP_ADAPTER_ADDRESSES iface = (IP_ADAPTER_ADDRESSES *)&buffer[0];
         while (iface) {
@@ -260,8 +273,8 @@ NetworkInterface::id_type NetworkInterface::resolve_index(const char *name) {
             iface = iface->Next;
         }
     }
-    throw std::runtime_error("Invalid interface");
+    throw invalid_interface();
     #endif // Win32
 }
-}
 
+} // Tins
diff --git a/src/offline_packet_filter.cpp b/src/offline_packet_filter.cpp
index 3681d54..983fdd2 100644
--- a/src/offline_packet_filter.cpp
+++ b/src/offline_packet_filter.cpp
@@ -30,51 +30,47 @@
 #include <stdexcept>
 #include "offline_packet_filter.h"
 #include "pdu.h"
+#include "exceptions.h"
+
+using std::string;
 
 namespace Tins {
 
-OfflinePacketFilter::OfflinePacketFilter(const OfflinePacketFilter& other)
-{
+OfflinePacketFilter::OfflinePacketFilter(const OfflinePacketFilter& other) {
     *this = other;
 }
 
-OfflinePacketFilter& OfflinePacketFilter::operator=(const OfflinePacketFilter& other)
-{
-    string_filter = other.string_filter;
-    init(string_filter, pcap_datalink(other.handle), pcap_snapshot(other.handle));
-    return *this;
+OfflinePacketFilter& OfflinePacketFilter::operator=(const OfflinePacketFilter& other) {
+    string_filter_ = other.string_filter_;
+    init(string_filter_, pcap_datalink(other.handle_), pcap_snapshot(other.handle_));
+    return* this;
 }
 
-OfflinePacketFilter::~OfflinePacketFilter()
-{
-    pcap_freecode(&filter);
-    pcap_close(handle);
+OfflinePacketFilter::~OfflinePacketFilter() {
+    pcap_freecode(&filter_);
+    pcap_close(handle_);
 }
 
-void OfflinePacketFilter::init(const std::string& pcap_filter, int link_type, 
-    unsigned int snap_len) 
-{
-    handle = pcap_open_dead(
+void OfflinePacketFilter::init(const string& pcap_filter, 
+                               int link_type, 
+                               unsigned int snap_len) {
+    handle_ = pcap_open_dead(
         link_type,
         snap_len
     );
-    if(pcap_compile(handle, &filter, pcap_filter.c_str(), 1, 0xffffffff) == -1)
-    {
-        throw std::runtime_error(pcap_geterr(handle));
+    if (pcap_compile(handle_, &filter_, pcap_filter.c_str(), 1, 0xffffffff) == -1) {
+        throw invalid_pcap_filter(pcap_geterr(handle_));
     }
 }
 
-bool OfflinePacketFilter::matches_filter(const uint8_t* buffer, 
-    uint32_t total_sz) const
-{
+bool OfflinePacketFilter::matches_filter(const uint8_t* buffer, uint32_t total_sz) const {
     pcap_pkthdr header = {};
     header.len = total_sz;
     header.caplen = total_sz;
-    return pcap_offline_filter(&filter, &header, buffer) != 0;
+    return pcap_offline_filter(&filter_, &header, buffer) != 0;
 }
 
-bool OfflinePacketFilter::matches_filter(PDU& pdu) const
-{
+bool OfflinePacketFilter::matches_filter(PDU& pdu) const {
     PDU::serialization_type buffer = pdu.serialize();
     return matches_filter(&buffer[0], static_cast<uint32_t>(buffer.size()));
 }
diff --git a/src/packet_sender.cpp b/src/packet_sender.cpp
index c1f53af..63fc439 100644
--- a/src/packet_sender.cpp
+++ b/src/packet_sender.cpp
@@ -67,73 +67,82 @@
 #include "internals.h"
 
 using std::string;
+using std::ostringstream;
+using std::max;
+using std::make_pair;
+using std::vector;
 using std::runtime_error;
 
 namespace Tins {
+
 const int PacketSender::INVALID_RAW_SOCKET = -1;
 const uint32_t PacketSender::DEFAULT_TIMEOUT = 2;
 
 #ifndef _WIN32
     typedef int socket_type;
     
-    const char *make_error_string() {
+    const char* make_error_string() {
         return strerror(errno);
     }
 #else
     typedef SOCKET socket_type;
 
     // fixme
-    const char *make_error_string() {
+    const char* make_error_string() {
         return "error";
     }
 #endif
 
-PacketSender::PacketSender(const NetworkInterface &iface, uint32_t recv_timeout, 
-  uint32_t usec) 
-: _sockets(SOCKETS_END, INVALID_RAW_SOCKET), 
+PacketSender::PacketSender(const NetworkInterface& iface, 
+                           uint32_t recv_timeout, 
+                           uint32_t usec) 
+: sockets_(SOCKETS_END, INVALID_RAW_SOCKET), 
 #if !defined(BSD) && !defined(_WIN32) && !defined(__FreeBSD_kernel__)
-  _ether_socket(INVALID_RAW_SOCKET),
+  ether_socket_(INVALID_RAW_SOCKET),
 #endif
-  _timeout(recv_timeout), _timeout_usec(usec), default_iface(iface)
-{
-    _types[IP_TCP_SOCKET] = IPPROTO_TCP;
-    _types[IP_UDP_SOCKET] = IPPROTO_UDP;
-    _types[IP_RAW_SOCKET] = IPPROTO_RAW;
-    _types[IPV6_SOCKET] = IPPROTO_RAW;
-    _types[ICMP_SOCKET] = IPPROTO_ICMP;
+  _timeout(recv_timeout), timeout_usec_(usec), default_iface_(iface) {
+    types_[IP_TCP_SOCKET] = IPPROTO_TCP;
+    types_[IP_UDP_SOCKET] = IPPROTO_UDP;
+    types_[IP_RAW_SOCKET] = IPPROTO_RAW;
+    types_[IPV6_SOCKET] = IPPROTO_RAW;
+    types_[ICMP_SOCKET] = IPPROTO_ICMP;
 }
 
 PacketSender::~PacketSender() {
-    for(unsigned i(0); i < _sockets.size(); ++i) {
-        if(_sockets[i] != INVALID_RAW_SOCKET) 
-        #ifndef _WIN32
-            ::close(_sockets[i]);
-        #else
-            ::closesocket(_sockets[i]);
-        #endif
+    for (unsigned i(0); i < sockets_.size(); ++i) {
+        if (sockets_[i] != INVALID_RAW_SOCKET)  {
+            #ifndef _WIN32
+                ::close(sockets_[i]);
+            #else
+                ::closesocket(sockets_[i]);
+            #endif
+        }
     }
     #if defined(BSD) || defined(__FreeBSD_kernel__)
-        for(BSDEtherSockets::iterator it = _ether_socket.begin(); it != _ether_socket.end(); ++it)
+        for (BSDEtherSockets::iterator it = ether_socket_.begin(); 
+             it != ether_socket_.end(); ++it) {
             ::close(it->second);
+        }
     #elif !defined(_WIN32)
-        if(_ether_socket != INVALID_RAW_SOCKET)
-            ::close(_ether_socket);
+        if (ether_socket_ != INVALID_RAW_SOCKET) {
+            ::close(ether_socket_);
+        }
     #endif
 
     #ifdef HAVE_PACKET_SENDER_PCAP_SENDPACKET
-        for (PcapHandleMap::iterator it = pcap_handles.begin(); it != pcap_handles.end(); ++it) {
+        for (PcapHandleMap::iterator it = pcap_handles_.begin(); it != pcap_handles_.end(); ++it) {
             pcap_close(it->second);
         }
-        pcap_handles.clear();
+        pcap_handles_.clear();
     #endif // HAVE_PACKET_SENDER_PCAP_SENDPACKET
 }
 
-void PacketSender::default_interface(const NetworkInterface &iface) {
-    default_iface = iface;
+void PacketSender::default_interface(const NetworkInterface& iface) {
+    default_iface_ = iface;
 }
 
 const NetworkInterface& PacketSender::default_interface() const {
-    return default_iface;
+    return default_iface_;
 }
 
 #if !defined(_WIN32) || defined(HAVE_PACKET_SENDER_PCAP_SENDPACKET)
@@ -141,19 +150,20 @@ const NetworkInterface& PacketSender::default_interface() const {
 #ifndef _WIN32
 bool PacketSender::ether_socket_initialized(const NetworkInterface& iface) const {
     #if defined(BSD) || defined(__FreeBSD_kernel__)
-    return _ether_socket.count(iface.id());
+    return ether_socket_.count(iface.id());
     #else
-    return _ether_socket != INVALID_RAW_SOCKET;
+    return ether_socket_ != INVALID_RAW_SOCKET;
     #endif
 }
 
-int PacketSender::get_ether_socket(const NetworkInterface& iface) {
-    if(!ether_socket_initialized(iface))
+int PacketSender::getether_socket_(const NetworkInterface& iface) {
+    if (!ether_socket_initialized(iface)) {
         open_l2_socket(iface);
+    }
     #if defined(BSD) || defined(__FreeBSD_kernel__)
-    return _ether_socket[iface.id()];
+    return ether_socket_[iface.id()];
     #else
-    return _ether_socket;
+    return ether_socket_;
     #endif
 }
 #endif // _WIN32
@@ -161,6 +171,8 @@ int PacketSender::get_ether_socket(const NetworkInterface& iface) {
 #ifdef HAVE_PACKET_SENDER_PCAP_SENDPACKET
 
 pcap_t* PacketSender::make_pcap_handle(const NetworkInterface& iface) const {
+    // This is an ugly fix to make interface names look like what 
+    // libpcap expects on Windows
     #ifdef _WIN32
         #define TINS_PREFIX_INTERFACE(x) ("\\Device\\NPF_" + x)
     #else // _WIN32
@@ -185,41 +197,45 @@ pcap_t* PacketSender::make_pcap_handle(const NetworkInterface& iface) const {
 
 void PacketSender::open_l2_socket(const NetworkInterface& iface) {
     #ifdef HAVE_PACKET_SENDER_PCAP_SENDPACKET
-        if (pcap_handles.count(iface) == 0) {
-            pcap_handles.insert(std::make_pair(iface, make_pcap_handle(iface)));
+        if (pcap_handles_.count(iface) == 0) {
+            pcap_handles_.insert(make_pair(iface, make_pcap_handle(iface)));
         }
     #elif defined(BSD) || defined(__FreeBSD_kernel__)
         int sock = -1;
         // At some point, there should be an available device
         for (int i = 0; sock == -1;i++) {
-            std::ostringstream oss;
+            ostringstream oss;
             oss << "/dev/bpf" << i;
 
             sock = open(oss.str().c_str(), O_RDWR);
         }
-        if(sock == -1) 
+        if (sock == -1) {
             throw socket_open_error(make_error_string());
+        }
         
         struct ifreq ifr;
         strncpy(ifr.ifr_name, iface.name().c_str(), sizeof(ifr.ifr_name) - 1);
-        if(ioctl(sock, BIOCSETIF, (caddr_t)&ifr) < 0) {
+        if (ioctl(sock, BIOCSETIF, (caddr_t)&ifr) < 0) {
             ::close(sock);
             throw socket_open_error(make_error_string());
         }
         // Use immediate mode
         u_int value = 1;
-        if(ioctl(sock, BIOCIMMEDIATE, &value) < 0)
+        if (ioctl(sock, BIOCIMMEDIATE, &value) < 0) {
             throw socket_open_error(make_error_string());
+        }
         // Get the buffer size
-        if(ioctl(sock, BIOCGBLEN, &buffer_size) < 0)
+        if (ioctl(sock, BIOCGBLEN, &buffer_size_) < 0) {
             throw socket_open_error(make_error_string());
-        _ether_socket[iface.id()] = sock;
+        }
+        ether_socket_[iface.id()] = sock;
     #else
-    if (_ether_socket == INVALID_RAW_SOCKET) {
-        _ether_socket = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
+    if (ether_socket_ == INVALID_RAW_SOCKET) {
+        ether_socket_ = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
         
-        if (_ether_socket == -1)
+        if (ether_socket_ == -1) {
             throw socket_open_error(make_error_string());
+        }
     }
     #endif
 }
@@ -227,13 +243,15 @@ void PacketSender::open_l2_socket(const NetworkInterface& iface) {
 
 void PacketSender::open_l3_socket(SocketType type) {
     int socktype = find_type(type);
-    if(socktype == -1)
+    if (socktype == -1) {
         throw invalid_socket_type();
-    if(_sockets[type] == INVALID_RAW_SOCKET) {
+    }
+    if (sockets_[type] == INVALID_RAW_SOCKET) {
         socket_type sockfd;
         sockfd = socket((type == IPV6_SOCKET) ? AF_INET6 : AF_INET, SOCK_RAW, socktype);
-        if (sockfd < 0)
+        if (sockfd < 0) {
             throw socket_open_error(make_error_string());
+        }
 
         const int on = 1;
         #ifndef _WIN32
@@ -243,93 +261,109 @@ void PacketSender::open_l3_socket(SocketType type) {
         #endif
         setsockopt(sockfd, IPPROTO_IP, IP_HDRINCL,(option_ptr)&on,sizeof(on));
 
-        _sockets[type] = static_cast<int>(sockfd);
+        sockets_[type] = static_cast<int>(sockfd);
     }
 }
 
-void PacketSender::close_socket(SocketType type, const NetworkInterface &iface) {
-    if(type == ETHER_SOCKET) {
+void PacketSender::close_socket(SocketType type, const NetworkInterface& iface) {
+    if (type == ETHER_SOCKET) {
         #if defined(BSD) || defined(__FreeBSD_kernel__)
-        BSDEtherSockets::iterator it = _ether_socket.find(iface.id());
-        if(it == _ether_socket.end())
+        BSDEtherSockets::iterator it = ether_socket_.find(iface.id());
+        if (it == ether_socket_.end()) {
             throw invalid_socket_type();
-        if(::close(it->second) == -1)
+        }
+        if (::close(it->second) == -1) {
             throw socket_close_error(make_error_string());
-        _ether_socket.erase(it);
+        }
+        ether_socket_.erase(it);
         #elif !defined(_WIN32)
-        if(_ether_socket == INVALID_RAW_SOCKET)
+        if (ether_socket_ == INVALID_RAW_SOCKET) {
             throw invalid_socket_type();
-        if(::close(_ether_socket) == -1)
+        }
+        if (::close(ether_socket_) == -1) {
             throw socket_close_error(make_error_string());
-        _ether_socket = INVALID_RAW_SOCKET;
+        }
+        ether_socket_ = INVALID_RAW_SOCKET;
         #endif
     }
     else {
-        if(type >= SOCKETS_END || _sockets[type] == INVALID_RAW_SOCKET)
+        if (type >= SOCKETS_END || sockets_[type] == INVALID_RAW_SOCKET) {
             throw invalid_socket_type();
+        }
         #ifndef _WIN32
-        if(close(_sockets[type]) == -1)
+        if (close(sockets_[type]) == -1) {
             throw socket_close_error(make_error_string());
+        }
         #else
-        closesocket(_sockets[type]);
+        closesocket(sockets_[type]);
         #endif
-        _sockets[type] = INVALID_RAW_SOCKET;
+        sockets_[type] = INVALID_RAW_SOCKET;
     }
 }
 
-void PacketSender::send(PDU &pdu) {
-    pdu.send(*this, default_iface);
+void PacketSender::send(PDU& pdu) {
+    pdu.send(*this, default_iface_);
 }
 
-void PacketSender::send(PDU &pdu, const NetworkInterface &iface) {
-    if (pdu.matches_flag(PDU::ETHERNET_II))
+void PacketSender::send(PDU& pdu, const NetworkInterface& iface) {
+    if (pdu.matches_flag(PDU::ETHERNET_II)) {
         send<Tins::EthernetII>(pdu, iface);
+    }
     #ifdef HAVE_DOT11
-        else if (pdu.matches_flag(PDU::DOT11))
+        else if (pdu.matches_flag(PDU::DOT11)) {
             send<Tins::Dot11>(pdu, iface);
-        else if (pdu.matches_flag(PDU::RADIOTAP))
+        }
+        else if (pdu.matches_flag(PDU::RADIOTAP)) {
             send<Tins::RadioTap>(pdu, iface);
+        }
     #endif // HAVE_DOT11
-    else if (pdu.matches_flag(PDU::IEEE802_3))
+    else if (pdu.matches_flag(PDU::IEEE802_3)) {
         send<Tins::IEEE802_3>(pdu, iface);
-    else send(pdu);
+    }
+    else {
+        send(pdu);
+    }
 }
 
-PDU *PacketSender::send_recv(PDU &pdu) {
-    return send_recv(pdu, default_iface);
+PDU* PacketSender::send_recv(PDU& pdu) {
+    return send_recv(pdu, default_iface_);
 }
 
-PDU *PacketSender::send_recv(PDU &pdu, const NetworkInterface &iface) {
+PDU* PacketSender::send_recv(PDU& pdu, const NetworkInterface& iface) {
     try {
         pdu.send(*this, iface);
     }
-    catch(runtime_error&) {
+    catch (runtime_error&) {
         return 0;
     }
     return pdu.recv_response(*this, iface);
 }
 
 #if !defined(_WIN32) || defined(HAVE_PACKET_SENDER_PCAP_SENDPACKET)
-void PacketSender::send_l2(PDU &pdu, struct sockaddr* link_addr, 
-  uint32_t len_addr, const NetworkInterface &iface) 
-{
+void PacketSender::send_l2(PDU& pdu,
+                           struct sockaddr* link_addr, 
+                           uint32_t len_addr,
+                           const NetworkInterface& iface) {
     PDU::serialization_type buffer = pdu.serialize();
 
     #ifdef HAVE_PACKET_SENDER_PCAP_SENDPACKET
         open_l2_socket(iface);
-        pcap_t* handle = pcap_handles[iface];
-        if (pcap_sendpacket(handle, (u_char*)&buffer[0], static_cast<int>(buffer.size())) != 0) {
-            throw runtime_error("Failed to send packet: " + string(pcap_geterr(handle)));
+        pcap_t* handle = pcap_handles_[iface];
+        const int buf_size = static_cast<int>(buffer.size());
+        if (pcap_sendpacket(handle, (u_char*)&buffer[0], buf_size) != 0) {
+            throw runtime_error("Failed to send packet: " + 
+                                string(pcap_geterr(handle)));
         }
     #else // HAVE_PACKET_SENDER_PCAP_SENDPACKET
-        int sock = get_ether_socket(iface);
-        if(!buffer.empty()) {
+        int sock = getether_socket_(iface);
+        if (!buffer.empty()) {
             #if defined(BSD) || defined(__FreeBSD_kernel__)
-            if(::write(sock, &buffer[0], buffer.size()) == -1)
+            if (::write(sock, &buffer[0], buffer.size()) == -1) {
             #else
-            if(::sendto(sock, &buffer[0], buffer.size(), 0, link_addr, len_addr) == -1)
+            if (::sendto(sock, &buffer[0], buffer.size(), 0, link_addr, len_addr) == -1) {
             #endif
                 throw socket_write_error(make_error_string());
+            }
         }
     #endif // HAVE_PACKET_SENDER_PCAP_SENDPACKET
 }
@@ -337,37 +371,49 @@ void PacketSender::send_l2(PDU &pdu, struct sockaddr* link_addr,
 #endif // !_WIN32 || HAVE_PACKET_SENDER_PCAP_SENDPACKET
 
 #ifndef _WIN32
-PDU *PacketSender::recv_l2(PDU &pdu, struct sockaddr *link_addr, 
-  uint32_t len_addr, const NetworkInterface &iface) 
-{
-    int sock = get_ether_socket(iface);
-    std::vector<int> sockets(1, sock);
+PDU* PacketSender::recv_l2(PDU& pdu, 
+                           struct sockaddr* link_addr, 
+                           uint32_t len_addr,
+                           const NetworkInterface& iface) {
+    int sock = getether_socket_(iface);
+    vector<int> sockets(1, sock);
     return recv_match_loop(sockets, pdu, link_addr, len_addr);
 }
 #endif // _WIN32
 
-PDU *PacketSender::recv_l3(PDU &pdu, struct sockaddr* link_addr, uint32_t len_addr, SocketType type) {
+PDU* PacketSender::recv_l3(PDU& pdu, 
+                           struct sockaddr* link_addr,
+                           uint32_t len_addr,
+                           SocketType type) {
     open_l3_socket(type);
-    std::vector<int> sockets(1, _sockets[type]);
-    if(type == IP_TCP_SOCKET || type == IP_UDP_SOCKET) {
+    vector<int> sockets(1, sockets_[type]);
+    if (type == IP_TCP_SOCKET || type == IP_UDP_SOCKET) {
         #ifdef BSD
             throw runtime_error("Receiving L3 packets not supported on this platform");
         #endif
         open_l3_socket(ICMP_SOCKET);
-        sockets.push_back(_sockets[ICMP_SOCKET]);
+        sockets.push_back(sockets_[ICMP_SOCKET]);
     }
     return recv_match_loop(sockets, pdu, link_addr, len_addr);
 }
 
-void PacketSender::send_l3(PDU &pdu, struct sockaddr* link_addr, uint32_t len_addr, SocketType type) {
+void PacketSender::send_l3(PDU& pdu, 
+                           struct sockaddr* link_addr,
+                           uint32_t len_addr,
+                           SocketType type) {
     open_l3_socket(type);
-    int sock = _sockets[type];
+    int sock = sockets_[type];
     PDU::serialization_type buffer = pdu.serialize();
-    if(sendto(sock, (const char*)&buffer[0], static_cast<int>(buffer.size()), 0, link_addr, len_addr) == -1)
+    const int buf_size = static_cast<int>(buffer.size());
+    if (sendto(sock, (const char*)&buffer[0], buf_size, 0, link_addr, len_addr) == -1) {
         throw socket_write_error(make_error_string());
+    }
 }
 
-PDU *PacketSender::recv_match_loop(const std::vector<int>& sockets, PDU &pdu, struct sockaddr* link_addr, uint32_t addrlen) {
+PDU* PacketSender::recv_match_loop(const vector<int>& sockets, 
+                                   PDU& pdu,
+                                   struct sockaddr* link_addr,
+                                   uint32_t addrlen) {
     #ifdef _WIN32
         typedef int socket_len_type;
         typedef int recvfrom_ret_type;
@@ -379,9 +425,9 @@ PDU *PacketSender::recv_match_loop(const std::vector<int>& sockets, PDU &pdu, st
     struct timeval timeout,  end_time;
     int read;
     #if defined(BSD) || defined(__FreeBSD_kernel__)
-        // On *BSD, we need to allocate a buffer using the given size.
-        std::vector<uint8_t> actual_buffer(buffer_size);
-        uint8_t *buffer = &actual_buffer[0];
+        // On* BSD, we need to allocate a buffer using the given size.
+        vector<uint8_t> actual_buffer(buffer_size_);
+        uint8_t* buffer = &actual_buffer[0];
     #else
         uint8_t buffer[2048];
         const int buffer_size = 2048;
@@ -389,28 +435,29 @@ PDU *PacketSender::recv_match_loop(const std::vector<int>& sockets, PDU &pdu, st
     
     timeout.tv_sec  = _timeout;
     end_time.tv_sec = static_cast<long>(time(0) + _timeout);
-    end_time.tv_usec = timeout.tv_usec = _timeout_usec;
-    while(true) {
+    end_time.tv_usec = timeout.tv_usec = timeout_usec_;
+    while (true) {
         FD_ZERO(&readfds);
         int max_fd = 0;
-        for(std::vector<int>::const_iterator it = sockets.begin(); it != sockets.end(); ++it) {
+        for (vector<int>::const_iterator it = sockets.begin(); it != sockets.end(); ++it) {
             FD_SET(*it, &readfds);
-            max_fd = std::max(max_fd, *it);
+            max_fd = max(max_fd, *it);
         }
-        if((read = select(max_fd + 1, &readfds, 0, 0, &timeout)) == -1)
+        if ((read = select(max_fd + 1, &readfds, 0, 0, &timeout)) == -1) {
             return 0;
-        if(read > 0) {
-            for(std::vector<int>::const_iterator it = sockets.begin(); it != sockets.end(); ++it) {
-                if(FD_ISSET(*it, &readfds)) {
+        }
+        if (read > 0) {
+            for (vector<int>::const_iterator it = sockets.begin(); it != sockets.end(); ++it) {
+                if (FD_ISSET(*it, &readfds)) {
                     recvfrom_ret_type size;
                     #if defined(BSD) || defined(__FreeBSD_kernel__)
-                        size = ::read(*it, buffer, buffer_size);
+                        size = ::read(*it, buffer, buffer_size_);
                         const uint8_t* ptr = buffer;
                         // We might see more than one packet
-                        while(ptr < (buffer + size)) {
+                        while (ptr < (buffer + size)) {
                             const bpf_hdr* bpf_header = reinterpret_cast<const bpf_hdr*>(ptr);
-                            const uint8_t *pkt_start = ptr + bpf_header->bh_hdrlen;
-                            if(pdu.matches_response(pkt_start, bpf_header->bh_caplen)) {
+                            const uint8_t* pkt_start = ptr + bpf_header->bh_hdrlen;
+                            if (pdu.matches_response(pkt_start, bpf_header->bh_caplen)) {
                                 return Internals::pdu_from_flag(pdu.pdu_type(), pkt_start, bpf_header->bh_caplen);
                             }
                             ptr += BPF_WORDALIGN(bpf_header->bh_hdrlen + bpf_header->bh_caplen);
@@ -418,7 +465,7 @@ PDU *PacketSender::recv_match_loop(const std::vector<int>& sockets, PDU &pdu, st
                     #else
                         socket_len_type length = addrlen;
                         size = ::recvfrom(*it, (char*)buffer, buffer_size, 0, link_addr, &length);
-                        if(pdu.matches_response(buffer, size)) {
+                        if (pdu.matches_response(buffer, size)) {
                             return Internals::pdu_from_flag(pdu.pdu_type(), buffer, size);
                         }
                     #endif
@@ -431,15 +478,16 @@ PDU *PacketSender::recv_match_loop(const std::vector<int>& sockets, PDU &pdu, st
         #else
             gettimeofday(&this_time, 0);
         #endif // _WIN32
-        if(timeval_subtract(&diff, &end_time, &this_time))
+        if (timeval_subtract(&diff, &end_time, &this_time)) {
             return 0;
+        }
         timeout.tv_sec = diff.tv_sec;
         timeout.tv_usec = diff.tv_usec;
     }
     return 0;
 }
 
-int PacketSender::timeval_subtract (struct timeval *result, struct timeval *x, struct timeval *y) {
+int PacketSender::timeval_subtract (struct timeval* result, struct timeval* x, struct timeval* y) {
     /* Perform the carry for the later subtraction by updating y. */
     if (x->tv_usec < y->tv_usec) {
         int nsec = (y->tv_usec - x->tv_usec) / 1000000 + 1;
@@ -463,10 +511,13 @@ int PacketSender::timeval_subtract (struct timeval *result, struct timeval *x, s
 }
 
 int PacketSender::find_type(SocketType type) {
-    SocketTypeMap::iterator it = _types.find(type);
-    if(it == _types.end())
+    SocketTypeMap::iterator it = types_.find(type);
+    if (it == types_.end()) {
         return -1;
-    else
+    }
+    else {
         return it->second;
+    }
 }
-}
+
+} // Tins
diff --git a/src/packet_writer.cpp b/src/packet_writer.cpp
index d8ac055..b5f2002 100644
--- a/src/packet_writer.cpp
+++ b/src/packet_writer.cpp
@@ -34,20 +34,24 @@
 #include "packet_writer.h"
 #include "packet.h"
 #include "pdu.h"
+#include "exceptions.h"
+
+using std::string;
 
 namespace Tins {
-PacketWriter::PacketWriter(const std::string &file_name, LinkType lt) {
+
+PacketWriter::PacketWriter(const string& file_name, LinkType lt) {
     init(file_name, lt);
 }
 
 PacketWriter::~PacketWriter() {
-    if(dumper && handle) {
-        pcap_dump_close(dumper);
-        pcap_close(handle);
+    if (dumper_ && handle_) {
+        pcap_dump_close(dumper_);
+        pcap_close(handle_);
     }
 }
 
-void PacketWriter::write(PDU &pdu) {
+void PacketWriter::write(PDU& pdu) {
     timeval tv;
     #ifndef _WIN32
         gettimeofday(&tv, 0);
@@ -58,7 +62,7 @@ void PacketWriter::write(PDU &pdu) {
     write(pdu, tv);
 }
 
-void PacketWriter::write(Packet &packet) {
+void PacketWriter::write(Packet& packet) {
     timeval tv;
     tv.tv_sec = packet.timestamp().seconds();
     tv.tv_usec = packet.timestamp().microseconds();
@@ -72,19 +76,19 @@ void PacketWriter::write(PDU& pdu, const struct timeval& tv) {
         static_cast<bpf_u_int32>(buffer.size()),
         static_cast<bpf_u_int32>(buffer.size())
     };
-    pcap_dump((u_char*)dumper, &header, &buffer[0]);
+    pcap_dump((u_char*)dumper_, &header, &buffer[0]);
 }
 
-void PacketWriter::init(const std::string& file_name, int link_type) {
-    handle = pcap_open_dead(link_type, 65535);
-    if(!handle)
-        throw std::runtime_error("Error creating pcap handle");
-    dumper = pcap_dump_open(handle, file_name.c_str());
-    if(!dumper) {
-        // RAII plx
-        pcap_close(handle);
-        throw std::runtime_error(pcap_geterr(handle));
+void PacketWriter::init(const string& file_name, int link_type) {
+    handle_ = pcap_open_dead(link_type, 65535);
+    if (!handle_) {
+        throw pcap_open_failed();
+    }
+    dumper_ = pcap_dump_open(handle_, file_name.c_str());
+    if (!dumper_) {
+        pcap_close(handle_);
+        throw pcap_error(pcap_geterr(handle_));
     }
 }
 
-}
+} // Tins
diff --git a/src/pdu.cpp b/src/pdu.cpp
index a947181..f2d21a6 100644
--- a/src/pdu.cpp
+++ b/src/pdu.cpp
@@ -31,36 +31,40 @@
 #include "rawpdu.h"
 #include "packet_sender.h"
 
+using std::swap;
+using std::vector;
+
 namespace Tins {
 
 PDU::PDU()
-: _inner_pdu()
-{
+: inner_pdu_() {
 
 }
 
-PDU::PDU(const PDU &other) : _inner_pdu(0) {
+PDU::PDU(const PDU& other) 
+: inner_pdu_(0) {
     copy_inner_pdu(other);
 }
 
-PDU &PDU::operator=(const PDU &other) {
+PDU& PDU::operator=(const PDU& other) {
     copy_inner_pdu(other);
-    return *this;
+    return* this;
 }
 
 PDU::~PDU() {
-    delete _inner_pdu;
+    delete inner_pdu_;
 }
 
-void PDU::copy_inner_pdu(const PDU &pdu) {
-    if(pdu.inner_pdu())
+void PDU::copy_inner_pdu(const PDU& pdu) {
+    if (pdu.inner_pdu()) {
         inner_pdu(pdu.inner_pdu()->clone());
+    }
 }
 
 uint32_t PDU::size() const {
     uint32_t sz = header_size() + trailer_size();
-    const PDU *ptr(_inner_pdu);
-    while(ptr) {
+    const PDU* ptr(inner_pdu_);
+    while (ptr) {
         sz += ptr->header_size() + ptr->trailer_size();
         ptr = ptr->inner_pdu();
     }
@@ -71,42 +75,42 @@ void PDU::send(PacketSender &, const NetworkInterface &) {
     
 }
 
-PDU *PDU::recv_response(PacketSender &, const NetworkInterface &) { 
+PDU* PDU::recv_response(PacketSender &, const NetworkInterface &) { 
     return 0; 
 }
 
-void PDU::inner_pdu(PDU *next_pdu) {
-    delete _inner_pdu;
-    _inner_pdu = next_pdu;
+void PDU::inner_pdu(PDU* next_pdu) {
+    delete inner_pdu_;
+    inner_pdu_ = next_pdu;
 }
 
-void PDU::inner_pdu(const PDU &next_pdu) {
+void PDU::inner_pdu(const PDU& next_pdu) {
     inner_pdu(next_pdu.clone());
 }
 
-PDU *PDU::release_inner_pdu() {
-    PDU *result = 0;
-    std::swap(result, _inner_pdu);
+PDU* PDU::release_inner_pdu() {
+    PDU* result = 0;
+    swap(result, inner_pdu_);
     return result;
 }
 
 PDU::serialization_type PDU::serialize() {
-    std::vector<uint8_t> buffer(size());
+    vector<uint8_t> buffer(size());
     serialize(&buffer[0], static_cast<uint32_t>(buffer.size()), 0);
-    
-    // Copy elision, do your magic
     return buffer;
 }
 
-void PDU::serialize(uint8_t *buffer, uint32_t total_sz, const PDU *parent) {
+void PDU::serialize(uint8_t* buffer, uint32_t total_sz, const PDU* parent) {
     uint32_t sz = header_size() + trailer_size();
-    /* Must not happen... */
+    // Must not happen...
     #ifdef TINS_DEBUG
     assert(total_sz >= sz);
     #endif
     prepare_for_serialize(parent);
-    if(_inner_pdu)
-        _inner_pdu->serialize(buffer + header_size(), total_sz - sz, this);
+    if (inner_pdu_) {
+        inner_pdu_->serialize(buffer + header_size(), total_sz - sz, this);
+    }
     write_serialization(buffer, total_sz, parent);
 }
-}
+
+} // Tins
diff --git a/src/pktap.cpp b/src/pktap.cpp
index bc9d7cb..0d0ab39 100644
--- a/src/pktap.cpp
+++ b/src/pktap.cpp
@@ -32,6 +32,7 @@
 #include "exceptions.h"
 #include "pktap.h"
 #include "internals.h"
+#include "exceptions.h"
 #include "memory_helpers.h"
 
 using Tins::Memory::InputMemoryStream;
@@ -64,8 +65,8 @@ uint32_t PKTAP::header_size() const {
     return sizeof(header_);
 }
 
-void PKTAP::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent) {
-    throw std::runtime_error("PKTAP cannot be serialized");
+void PKTAP::write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent) {
+    throw pdu_not_serializable();
 }
 
 } // Tins
diff --git a/src/ppi.cpp b/src/ppi.cpp
index 1c0d503..e0bc766 100644
--- a/src/ppi.cpp
+++ b/src/ppi.cpp
@@ -45,17 +45,16 @@ using Tins::Memory::InputMemoryStream;
 
 namespace Tins {
 
-PPI::PPI(const uint8_t *buffer, uint32_t total_sz) {
+PPI::PPI(const uint8_t* buffer, uint32_t total_sz) {
     InputMemoryStream stream(buffer, total_sz);
-    stream.read(_header);
-    if (length() > total_sz || length() < sizeof(_header)) {
+    stream.read(header_);
+    if (length() > total_sz || length() < sizeof(header_)) {
         throw malformed_packet();
     }
     // There are some options
-    const size_t options_length = length() - sizeof(_header);
+    const size_t options_length = length() - sizeof(header_);
     if (options_length > 0) {
-        _data.assign(stream.pointer(), stream.pointer() + options_length);
-        stream.skip(options_length);
+        stream.read(data_, options_length);
     }
     if (stream) {
         switch (dlt()) {
@@ -67,10 +66,12 @@ PPI::PPI(const uint8_t *buffer, uint32_t total_sz) {
                 #endif
                 break;
             case DLT_EN10MB:
-                if(Internals::is_dot3(stream.pointer(), stream.size()))
+                if (Internals::is_dot3(stream.pointer(), stream.size())) {
                     inner_pdu(new Dot3(stream.pointer(), stream.size()));
-                else
+                }
+                else {
                     inner_pdu(new EthernetII(stream.pointer(), stream.size()));
+                }
                 break;
             case DLT_IEEE802_11_RADIO:
                 #ifdef HAVE_DOT11
@@ -90,18 +91,18 @@ PPI::PPI(const uint8_t *buffer, uint32_t total_sz) {
 }
 
 uint32_t PPI::header_size() const {
-    return static_cast<uint32_t>(sizeof(_header) + _data.size());
+    return static_cast<uint32_t>(sizeof(header_) + data_.size());
 }
 
-void PPI::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *) {
-    throw std::runtime_error("PPI serialization not supported");
+void PPI::write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU *) {
+    throw pdu_not_serializable();
 }
 
 void PPI::parse_80211(const uint8_t* buffer, uint32_t total_sz) {
     #ifdef HAVE_DOT11
-    if (_data.size() >= 13) {
+    if (data_.size() >= 13) {
         // Is FCS-at-end on?
-        if ((_data[12] & 1) == 1) {
+        if ((data_[12] & 1) == 1) {
             // We need to reduce the total size since we're skipping the FCS
             if (total_sz < sizeof(uint32_t)) {
                 throw malformed_packet();
diff --git a/src/pppoe.cpp b/src/pppoe.cpp
index b6d432b..bded6e1 100644
--- a/src/pppoe.cpp
+++ b/src/pppoe.cpp
@@ -33,23 +33,26 @@
 #include "exceptions.h"
 #include "memory_helpers.h"
 
+using std::string;
+using std::vector;
+using std::memcpy;
+using std::copy;
+
 using Tins::Memory::InputMemoryStream;
 using Tins::Memory::OutputMemoryStream;
 
 namespace Tins {
 
 PPPoE::PPPoE() 
-: _header(), _tags_size()
-{
+: header_(), tags_size_() {
     version(1);
     type(1);
 }
 
-PPPoE::PPPoE(const uint8_t *buffer, uint32_t total_sz) 
-: _tags_size()
-{
+PPPoE::PPPoE(const uint8_t* buffer, uint32_t total_sz) 
+: tags_size_() {
     InputMemoryStream stream(buffer, total_sz);
-    stream.read(_header); 
+    stream.read(header_); 
     stream.size(std::min(stream.size(), (uint32_t)payload_length()));
     // If this is a session data packet
     if (code() == 0) {
@@ -60,11 +63,10 @@ PPPoE::PPPoE(const uint8_t *buffer, uint32_t total_sz)
         }
     }
     else {
-        const uint8_t *end = stream.pointer() + stream.size();
-        while (stream.pointer() < end) {
+        while (stream) {
             TagTypes opt_type = static_cast<TagTypes>(stream.read<uint16_t>());
-            uint16_t opt_len = Endian::be_to_host(stream.read<uint16_t>());
-            if(!stream.can_read(opt_len)) {
+            uint16_t opt_len = stream.read_be<uint16_t>();
+            if (!stream.can_read(opt_len)) {
                 throw malformed_packet();
             }
             add_tag(tag(opt_type, opt_len, stream.pointer()));
@@ -73,55 +75,55 @@ PPPoE::PPPoE(const uint8_t *buffer, uint32_t total_sz)
     }
 }
 
-const PPPoE::tag *PPPoE::search_tag(TagTypes identifier) const {
-    for(tags_type::const_iterator it = _tags.begin(); it != _tags.end(); ++it) {
-        if(it->option() == identifier)
+const PPPoE::tag* PPPoE::search_tag(TagTypes identifier) const {
+    for (tags_type::const_iterator it = tags_.begin(); it != tags_.end(); ++it) {
+        if (it->option() == identifier) {
             return &*it;
+        }
     }
     return 0;
 }
 
 void PPPoE::version(small_uint<4> new_version) {
-    _header.version = new_version;
+    header_.version = new_version;
 }
 
 void PPPoE::type(small_uint<4> new_type) {
-    _header.type = new_type;
+    header_.type = new_type;
 }
 
 void PPPoE::code(uint8_t new_code) {
-    _header.code = new_code;
+    header_.code = new_code;
 }
 
 void PPPoE::session_id(uint16_t new_session_id) {
-    _header.session_id = Endian::host_to_be(new_session_id);
+    header_.session_id = Endian::host_to_be(new_session_id);
 }
 
 void PPPoE::payload_length(uint16_t new_payload_length) {
-    _header.payload_length = Endian::host_to_be(new_payload_length);
+    header_.payload_length = Endian::host_to_be(new_payload_length);
 }
 
 uint32_t PPPoE::header_size() const {
-    return sizeof(_header) + _tags_size;
+    return sizeof(header_) + tags_size_;
 }
 
-void PPPoE::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *) 
-{
+void PPPoE::write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU *) {
     OutputMemoryStream stream(buffer, total_sz);
-    if (_tags_size > 0) {
-        payload_length(_tags_size);
+    if (tags_size_ > 0) {
+        payload_length(tags_size_);
     }
-    stream.write(_header);
-    for(tags_type::const_iterator it = _tags.begin(); it != _tags.end(); ++it) {
+    stream.write(header_);
+    for (tags_type::const_iterator it = tags_.begin(); it != tags_.end(); ++it) {
         stream.write<uint16_t>(it->option());
         stream.write(Endian::host_to_be<uint16_t>(it->length_field()));
         stream.write(it->data_ptr(), it->data_size());
     }
 }
 
-void PPPoE::add_tag(const tag &option) {
-    _tags_size += static_cast<uint16_t>(option.data_size() + sizeof(uint16_t) * 2);
-    _tags.push_back(option);
+void PPPoE::add_tag(const tag& option) {
+    tags_size_ += static_cast<uint16_t>(option.data_size() + sizeof(uint16_t) * 2);
+    tags_.push_back(option);
 }
 
 // *********************** Setters *************************
@@ -132,27 +134,27 @@ void PPPoE::end_of_list() {
     );
 }
 
-void PPPoE::service_name(const std::string &value) {
+void PPPoE::service_name(const string& value) {
     add_tag_iterable(SERVICE_NAME, value);
 }
 
-void PPPoE::ac_name(const std::string &value) {
+void PPPoE::ac_name(const string& value) {
     add_tag_iterable(AC_NAME, value);
 }
 
-void PPPoE::host_uniq(const byte_array &value) {
+void PPPoE::host_uniq(const byte_array& value) {
     add_tag_iterable(HOST_UNIQ, value);
 }
 
-void PPPoE::ac_cookie(const byte_array &value) {
+void PPPoE::ac_cookie(const byte_array& value) {
     add_tag_iterable(AC_COOKIE, value);
 }
 
-void PPPoE::vendor_specific(const vendor_spec_type &value) {
-    std::vector<uint8_t> buffer(sizeof(uint32_t) + value.data.size());
+void PPPoE::vendor_specific(const vendor_spec_type& value) {
+    vector<uint8_t> buffer(sizeof(uint32_t) + value.data.size());
     uint32_t tmp_vendor_id = Endian::host_to_be(value.vendor_id);
-    std::memcpy(&buffer[0], &tmp_vendor_id, sizeof(uint32_t));
-    std::copy(
+    memcpy(&buffer[0], &tmp_vendor_id, sizeof(uint32_t));
+    copy(
         value.data.begin(), 
         value.data.end(), 
         buffer.begin() + sizeof(uint32_t)
@@ -166,29 +168,29 @@ void PPPoE::vendor_specific(const vendor_spec_type &value) {
     );
 }
 
-void PPPoE::relay_session_id(const byte_array &value) {
+void PPPoE::relay_session_id(const byte_array& value) {
     add_tag_iterable(RELAY_SESSION_ID, value);
 }
 
-void PPPoE::service_name_error(const std::string &value) {
+void PPPoE::service_name_error(const std::string& value) {
     add_tag_iterable(SERVICE_NAME_ERROR, value);
 }
 
-void PPPoE::ac_system_error(const std::string &value) {
+void PPPoE::ac_system_error(const std::string& value) {
     add_tag_iterable(AC_SYSTEM_ERROR, value);
 }
 
-void PPPoE::generic_error(const std::string &value) {
+void PPPoE::generic_error(const std::string& value) {
     add_tag_iterable(GENERIC_ERROR, value);
 }
 
 // *********************** Getters *************************
 
-std::string PPPoE::service_name() const {
+string PPPoE::service_name() const {
     return search_and_convert<std::string>(SERVICE_NAME);
 }
 
-std::string PPPoE::ac_name() const {
+string PPPoE::ac_name() const {
     return search_and_convert<std::string>(AC_NAME);
 }
 
@@ -201,9 +203,10 @@ byte_array PPPoE::ac_cookie() const {
 }
 
 PPPoE::vendor_spec_type PPPoE::vendor_specific() const {
-    const tag *t = search_tag(VENDOR_SPECIFIC);
-    if(!t)
+    const tag* t = search_tag(VENDOR_SPECIFIC);
+    if (!t) {
         throw option_not_found();
+    }
     return t->to<vendor_spec_type>();
 }
 
@@ -211,29 +214,27 @@ byte_array PPPoE::relay_session_id() const {
     return search_and_convert<byte_array>(RELAY_SESSION_ID);
 }
 
-std::string PPPoE::service_name_error() const {
-    return search_and_convert<std::string>(SERVICE_NAME_ERROR);
+string PPPoE::service_name_error() const {
+    return search_and_convert<string>(SERVICE_NAME_ERROR);
 }
 
-std::string PPPoE::ac_system_error() const {
-    return search_and_convert<std::string>(AC_SYSTEM_ERROR);
+string PPPoE::ac_system_error() const {
+    return search_and_convert<string>(AC_SYSTEM_ERROR);
 }
 
-std::string PPPoE::generic_error() const {
-    return search_and_convert<std::string>(GENERIC_ERROR);
+string PPPoE::generic_error() const {
+    return search_and_convert<string>(GENERIC_ERROR);
 }
 
-PPPoE::vendor_spec_type PPPoE::vendor_spec_type::from_option(const tag &opt) {
-    if(opt.data_size() < sizeof(uint32_t))
+PPPoE::vendor_spec_type PPPoE::vendor_spec_type::from_option(const tag& opt) {
+    if (opt.data_size() < sizeof(uint32_t)) {
         throw malformed_option();
+    }
     vendor_spec_type output;
-    std::memcpy(&output.vendor_id, opt.data_ptr(), sizeof(uint32_t));
-    output.vendor_id = Endian::be_to_host(output.vendor_id);
-    output.data.assign(
-        opt.data_ptr() + sizeof(uint32_t), 
-        opt.data_ptr() + opt.data_size()
-    );
+    InputMemoryStream stream(opt.data_ptr(), opt.data_size());
+    output.vendor_id = stream.read_be<uint32_t>();
+    stream.read(output.data, stream.size());
     return output;
 }
-} //namespace Tins
 
+} //namespace Tins
diff --git a/src/radiotap.cpp b/src/radiotap.cpp
index c7ce186..d43a229 100644
--- a/src/radiotap.cpp
+++ b/src/radiotap.cpp
@@ -49,33 +49,34 @@
 #include "exceptions.h"
 #include "memory_helpers.h"
 
+using std::memcpy;
+
 using Tins::Memory::OutputMemoryStream;
 
 namespace Tins {
 
 void check_size(uint32_t total_sz, size_t field_size) {
-    if(total_sz < field_size)
+    if (total_sz < field_size) {
         throw malformed_packet();
+    }
 }
 
 template<typename T>
-void read_field(const uint8_t* &buffer, uint32_t &total_sz, T& field) {
+void read_field(const uint8_t* &buffer, uint32_t& total_sz, T& field) {
     check_size(total_sz, sizeof(field));
     memcpy(&field, buffer, sizeof(field));
     buffer += sizeof(field);
     total_sz -= sizeof(field);
 }
 
-RadioTap::RadioTap() : _radio()
-{
+RadioTap::RadioTap() : radio_() {
     init();
 }
 
-RadioTap::RadioTap(const uint8_t *buffer, uint32_t total_sz)
-{
-    check_size(total_sz, sizeof(_radio));
-    const uint8_t *buffer_start = buffer;
-    std::memcpy(&_radio, buffer, sizeof(_radio));
+RadioTap::RadioTap(const uint8_t* buffer, uint32_t total_sz) {
+    check_size(total_sz, sizeof(radio_));
+    const uint8_t* buffer_start = buffer;
+    memcpy(&radio_, buffer, sizeof(radio_));
     uint32_t radiotap_hdr_size = length();
     check_size(total_sz, radiotap_hdr_size);
     // We start on the first flags field, skipping version, pad and length.
@@ -86,74 +87,81 @@ RadioTap::RadioTap(const uint8_t *buffer, uint32_t total_sz)
     buffer += extra_flags_size;
     radiotap_hdr_size -= extra_flags_size;
     // Also skip the header
-    buffer += sizeof(_radio);
-    radiotap_hdr_size -= sizeof(_radio);
+    buffer += sizeof(radio_);
+    radiotap_hdr_size -= sizeof(radio_);
 
-    while(true) {
-        _radio.flags_32 |= *(const uint32_t*)current_flags;
-        if(current_flags->tsft) {
+    while (true) {
+        radio_.flags_32 |= *(const uint32_t*)current_flags;
+        if (current_flags->tsft) {
             align_buffer<8>(buffer_start, buffer, radiotap_hdr_size);
-            read_field(buffer, radiotap_hdr_size, _tsft);
+            read_field(buffer, radiotap_hdr_size, tsft_);
         }
 
-        if(current_flags->flags)
-            read_field(buffer, radiotap_hdr_size, _flags);
+        if (current_flags->flags) {
+            read_field(buffer, radiotap_hdr_size, flags_);
+        }
 
-        if(current_flags->rate)
-            read_field(buffer, radiotap_hdr_size, _rate);
+        if (current_flags->rate) {
+            read_field(buffer, radiotap_hdr_size, rate_);
+        }
 
-        if(current_flags->channel) {
+        if (current_flags->channel) {
             align_buffer<2>(buffer_start, buffer, radiotap_hdr_size);
-            read_field(buffer, radiotap_hdr_size, _channel_freq);
-            read_field(buffer, radiotap_hdr_size, _channel_type);
+            read_field(buffer, radiotap_hdr_size, channel_freq_);
+            read_field(buffer, radiotap_hdr_size, channel_type_);
         }
 
-        if(current_flags->dbm_signal)
-            read_field(buffer, radiotap_hdr_size, _dbm_signal);
+        if (current_flags->dbm_signal) {
+            read_field(buffer, radiotap_hdr_size, dbm_signal_);
+        }
 
-        if(current_flags->dbm_noise)
-            read_field(buffer, radiotap_hdr_size, _dbm_noise);
+        if (current_flags->dbm_noise) {
+            read_field(buffer, radiotap_hdr_size, dbm_noise_);
+        }
 
-        if(current_flags->lock_quality)
-            read_field(buffer, radiotap_hdr_size, _signal_quality);
+        if (current_flags->lock_quality) {
+            read_field(buffer, radiotap_hdr_size, signal_quality_);
+        }
 
-        if(current_flags->antenna)
-            read_field(buffer, radiotap_hdr_size, _antenna);
+        if (current_flags->antenna) {
+            read_field(buffer, radiotap_hdr_size, antenna_);
+        }
 
-        if(current_flags->db_signal)
-            read_field(buffer, radiotap_hdr_size, _db_signal);
+        if (current_flags->db_signal) {
+            read_field(buffer, radiotap_hdr_size, db_signal_);
+        }
 
-        if(current_flags->rx_flags) {
+        if (current_flags->rx_flags) {
             align_buffer<2>(buffer_start, buffer, radiotap_hdr_size);
-            read_field(buffer, radiotap_hdr_size, _rx_flags);
+            read_field(buffer, radiotap_hdr_size, rx_flags_);
         }
 
-        if(current_flags->tx_flags) {
+        if (current_flags->tx_flags) {
             align_buffer<2>(buffer_start, buffer, radiotap_hdr_size);
-            read_field(buffer, radiotap_hdr_size, _tx_flags);
+            read_field(buffer, radiotap_hdr_size, tx_flags_);
         }
 
-        if(current_flags->data_retries) {
-            read_field(buffer, radiotap_hdr_size, _data_retries);
+        if (current_flags->data_retries) {
+            read_field(buffer, radiotap_hdr_size, data_retries_);
         }
 
-        if(current_flags->channel_plus) {
+        if (current_flags->channel_plus) {
             align_buffer<4>(buffer_start, buffer, radiotap_hdr_size);
             uint32_t dummy;
             read_field(buffer, radiotap_hdr_size, dummy);
             // nasty Big Endian fix
-            _channel_type = Endian::le_to_host<uint16_t>(Endian::host_to_le<uint32_t>(dummy));
-            read_field(buffer, radiotap_hdr_size, _channel_freq);
-            read_field(buffer, radiotap_hdr_size, _channel);
-            read_field(buffer, radiotap_hdr_size, _max_power);
+            channel_type_ = Endian::le_to_host<uint16_t>(Endian::host_to_le<uint32_t>(dummy));
+            read_field(buffer, radiotap_hdr_size, channel_freq_);
+            read_field(buffer, radiotap_hdr_size, channel_);
+            read_field(buffer, radiotap_hdr_size, max_power_);
         }
-        if(current_flags->mcs) {
-            read_field(buffer, radiotap_hdr_size, _mcs.known);
-            read_field(buffer, radiotap_hdr_size, _mcs.flags);
-            read_field(buffer, radiotap_hdr_size, _mcs.mcs);
+        if (current_flags->mcs) {
+            read_field(buffer, radiotap_hdr_size, mcs_.known);
+            read_field(buffer, radiotap_hdr_size, mcs_.flags);
+            read_field(buffer, radiotap_hdr_size, mcs_.mcs);
         } 
         // We can do this safely because we checked the size on find_extra_flags...
-        if(current_flags->ext == 1) {
+        if (current_flags->ext == 1) {
             current_flags++;
         }
         else {
@@ -164,15 +172,17 @@ RadioTap::RadioTap(const uint8_t *buffer, uint32_t total_sz)
     total_sz -= length();
     buffer += radiotap_hdr_size;
 
-    if(_radio.flags.flags && (flags() & FCS) != 0) {
+    if (radio_.flags.flags && (flags() & FCS) != 0) {
         check_size(total_sz, sizeof(uint32_t));
         total_sz -= sizeof(uint32_t);
-        if((flags() & FAILED_FCS) !=0)
+        if ((flags() & FAILED_FCS) !=0) {
             throw malformed_packet();
+        }
     }
 
-    if(total_sz)
+    if (total_sz) {
         inner_pdu(Dot11::from_bytes(buffer, total_sz));
+    }
 }
 
 void RadioTap::init() {
@@ -200,241 +210,266 @@ uint32_t RadioTap::find_extra_flag_fields_size(const uint8_t* buffer, uint32_t t
 
 // Setter for RadioTap fields
 void RadioTap::version(uint8_t new_version) {
-    _radio.it_version = new_version;
+    radio_.it_version = new_version;
 }
 
 void RadioTap::padding(uint8_t new_padding) {
-    _radio.it_pad = new_padding;
+    radio_.it_pad = new_padding;
 }
 
 void RadioTap::length(uint16_t new_length) {
-    _radio.it_len = Endian::host_to_le(new_length);
+    radio_.it_len = Endian::host_to_le(new_length);
 }
 
 void RadioTap::tsft(uint64_t new_tsft) {
-    _tsft = Endian::host_to_le(new_tsft);
-    _radio.flags.tsft = 1;
+    tsft_ = Endian::host_to_le(new_tsft);
+    radio_.flags.tsft = 1;
 }
 
 void RadioTap::flags(FrameFlags new_flags) {
-    _flags = (uint8_t)new_flags;
-    _radio.flags.flags = 1;
+    flags_ = (uint8_t)new_flags;
+    radio_.flags.flags = 1;
 }
 
 void RadioTap::rate(uint8_t new_rate) {
-    _rate = new_rate;
-    _radio.flags.rate = 1;
+    rate_ = new_rate;
+    radio_.flags.rate = 1;
 }
 
 void RadioTap::channel(uint16_t new_freq, uint16_t new_type) {
-    _channel_freq = Endian::host_to_le(new_freq);
-    _channel_type = Endian::host_to_le(new_type);
-    _radio.flags.channel = 1;
+    channel_freq_ = Endian::host_to_le(new_freq);
+    channel_type_ = Endian::host_to_le(new_type);
+    radio_.flags.channel = 1;
 }
 void RadioTap::dbm_signal(int8_t new_dbm_signal) {
-    _dbm_signal = new_dbm_signal;
-    _radio.flags.dbm_signal = 1;
+    dbm_signal_ = new_dbm_signal;
+    radio_.flags.dbm_signal = 1;
 }
 
 void RadioTap::dbm_noise(int8_t new_dbm_noise) {
-    _dbm_noise = new_dbm_noise;
-    _radio.flags.dbm_noise = 1;
+    dbm_noise_ = new_dbm_noise;
+    radio_.flags.dbm_noise = 1;
 }
 
 void RadioTap::signal_quality(uint8_t new_signal_quality) {
-    _signal_quality = new_signal_quality;
-    _radio.flags.lock_quality = 1;
+    signal_quality_ = new_signal_quality;
+    radio_.flags.lock_quality = 1;
 }
 
 void RadioTap::data_retries(uint8_t new_data_retries) {
-    _data_retries = new_data_retries;
-    _radio.flags.data_retries = 1;
+    data_retries_ = new_data_retries;
+    radio_.flags.data_retries = 1;
 }
 
 void RadioTap::antenna(uint8_t new_antenna) {
-    _antenna = new_antenna;
-    _radio.flags.antenna = 1;
+    antenna_ = new_antenna;
+    radio_.flags.antenna = 1;
 }
 
 void RadioTap::db_signal(uint8_t new_db_signal) {
-    _db_signal = new_db_signal;
-    _radio.flags.db_signal = 1;
+    db_signal_ = new_db_signal;
+    radio_.flags.db_signal = 1;
 }
 
 void RadioTap::rx_flags(uint16_t new_rx_flag) {
-    _rx_flags = Endian::host_to_le(new_rx_flag);
-    _radio.flags.rx_flags = 1;
+    rx_flags_ = Endian::host_to_le(new_rx_flag);
+    radio_.flags.rx_flags = 1;
 }
 
 void RadioTap::tx_flags(uint16_t new_tx_flag) {
-    _tx_flags = Endian::host_to_le(new_tx_flag);
-    _radio.flags.tx_flags = 1;
+    tx_flags_ = Endian::host_to_le(new_tx_flag);
+    radio_.flags.tx_flags = 1;
 }
 
 void RadioTap::mcs(const mcs_type& new_mcs) {
-    _mcs = new_mcs;
-    _radio.flags.mcs = 1;   
+    mcs_ = new_mcs;
+    radio_.flags.mcs = 1;   
 }
 
 uint32_t RadioTap::header_size() const {
     uint32_t total_bytes = 0;
-    if(_radio.flags.tsft)
-        total_bytes += sizeof(_tsft);
-    if(_radio.flags.flags)
-        total_bytes += sizeof(_flags);
-    if(_radio.flags.rate)
-        total_bytes += sizeof(_rate);
-    if(_radio.flags.channel) {
+    if (radio_.flags.tsft) {
+        total_bytes += sizeof(tsft_);
+    }
+    if (radio_.flags.flags) {
+        total_bytes += sizeof(flags_);
+    }
+    if (radio_.flags.rate) {
+        total_bytes += sizeof(rate_);
+    }
+    if (radio_.flags.channel) {
         total_bytes += (total_bytes & 1);
         total_bytes += sizeof(uint16_t) * 2;
     }
-    if(_radio.flags.dbm_signal)
-        total_bytes += sizeof(_dbm_signal);
-    if(_radio.flags.dbm_noise)
-        total_bytes += sizeof(_dbm_noise);
-    if(_radio.flags.lock_quality) {
-        total_bytes += (total_bytes & 1);
-        total_bytes += sizeof(_signal_quality);
+    if (radio_.flags.dbm_signal) {
+        total_bytes += sizeof(dbm_signal_);
     }
-    if(_radio.flags.antenna)
-        total_bytes += sizeof(_antenna);
-    if(_radio.flags.db_signal)
-        total_bytes += sizeof(_db_signal);
-    if(_radio.flags.rx_flags) {
-        total_bytes += (total_bytes & 1);
-        total_bytes += sizeof(_rx_flags);
+    if (radio_.flags.dbm_noise) {
+        total_bytes += sizeof(dbm_noise_);
     }
-    if(_radio.flags.tx_flags) {
+    if (radio_.flags.lock_quality) {
         total_bytes += (total_bytes & 1);
-        total_bytes += sizeof(_tx_flags);
+        total_bytes += sizeof(signal_quality_);
     }
-    if(_radio.flags.data_retries)
-        total_bytes += sizeof(_data_retries);
-    if(_radio.flags.channel_plus) {
+    if (radio_.flags.antenna) {
+        total_bytes += sizeof(antenna_);
+    }
+    if (radio_.flags.db_signal) {
+        total_bytes += sizeof(db_signal_);
+    }
+    if (radio_.flags.rx_flags) {
+        total_bytes += (total_bytes & 1);
+        total_bytes += sizeof(rx_flags_);
+    }
+    if (radio_.flags.tx_flags) {
+        total_bytes += (total_bytes & 1);
+        total_bytes += sizeof(tx_flags_);
+    }
+    if (radio_.flags.data_retries) {
+        total_bytes += sizeof(data_retries_);
+    }
+    if (radio_.flags.channel_plus) {
         uint32_t offset = total_bytes % 4;
-        if(offset)
+        if (offset) {
             total_bytes += 4 - offset;
+        }
         total_bytes += 8;
     }
-    if(_radio.flags.mcs) {
-        total_bytes += sizeof(_mcs);
+    if (radio_.flags.mcs) {
+        total_bytes += sizeof(mcs_);
     }
 
-    return sizeof(_radio) + total_bytes;
+    return sizeof(radio_) + total_bytes;
 }
 
 uint32_t RadioTap::trailer_size() const {
     // will be sizeof(uint32_t) if the FCS-at-the-end bit is on.
-    return ((_flags & 0x10) != 0) ? sizeof(uint32_t) : 0;
+    return ((flags_ & 0x10) != 0) ? sizeof(uint32_t) : 0;
 }
 
 // Getter for RadioTap fields
 uint8_t RadioTap::version() const {
-    return _radio.it_version;
+    return radio_.it_version;
 }
 
 uint8_t RadioTap::padding() const {
-    return _radio.it_pad;
+    return radio_.it_pad;
 }
 
 uint16_t RadioTap::length() const {
-    return Endian::le_to_host(_radio.it_len);
+    return Endian::le_to_host(radio_.it_len);
 }
 
 uint64_t RadioTap::tsft() const {
-   if(!_radio.flags.tsft)
+   if (!radio_.flags.tsft) {
         throw field_not_present();
-    return Endian::le_to_host(_tsft);
+   }
+    return Endian::le_to_host(tsft_);
 }
 
 RadioTap::FrameFlags RadioTap::flags() const {
-    if(!_radio.flags.flags)
+    if (!radio_.flags.flags) {
         throw field_not_present();
-    return (FrameFlags)_flags;
+    }
+    return (FrameFlags)flags_;
 }
 
 uint8_t RadioTap::rate() const {
-    if(!_radio.flags.rate)
+    if (!radio_.flags.rate) {
         throw field_not_present();
-    return _rate;
+    }
+    return rate_;
 }
 
 uint16_t RadioTap::channel_freq() const {
-    if(!_radio.flags.channel)
-         throw field_not_present();
-    return Endian::le_to_host(_channel_freq);
+    if (!radio_.flags.channel) {
+        throw field_not_present();
+    }
+    return Endian::le_to_host(channel_freq_);
 }
 
 uint16_t RadioTap::channel_type() const {
-    if(!_radio.flags.channel)
+    if (!radio_.flags.channel) {
         throw field_not_present();
-    return Endian::le_to_host(_channel_type);
+    }
+    return Endian::le_to_host(channel_type_);
 }
 
 int8_t RadioTap::dbm_signal() const {
-    if(!_radio.flags.dbm_signal)
+    if (!radio_.flags.dbm_signal) {
         throw field_not_present();
-    return _dbm_signal;
+    }
+    return dbm_signal_;
 }
 
 int8_t RadioTap::dbm_noise() const {
-    if(!_radio.flags.dbm_noise)
+    if (!radio_.flags.dbm_noise) {
         throw field_not_present();
-    return _dbm_noise;
+    }
+    return dbm_noise_;
 }
 
 uint16_t RadioTap::signal_quality() const {
-    if(!_radio.flags.lock_quality)
-         throw field_not_present();
-    return _signal_quality;
+    if (!radio_.flags.lock_quality) {
+        throw field_not_present();
+    }
+    return signal_quality_;
 }
 
 uint8_t RadioTap::antenna() const {
-    if(!_radio.flags.antenna)
-         throw field_not_present();
-    return _antenna;
+    if (!radio_.flags.antenna) {
+        throw field_not_present();
+    }
+    return antenna_;
 }
 
 RadioTap::mcs_type RadioTap::mcs() const {
-    if(!_radio.flags.mcs)
-         throw field_not_present();
-    return _mcs;
+    if (!radio_.flags.mcs) {
+        throw field_not_present();
+    }
+    return mcs_;
 }
 
 uint8_t RadioTap::db_signal() const {
-    if(!_radio.flags.db_signal)
-         throw field_not_present();
-    return _db_signal;
+    if (!radio_.flags.db_signal) {
+        throw field_not_present();
+    }
+    return db_signal_;
 }
 
 uint32_t RadioTap::channel_plus() const {
-    if(!_radio.flags.channel_plus)
+    if (!radio_.flags.channel_plus) {
         throw field_not_present();
-    return Endian::le_to_host<uint32_t>(_channel_type);
+    }
+    return Endian::le_to_host<uint32_t>(channel_type_);
 }
 
 uint16_t RadioTap::rx_flags() const {
-    if(!_radio.flags.rx_flags)
-         throw field_not_present();
-    return Endian::le_to_host(_rx_flags);
+    if (!radio_.flags.rx_flags) {
+        throw field_not_present();
+    }
+    return Endian::le_to_host(rx_flags_);
 }
 
 uint16_t RadioTap::tx_flags() const {
-    if(!_radio.flags.tx_flags)
-         throw field_not_present();
-    return Endian::le_to_host(_tx_flags);
+    if (!radio_.flags.tx_flags) {
+        throw field_not_present();
+    }
+    return Endian::le_to_host(tx_flags_);
 }
 
 uint8_t RadioTap::data_retries() const {
-    if(!_radio.flags.data_retries)
-         throw field_not_present();
-    return _data_retries;
+    if (!radio_.flags.data_retries) {
+        throw field_not_present();
+    }
+    return data_retries_;
 }
 
 #ifndef _WIN32
-void RadioTap::send(PacketSender &sender, const NetworkInterface &iface) {
-    if(!iface)
+void RadioTap::send(PacketSender& sender, const NetworkInterface& iface) {
+    if (!iface) {
         throw invalid_interface();
+    }
 
     #if !defined(BSD) && !defined(__FreeBSD_kernel__)
         struct sockaddr_ll addr;
@@ -446,8 +481,8 @@ void RadioTap::send(PacketSender &sender, const NetworkInterface &iface) {
         addr.sll_halen = 6;
         addr.sll_ifindex = iface.id();
 
-        const Tins::Dot11 *wlan = tins_cast<Tins::Dot11*>(inner_pdu());
-        if(wlan) {
+        const Tins::Dot11* wlan = tins_cast<Tins::Dot11*>(inner_pdu());
+        if (wlan) {
             Tins::Dot11::address_type dot11_addr(wlan->addr1());
             std::copy(dot11_addr.begin(), dot11_addr.end(), addr.sll_addr);
         }
@@ -459,11 +494,12 @@ void RadioTap::send(PacketSender &sender, const NetworkInterface &iface) {
 }
 #endif
 
-bool RadioTap::matches_response(const uint8_t *ptr, uint32_t total_sz) const {
-    if(sizeof(_radio) < total_sz)
+bool RadioTap::matches_response(const uint8_t* ptr, uint32_t total_sz) const {
+    if (sizeof(radio_) < total_sz) {
         return false;
-    const radiotap_hdr *radio_ptr = (const radiotap_hdr*)ptr;
-    if(radio_ptr->it_len <= total_sz) {
+    }
+    const radiotap_hdr* radio_ptr = (const radiotap_hdr*)ptr;
+    if (radio_ptr->it_len <= total_sz) {
         ptr += radio_ptr->it_len;
         total_sz -= radio_ptr->it_len;
         return inner_pdu() ? inner_pdu()->matches_response(ptr, total_sz) : true;
@@ -471,65 +507,65 @@ bool RadioTap::matches_response(const uint8_t *ptr, uint32_t total_sz) const {
     return false;
 }
 
-void RadioTap::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent) {
+void RadioTap::write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent) {
     OutputMemoryStream stream(buffer, total_sz);
-    uint8_t *buffer_start = buffer;
-    _radio.it_len = Endian::host_to_le<uint16_t>(header_size());
-    stream.write(_radio);
-    if(_radio.flags.tsft) {
-        stream.write(_tsft);
+    uint8_t* buffer_start = buffer;
+    radio_.it_len = Endian::host_to_le<uint16_t>(header_size());
+    stream.write(radio_);
+    if (radio_.flags.tsft) {
+        stream.write(tsft_);
     }
-    if(_radio.flags.flags) {
-        stream.write(_flags);
+    if (radio_.flags.flags) {
+        stream.write(flags_);
     }
-    if(_radio.flags.rate) {
-        stream.write(_rate);
+    if (radio_.flags.rate) {
+        stream.write(rate_);
     }
-    if(_radio.flags.channel) {
-        if(((buffer - buffer_start) & 1) == 1) {
+    if (radio_.flags.channel) {
+        if (((buffer - buffer_start) & 1) == 1) {
             stream.write<uint8_t>(0);
         }
-        stream.write(_channel_freq);
-        stream.write(_channel_type);
+        stream.write(channel_freq_);
+        stream.write(channel_type_);
     }
-    if(_radio.flags.dbm_signal) {
-        stream.write(_dbm_signal);
+    if (radio_.flags.dbm_signal) {
+        stream.write(dbm_signal_);
     }
-    if(_radio.flags.dbm_noise) {
-        stream.write(_dbm_noise);
+    if (radio_.flags.dbm_noise) {
+        stream.write(dbm_noise_);
     }
-    if(_radio.flags.lock_quality) {
-        if(((buffer - buffer_start) & 1) == 1) {
+    if (radio_.flags.lock_quality) {
+        if (((buffer - buffer_start) & 1) == 1) {
             stream.write<uint8_t>(0);
         }
-        stream.write(_signal_quality);
+        stream.write(signal_quality_);
     }
-    if(_radio.flags.antenna) {
-        stream.write(_antenna);
+    if (radio_.flags.antenna) {
+        stream.write(antenna_);
     }
-    if(_radio.flags.db_signal) {
-        stream.write(_db_signal);
+    if (radio_.flags.db_signal) {
+        stream.write(db_signal_);
     }
-    if(_radio.flags.rx_flags) {
-        if(((buffer - buffer_start) & 1) == 1) {
+    if (radio_.flags.rx_flags) {
+        if (((buffer - buffer_start) & 1) == 1) {
             stream.write<uint8_t>(0);
         }
-        stream.write(_rx_flags);
+        stream.write(rx_flags_);
     }
-    if(_radio.flags.channel_plus) {
+    if (radio_.flags.channel_plus) {
         const uint32_t padding = ((stream.pointer() - buffer_start) % 4);
         if (padding != 0) {
             stream.fill(4 - padding, 0);
         }
-        uint32_t dummy = _channel_type;
+        uint32_t dummy = channel_type_;
         // nasty Big Endian fix
         dummy = Endian::le_to_host<uint32_t>(Endian::host_to_le<uint16_t>(dummy));
         stream.write(dummy);
-        stream.write(_channel_freq);
-        stream.write(_channel);
-        stream.write(_max_power);
+        stream.write(channel_freq_);
+        stream.write(channel_);
+        stream.write(max_power_);
     }
-    if ((_flags & 0x10) != 0 && inner_pdu()) {
+    if ((flags_ & 0x10) != 0 && inner_pdu()) {
     	uint32_t crc32 = Endian::host_to_le(
             Utils::crc32(stream.pointer(), inner_pdu()->size())
         );
@@ -537,6 +573,7 @@ void RadioTap::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU
         stream.write(crc32);
     }
 }
-}
+
+} // Tins
 
 #endif // HAVE_DOT11
diff --git a/src/rawpdu.cpp b/src/rawpdu.cpp
index c0fb83c..4ecee6a 100644
--- a/src/rawpdu.cpp
+++ b/src/rawpdu.cpp
@@ -34,31 +34,31 @@
 using Tins::Memory::OutputMemoryStream;
 
 namespace Tins {
-RawPDU::RawPDU(const uint8_t *pload, uint32_t size) 
-: _payload(pload, pload + size) 
-{
+RawPDU::RawPDU(const uint8_t* pload, uint32_t size) 
+: payload_(pload, pload + size) {
     
 }
 
-RawPDU::RawPDU(const std::string &data) 
-: _payload(data.begin(), data.end()) {
+RawPDU::RawPDU(const std::string& data) 
+: payload_(data.begin(), data.end()) {
     
 }
 
 uint32_t RawPDU::header_size() const {
-    return static_cast<uint32_t>(_payload.size());
+    return static_cast<uint32_t>(payload_.size());
 }
 
-void RawPDU::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *) {
+void RawPDU::write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU *) {
     OutputMemoryStream stream(buffer, total_sz);
-    stream.write(_payload.begin(), _payload.end());
+    stream.write(payload_.begin(), payload_.end());
 }
 
-void RawPDU::payload(const payload_type &pload) {
-    _payload = pload;
+void RawPDU::payload(const payload_type& pload) {
+    payload_ = pload;
 }
 
-bool RawPDU::matches_response(const uint8_t *ptr, uint32_t total_sz) const {
+bool RawPDU::matches_response(const uint8_t* ptr, uint32_t total_sz) const {
     return true;
 }
-}
+
+} // Tins
diff --git a/src/rsn_information.cpp b/src/rsn_information.cpp
index e1a90aa..23511b5 100644
--- a/src/rsn_information.cpp
+++ b/src/rsn_information.cpp
@@ -42,84 +42,81 @@ using Tins::Memory::OutputMemoryStream;
 
 namespace Tins {
 
-RSNInformation::RSNInformation() : _version(1), _capabilities(0) {
+RSNInformation::RSNInformation()
+: version_(1), capabilities_(0) {
 
 }
 
-RSNInformation::RSNInformation(const serialization_type &buffer) {
+RSNInformation::RSNInformation(const serialization_type& buffer) {
     init(&buffer[0], static_cast<uint32_t>(buffer.size()));
 }
 
-RSNInformation::RSNInformation(const uint8_t *buffer, uint32_t total_sz) {
+RSNInformation::RSNInformation(const uint8_t* buffer, uint32_t total_sz) {
     init(buffer, total_sz);
 }
 
-void RSNInformation::init(const uint8_t *buffer, uint32_t total_sz) {
+void RSNInformation::init(const uint8_t* buffer, uint32_t total_sz) {
     InputMemoryStream stream(buffer, total_sz);
-    version(Endian::le_to_host(stream.read<uint16_t>()));    
-    group_suite((RSNInformation::CypherSuites)Endian::le_to_host(stream.read<uint32_t>()));
-    int pairwise_cyphers_size = Endian::le_to_host(stream.read<uint16_t>());
+    version(stream.read_le<uint16_t>());
+    group_suite((RSNInformation::CypherSuites)stream.read_le<uint32_t>());
+    int pairwise_cyphers_size = stream.read_le<uint16_t>();
     if (!stream.can_read(pairwise_cyphers_size)) {
         throw malformed_packet();
     }
     while (pairwise_cyphers_size--) {
-        add_pairwise_cypher(
-            (RSNInformation::CypherSuites)Endian::le_to_host(stream.read<uint32_t>())
-        );
+        add_pairwise_cypher((RSNInformation::CypherSuites)stream.read_le<uint32_t>());
     }
-    int akm_cyphers_size = Endian::le_to_host(stream.read<uint16_t>());
+    int akm_cyphers_size = stream.read_le<uint16_t>();
     if (!stream.can_read(akm_cyphers_size)) {
         throw malformed_packet();
     }
     while (akm_cyphers_size--) {
-        add_akm_cypher(
-            (RSNInformation::AKMSuites)Endian::le_to_host(stream.read<uint32_t>())
-        );
+        add_akm_cypher((RSNInformation::AKMSuites)stream.read_le<uint32_t>());
     }
-    capabilities(Endian::le_to_host(stream.read<uint16_t>()));
+    capabilities(stream.read_le<uint16_t>());
 }
 
 void RSNInformation::add_pairwise_cypher(CypherSuites cypher) {
-    _pairwise_cyphers.push_back(cypher);
+    pairwise_cyphers_.push_back(cypher);
 }
 
 void RSNInformation::add_akm_cypher(AKMSuites akm) {
-    _akm_cyphers.push_back(akm);
+    akm_cyphers_.push_back(akm);
 }
 
 void RSNInformation::group_suite(CypherSuites group) {
-    _group_suite = static_cast<CypherSuites>(Endian::host_to_le<uint32_t>(group));
+    group_suite_ = static_cast<CypherSuites>(Endian::host_to_le<uint32_t>(group));
 }
 
 void RSNInformation::version(uint16_t ver) {
-    _version = Endian::host_to_le(ver);
+    version_ = Endian::host_to_le(ver);
 }
 
 void RSNInformation::capabilities(uint16_t cap) {
-    _capabilities = Endian::host_to_le(cap);
+    capabilities_ = Endian::host_to_le(cap);
 }
 
 RSNInformation::serialization_type RSNInformation::serialize() const {
-    size_t size = sizeof(_version) + sizeof(_capabilities) + sizeof(uint32_t);
+    size_t size = sizeof(version_) + sizeof(capabilities_) + sizeof(uint32_t);
     size += (sizeof(uint16_t) << 1); // 2 lists count.
-    size += sizeof(uint32_t) * (_akm_cyphers.size() + _pairwise_cyphers.size());
+    size += sizeof(uint32_t) * (akm_cyphers_.size() + pairwise_cyphers_.size());
 
-    const uint16_t pairwise_cyphers_size = Endian::host_to_le<uint16_t>(_pairwise_cyphers.size());
-    const uint16_t akm_cyphers_size = Endian::host_to_le<uint16_t>(_akm_cyphers.size());
+    const uint16_t pairwise_cyphers_size = Endian::host_to_le<uint16_t>(pairwise_cyphers_.size());
+    const uint16_t akm_cyphers_size = Endian::host_to_le<uint16_t>(akm_cyphers_.size());
     
     serialization_type buffer(size);
     OutputMemoryStream stream(&buffer[0], buffer.size());
-    stream.write(_version);
-    stream.write(_group_suite);
+    stream.write(version_);
+    stream.write(group_suite_);
     stream.write(pairwise_cyphers_size);
-    for (cyphers_type::const_iterator it = _pairwise_cyphers.begin(); it != _pairwise_cyphers.end(); ++it) {
+    for (cyphers_type::const_iterator it = pairwise_cyphers_.begin(); it != pairwise_cyphers_.end(); ++it) {
         stream.write(Endian::host_to_le<uint32_t>(*it));
     }
     stream.write(akm_cyphers_size);
-    for (akm_type::const_iterator it = _akm_cyphers.begin(); it != _akm_cyphers.end(); ++it) {
+    for (akm_type::const_iterator it = akm_cyphers_.begin(); it != akm_cyphers_.end(); ++it) {
         stream.write(Endian::host_to_le<uint32_t>(*it));
     }
-    stream.write(_capabilities);
+    stream.write(capabilities_);
     return buffer;
 }
 
@@ -131,11 +128,13 @@ RSNInformation RSNInformation::wpa2_psk() {
     return info;
 }
 
-RSNInformation RSNInformation::from_option(const PDUOption<uint8_t, Dot11> &opt) {
-    if(opt.data_size() < sizeof(uint16_t) * 2 + sizeof(uint32_t))
+RSNInformation RSNInformation::from_option(const PDUOption<uint8_t, Dot11>& opt) {
+    if (opt.data_size() < sizeof(uint16_t) * 2 + sizeof(uint32_t)) {
         throw malformed_option();
+    }
     return RSNInformation(opt.data_ptr(), static_cast<uint32_t>(opt.data_size()));
 }
-}
+
+} // Tins
 
 #endif // HAVE_DOT11
diff --git a/src/sll.cpp b/src/sll.cpp
index c95a71a..98f6009 100644
--- a/src/sll.cpp
+++ b/src/sll.cpp
@@ -39,13 +39,13 @@ using Tins::Memory::OutputMemoryStream;
 
 namespace Tins {
 
-SLL::SLL() : _header() {
+SLL::SLL() : header_() {
     
 }
     
-SLL::SLL(const uint8_t *buffer, uint32_t total_sz) {
+SLL::SLL(const uint8_t* buffer, uint32_t total_sz) {
     InputMemoryStream stream(buffer, total_sz);
-    stream.read(_header);
+    stream.read(header_);
     if (stream) {
         inner_pdu(
             Internals::pdu_from_flag(
@@ -58,30 +58,30 @@ SLL::SLL(const uint8_t *buffer, uint32_t total_sz) {
 }
 
 void SLL::packet_type(uint16_t new_packet_type) {
-    _header.packet_type = Endian::host_to_be(new_packet_type);
+    header_.packet_type = Endian::host_to_be(new_packet_type);
 }
 
 void SLL::lladdr_type(uint16_t new_lladdr_type) {
-    _header.lladdr_type = Endian::host_to_be(new_lladdr_type);
+    header_.lladdr_type = Endian::host_to_be(new_lladdr_type);
 }
 
 void SLL::lladdr_len(uint16_t new_lladdr_len) {
-    _header.lladdr_len = Endian::host_to_be(new_lladdr_len);
+    header_.lladdr_len = Endian::host_to_be(new_lladdr_len);
 }
 
-void SLL::address(const address_type &new_address) {
-    new_address.copy(_header.address);
+void SLL::address(const address_type& new_address) {
+    new_address.copy(header_.address);
 }
 
 void SLL::protocol(uint16_t new_protocol) {
-    _header.protocol = Endian::host_to_be(new_protocol);
+    header_.protocol = Endian::host_to_be(new_protocol);
 }
 
 uint32_t SLL::header_size() const {
-    return sizeof(_header);
+    return sizeof(header_);
 }
 
-void SLL::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *) {
+void SLL::write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU *) {
     OutputMemoryStream stream(buffer, total_sz);
     if (inner_pdu()) {
         Constants::Ethernet::e flag = Internals::pdu_flag_to_ether_type(
@@ -89,7 +89,7 @@ void SLL::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *) {
         );
         protocol(static_cast<uint16_t>(flag));
     }
-    stream.write(_header);
+    stream.write(header_);
 }
 
 } // Tins
diff --git a/src/snap.cpp b/src/snap.cpp
index 5985de7..dfdb14f 100644
--- a/src/snap.cpp
+++ b/src/snap.cpp
@@ -47,16 +47,15 @@ using Tins::Memory::OutputMemoryStream;
 
 namespace Tins {
 
-SNAP::SNAP() : _snap()
-{
-    _snap.dsap = _snap.ssap = 0xaa;
+SNAP::SNAP()
+: snap_() {
+    snap_.dsap = snap_.ssap = 0xaa;
     control(3);
 }
 
-SNAP::SNAP(const uint8_t *buffer, uint32_t total_sz) 
-{
+SNAP::SNAP(const uint8_t* buffer, uint32_t total_sz) {
     InputMemoryStream stream(buffer, total_sz);
-    stream.read(_snap);
+    stream.read(snap_);
     if (stream) {
         inner_pdu(
             Internals::pdu_from_flag(
@@ -70,39 +69,39 @@ SNAP::SNAP(const uint8_t *buffer, uint32_t total_sz)
 
 void SNAP::control(uint8_t new_control) {
     #if TINS_IS_LITTLE_ENDIAN
-    _snap.control_org = (_snap.control_org & 0xffffff00) | (new_control);
+    snap_.control_org = (snap_.control_org & 0xffffff00) | (new_control);
     #else
-    _snap.control_org = (_snap.control_org & 0xffffff) | (new_control << 24);
+    snap_.control_org = (snap_.control_org & 0xffffff) | (new_control << 24);
     #endif
 }
 
 void SNAP::org_code(small_uint<24> new_org) {
     #if TINS_IS_LITTLE_ENDIAN
-    _snap.control_org = Endian::host_to_be<uint32_t>(new_org) | control();
+    snap_.control_org = Endian::host_to_be<uint32_t>(new_org) | control();
     #else
-    _snap.control_org = new_org | (control() << 24);
+    snap_.control_org = new_org | (control() << 24);
     #endif
 }
 
 void SNAP::eth_type(uint16_t new_eth) {
-    _snap.eth_type = Endian::host_to_be(new_eth); 
+    snap_.eth_type = Endian::host_to_be(new_eth); 
 }
 
 uint32_t SNAP::header_size() const {
-    return sizeof(_snap);
+    return sizeof(snap_);
 }
 
-void SNAP::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent) {
+void SNAP::write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent) {
     OutputMemoryStream stream(buffer, total_sz);
     if (inner_pdu()) {
         Constants::Ethernet::e flag = Internals::pdu_flag_to_ether_type(
             inner_pdu()->pdu_type()
         );
-        _snap.eth_type = Endian::host_to_be(
+        snap_.eth_type = Endian::host_to_be(
             static_cast<uint16_t>(flag)
         );
     }
-    stream.write(_snap);
+    stream.write(snap_);
 }
 
 } // Tins
diff --git a/src/sniffer.cpp b/src/sniffer.cpp
index 7716382..81c45a2 100644
--- a/src/sniffer.cpp
+++ b/src/sniffer.cpp
@@ -50,83 +50,79 @@ using std::string;
 using std::runtime_error;
 
 namespace Tins {
+
 BaseSniffer::BaseSniffer() 
-: handle(0), mask(0), extract_raw(false)
-{
+: handle_(0), mask_(0), extract_raw_(false) {
     
 }
     
-BaseSniffer::~BaseSniffer() 
-{
-    if (handle) {
-        pcap_close(handle);
+BaseSniffer::~BaseSniffer() {
+    if (handle_) {
+        pcap_close(handle_);
     }
 }
 
-void BaseSniffer::set_pcap_handle(pcap_t* const pcap_handle)
-{
-    handle = pcap_handle;
+void BaseSniffer::set_pcap_handle(pcap_t* pcap_handle) {
+    handle_ = pcap_handle;
 }
 
-pcap_t* BaseSniffer::get_pcap_handle()
-{
-    return handle;
+pcap_t* BaseSniffer::get_pcap_handle() {
+    return handle_;
 }
 
-const pcap_t* BaseSniffer::get_pcap_handle() const
-{
-    return handle;
+const pcap_t* BaseSniffer::get_pcap_handle() const {
+    return handle_;
 }
 
-void BaseSniffer::set_if_mask(bpf_u_int32 if_mask)
-{
-    mask = if_mask;
+void BaseSniffer::set_if_mask(bpf_u_int32 if_mask) {
+    mask_ = if_mask;
 }
 
-bpf_u_int32 BaseSniffer::get_if_mask() const
-{
-    return mask;
+bpf_u_int32 BaseSniffer::get_if_mask() const {
+    return mask_;
 }
 
 struct sniff_data {
     struct timeval tv;
-    PDU *pdu;
+    PDU* pdu;
     bool packet_processed;
 
     sniff_data() : pdu(0), packet_processed(true) { }
 };
 
 template<typename T>
-T *safe_alloc(const u_char *bytes, bpf_u_int32 len) {
+T* safe_alloc(const u_char* bytes, bpf_u_int32 len) {
     try {
         return new T((const uint8_t*)bytes, len);
     }
-    catch(malformed_packet&) {
+    catch (malformed_packet&) {
         return 0;
     }
 }
 
 template<typename T>
-void sniff_loop_handler(u_char *user, const struct pcap_pkthdr *h, const u_char *bytes) {
-    sniff_data *data = (sniff_data*)user;
+void sniff_loop_handler(u_char* user, const struct pcap_pkthdr* h, const u_char* bytes) {
+    sniff_data* data = (sniff_data*)user;
     data->packet_processed = true;
     data->tv = h->ts;
     data->pdu = safe_alloc<T>(bytes, h->caplen);
 }
 
-void sniff_loop_eth_handler(u_char *user, const struct pcap_pkthdr *h, const u_char *bytes) {
-    sniff_data *data = (sniff_data*)user;
+void sniff_loop_eth_handler(u_char* user, const struct pcap_pkthdr* h, const u_char* bytes) {
+    sniff_data* data = (sniff_data*)user;
     data->packet_processed = true;
     data->tv = h->ts;
-    if(Internals::is_dot3((const uint8_t*)bytes, h->caplen))
+    if (Internals::is_dot3((const uint8_t*)bytes, h->caplen)) {
         data->pdu = safe_alloc<Dot3>((const uint8_t*)bytes, h->caplen);
-    else
+    }
+    else {
         data->pdu = safe_alloc<EthernetII>((const uint8_t*)bytes, h->caplen);
+    }
 }
 
 #ifdef HAVE_DOT11
-void sniff_loop_dot11_handler(u_char *user, const struct pcap_pkthdr *h, const u_char *bytes) {
-    sniff_data *data = (sniff_data*)user;
+void sniff_loop_dot11_handler(u_char* user, const struct pcap_pkthdr* h, const u_char* bytes) {
+    sniff_data* data = (sniff_data*)user;
     data->packet_processed = true;
     data->tv = h->ts;
     try {
@@ -140,20 +136,22 @@ void sniff_loop_dot11_handler(u_char *user, const struct pcap_pkthdr *h, const u
 
 PtrPacket BaseSniffer::next_packet() {
     sniff_data data;
-    const int iface_type = pcap_datalink(handle);
+    const int iface_type = pcap_datalink(handle_);
     pcap_handler handler = 0;
-    if(extract_raw)
+    if (extract_raw_) {
         handler = &sniff_loop_handler<RawPDU>;
-    else if(iface_type == DLT_EN10MB)
+    }
+    else if (iface_type == DLT_EN10MB) {
         handler = sniff_loop_eth_handler;
-    else if(iface_type == DLT_IEEE802_11_RADIO) {
+    }
+    else if (iface_type == DLT_IEEE802_11_RADIO) {
         #ifdef HAVE_DOT11
             handler = &sniff_loop_handler<RadioTap>;
         #else
             throw protocol_disabled();
         #endif
     }
-    else if(iface_type == DLT_IEEE802_11) {
+    else if (iface_type == DLT_IEEE802_11) {
         #ifdef HAVE_DOT11
             handler = sniff_loop_dot11_handler;
         #else
@@ -165,41 +163,46 @@ PtrPacket BaseSniffer::next_packet() {
         handler = &sniff_loop_handler<PKTAP>;
     }
     #endif // DLT_PKTAP
-    else if(iface_type == DLT_NULL)
+    else if (iface_type == DLT_NULL) {
         handler = &sniff_loop_handler<Tins::Loopback>;
-    else if(iface_type == DLT_LINUX_SLL)
+    }
+    else if (iface_type == DLT_LINUX_SLL) {
         handler = &sniff_loop_handler<SLL>;
-    else if(iface_type == DLT_PPI)
+    }
+    else if (iface_type == DLT_PPI) {
         handler = &sniff_loop_handler<PPI>;
-    else
+    }
+    else {
         throw unknown_link_type();
+    }
     // keep calling pcap_loop until a well-formed packet is found.
-    while(data.pdu == 0 && data.packet_processed) {
+    while (data.pdu == 0 && data.packet_processed) {
         data.packet_processed = false;
-        if(pcap_loop(handle, 1, handler, (u_char*)&data) < 0)
+        if (pcap_loop(handle_, 1, handler, (u_char*)&data) < 0) {
             return PtrPacket(0, Timestamp());
+        }
     }
     return PtrPacket(data.pdu, data.tv);
 }
 
 void BaseSniffer::set_extract_raw_pdus(bool value) {
-    extract_raw = value;
+    extract_raw_ = value;
 }
 
 void BaseSniffer::stop_sniff() {
-    pcap_breakloop(handle);
+    pcap_breakloop(handle_);
 }
 
 int BaseSniffer::get_fd() {
     #ifndef _WIN32
-        return pcap_get_selectable_fd(handle);
+        return pcap_get_selectable_fd(handle_);
     #else
-        throw std::runtime_error("Method not supported in Windows platform");
+        throw unsupported_function();
     #endif // _WIN32
 }
 
 int BaseSniffer::link_type() const {
-    return pcap_datalink(handle);
+    return pcap_datalink(handle_);
 }
 
 BaseSniffer::iterator BaseSniffer::begin() {
@@ -210,24 +213,23 @@ BaseSniffer::iterator BaseSniffer::end() {
     return iterator(0);
 }
 
-bool BaseSniffer::set_filter(const std::string &filter) {
+bool BaseSniffer::set_filter(const string& filter) {
     bpf_program prog;
-    if(pcap_compile(handle, &prog, filter.c_str(), 0, mask) == -1) {
+    if (pcap_compile(handle_, &prog, filter.c_str(), 0, mask_) == -1) {
         return false;
     }
-    bool result = pcap_setfilter(handle, &prog) != -1;
+    bool result = pcap_setfilter(handle_, &prog) != -1;
     pcap_freecode(&prog);
     return result;
 }
 
 void BaseSniffer::set_timeout(int ms) {
-    pcap_set_timeout(handle, ms);
+    pcap_set_timeout(handle_, ms);
 }
 
 // ****************************** Sniffer ******************************
 
-Sniffer::Sniffer(const string &device, const SnifferConfiguration& configuration)
-{
+Sniffer::Sniffer(const string& device, const SnifferConfiguration& configuration) {
     char error[PCAP_ERRBUF_SIZE];
     pcap_t* phandle = pcap_create(TINS_PREFIX_INTERFACE(device).c_str(), error);
     if (!phandle) {
@@ -246,16 +248,18 @@ Sniffer::Sniffer(const string &device, const SnifferConfiguration& configuration
 
     // Finally, activate the pcap. In case of error throw runtime_error
     if (pcap_activate(get_pcap_handle()) < 0) {
-        throw std::runtime_error(pcap_geterr(get_pcap_handle()));
+        throw pcap_error(pcap_geterr(get_pcap_handle()));
     }
 
     // Configure the sniffer's attributes after activation.
     configuration.configure_sniffer_post_activation(*this);
 }
 
-Sniffer::Sniffer(const std::string &device, unsigned max_packet_size, bool promisc, 
-                 const std::string &filter, bool rfmon)
-{
+Sniffer::Sniffer(const string& device,
+                 unsigned max_packet_size,
+                 bool promisc, 
+                 const string& filter,
+                 bool rfmon) {
     SnifferConfiguration configuration;
     configuration.set_snap_len(max_packet_size);
     configuration.set_promisc_mode(promisc);
@@ -280,16 +284,17 @@ Sniffer::Sniffer(const std::string &device, unsigned max_packet_size, bool promi
 
     // Finally, activate the pcap. In case of error throw runtime_error
     if (pcap_activate(get_pcap_handle()) < 0) {
-        throw std::runtime_error(pcap_geterr(get_pcap_handle()));
+        throw pcap_error(pcap_geterr(get_pcap_handle()));
     }
 
     // Configure the sniffer's attributes after activation.
     configuration.configure_sniffer_post_activation(*this);
 }
 
-Sniffer::Sniffer(const std::string &device, promisc_type promisc, const std::string &filter,
-                 bool rfmon)
-{
+Sniffer::Sniffer(const string& device, 
+                 promisc_type promisc,
+                 const string& filter,
+                 bool rfmon) {
     SnifferConfiguration configuration;
     configuration.set_promisc_mode(promisc == PROMISC);
     configuration.set_filter(filter);
@@ -313,52 +318,47 @@ Sniffer::Sniffer(const std::string &device, promisc_type promisc, const std::str
 
     // Finally, activate the pcap. In case of error throw runtime_error
     if (pcap_activate(get_pcap_handle()) < 0) {
-        throw std::runtime_error(pcap_geterr(get_pcap_handle()));
+        throw pcap_error(pcap_geterr(get_pcap_handle()));
     }
 
     // Configure the sniffer's attributes after activation.
     configuration.configure_sniffer_post_activation(*this);
 }
 
-void Sniffer::set_snap_len(unsigned snap_len)
-{
+void Sniffer::set_snap_len(unsigned snap_len) {
     if (pcap_set_snaplen(get_pcap_handle(), snap_len)) {
-        throw std::runtime_error(pcap_geterr(get_pcap_handle()));
+        throw pcap_error(pcap_geterr(get_pcap_handle()));
     }
 }
 
-void Sniffer::set_buffer_size(unsigned buffer_size)
-{
+void Sniffer::set_buffer_size(unsigned buffer_size) {
     if (pcap_set_buffer_size(get_pcap_handle(), buffer_size)) {
-        throw std::runtime_error(pcap_geterr(get_pcap_handle()));
+        throw pcap_error(pcap_geterr(get_pcap_handle()));
     }
 }
 
-void Sniffer::set_promisc_mode(bool promisc_enabled)
-{
+void Sniffer::set_promisc_mode(bool promisc_enabled) {
     if (pcap_set_promisc(get_pcap_handle(), promisc_enabled)) {
-        throw runtime_error(pcap_geterr(get_pcap_handle()));
+        throw pcap_error(pcap_geterr(get_pcap_handle()));
     }
 }
 
-void Sniffer::set_immediate_mode(bool enabled) 
-{
+void Sniffer::set_immediate_mode(bool enabled) {
     // As of libpcap version 1.5.0 this function exists. Before, it was
     // technically always immediate mode since capture used TPACKET_V1/2
     // which doesn't do packet buffering.
     #ifdef HAVE_PCAP_IMMEDIATE_MODE
     if (pcap_set_immediate_mode(get_pcap_handle(), enabled)) {
-        throw runtime_error(pcap_geterr(get_pcap_handle()));
+        throw pcap_error(pcap_geterr(get_pcap_handle()));
     }
     #endif // HAVE_PCAP_IMMEDIATE_MODE
 }
 
-void Sniffer::set_rfmon(bool rfmon_enabled)
-{
+void Sniffer::set_rfmon(bool rfmon_enabled) {
     #ifndef _WIN32
     if (pcap_can_set_rfmon(get_pcap_handle()) == 1) {
         if (pcap_set_rfmon(get_pcap_handle(), rfmon_enabled)) {
-            throw runtime_error(pcap_geterr(get_pcap_handle()));
+            throw pcap_error(pcap_geterr(get_pcap_handle()));
         }
     }
     #endif
@@ -367,11 +367,12 @@ void Sniffer::set_rfmon(bool rfmon_enabled)
 
 // **************************** FileSniffer ****************************
 
-FileSniffer::FileSniffer(const string &file_name, const SnifferConfiguration& configuration) {
+FileSniffer::FileSniffer(const string& file_name, 
+                         const SnifferConfiguration& configuration) {
     char error[PCAP_ERRBUF_SIZE];
-    pcap_t *phandle = pcap_open_offline(file_name.c_str(), error);
-    if(!phandle) {
-        throw std::runtime_error(error);
+    pcap_t* phandle = pcap_open_offline(file_name.c_str(), error);
+    if (!phandle) {
+        throw pcap_error(error);
     }
     set_pcap_handle(phandle);
 
@@ -380,15 +381,14 @@ FileSniffer::FileSniffer(const string &file_name, const SnifferConfiguration& co
     
 }
 
-FileSniffer::FileSniffer(const std::string &file_name, const std::string &filter)
-{
+FileSniffer::FileSniffer(const string& file_name, const string& filter) {
     SnifferConfiguration config;
     config.set_filter(filter);
 
     char error[PCAP_ERRBUF_SIZE];
-    pcap_t *phandle = pcap_open_offline(file_name.c_str(), error);
-    if(!phandle) {
-        throw std::runtime_error(error);
+    pcap_t* phandle = pcap_open_offline(file_name.c_str(), error);
+    if (!phandle) {
+        throw pcap_error(error);
     }
     set_pcap_handle(phandle);
 
@@ -401,92 +401,76 @@ FileSniffer::FileSniffer(const std::string &file_name, const std::string &filter
 const unsigned SnifferConfiguration::DEFAULT_SNAP_LEN = 65535;
 const unsigned SnifferConfiguration::DEFAULT_TIMEOUT = 1000;
 
-SnifferConfiguration::SnifferConfiguration() :
-    _flags(0),
-    _snap_len(DEFAULT_SNAP_LEN),
-    _buffer_size(0),
-    _timeout(DEFAULT_TIMEOUT),
-    _promisc(false),
-    _rfmon(false),
-    _immediate_mode(false)
-{
+SnifferConfiguration::SnifferConfiguration()
+: flags_(0), snap_len_(DEFAULT_SNAP_LEN), buffer_size_(0), timeout_(DEFAULT_TIMEOUT),
+  promisc_(false), rfmon_(false), immediate_mode_(false) {
 
 }
 
-void SnifferConfiguration::configure_sniffer_pre_activation(Sniffer& sniffer) const
-{
-    sniffer.set_snap_len(_snap_len);
-    sniffer.set_timeout(_timeout);
-    if ((_flags & BUFFER_SIZE) != 0) {
-        sniffer.set_buffer_size(_buffer_size);
+void SnifferConfiguration::configure_sniffer_pre_activation(Sniffer& sniffer) const {
+    sniffer.set_snap_len(snap_len_);
+    sniffer.set_timeout(timeout_);
+    if ((flags_ & BUFFER_SIZE) != 0) {
+        sniffer.set_buffer_size(buffer_size_);
     }
-    if ((_flags & PROMISCUOUS) != 0) {
-        sniffer.set_promisc_mode(_promisc);
+    if ((flags_ & PROMISCUOUS) != 0) {
+        sniffer.set_promisc_mode(promisc_);
     }
-    if ((_flags & RFMON) != 0) {
-        sniffer.set_rfmon(_rfmon);
+    if ((flags_ & RFMON) != 0) {
+        sniffer.set_rfmon(rfmon_);
     }
-    if ((_flags & IMMEDIATE_MODE) != 0) {
-        sniffer.set_immediate_mode(_immediate_mode);
+    if ((flags_ & IMMEDIATE_MODE) != 0) {
+        sniffer.set_immediate_mode(immediate_mode_);
     }
 }
 
-void SnifferConfiguration::configure_sniffer_pre_activation(FileSniffer& sniffer) const
-{
-    if ((_flags & PACKET_FILTER) != 0) {
-        if (!sniffer.set_filter(_filter)) {
-            throw std::runtime_error("Could not set the filter!");
+void SnifferConfiguration::configure_sniffer_pre_activation(FileSniffer& sniffer) const {
+    if ((flags_ & PACKET_FILTER) != 0) {
+        if (!sniffer.set_filter(filter_)) {
+            throw invalid_pcap_filter(pcap_geterr(sniffer.get_pcap_handle()));
         }
     }
 }
 
-void SnifferConfiguration::configure_sniffer_post_activation(Sniffer& sniffer) const
-{
-    if ((_flags & PACKET_FILTER) != 0) {
-        if (!sniffer.set_filter(_filter)) {
-            throw std::runtime_error("Could not set the filter! ");
+void SnifferConfiguration::configure_sniffer_post_activation(Sniffer& sniffer) const {
+    if ((flags_ & PACKET_FILTER) != 0) {
+        if (!sniffer.set_filter(filter_)) {
+            throw invalid_pcap_filter(pcap_geterr(sniffer.get_pcap_handle()));
         }
     }
 }
 
-void SnifferConfiguration::set_snap_len(unsigned snap_len)
-{
-    _snap_len = snap_len;
+void SnifferConfiguration::set_snap_len(unsigned snap_len) {
+    snap_len_ = snap_len;
 }
 
-void SnifferConfiguration::set_buffer_size(unsigned buffer_size)
-{
-    _flags |= BUFFER_SIZE;
-    _buffer_size = buffer_size;
+void SnifferConfiguration::set_buffer_size(unsigned buffer_size) {
+    flags_ |= BUFFER_SIZE;
+    buffer_size_ = buffer_size;
 }
 
-void SnifferConfiguration::set_promisc_mode(bool enabled)
-{
-    _flags |= PROMISCUOUS;
-    _promisc = enabled;
+void SnifferConfiguration::set_promisc_mode(bool enabled) {
+    flags_ |= PROMISCUOUS;
+    promisc_ = enabled;
 }
 
-void SnifferConfiguration::set_filter(const std::string& filter)
-{
-    _flags |= PACKET_FILTER;
-    _filter = filter;
+void SnifferConfiguration::set_filter(const string& filter) {
+    flags_ |= PACKET_FILTER;
+    filter_ = filter;
 }
 
-void SnifferConfiguration::set_rfmon(bool enabled)
-{
-    _flags |= RFMON;
-    _rfmon = enabled;
+void SnifferConfiguration::set_rfmon(bool enabled) {
+    flags_ |= RFMON;
+    rfmon_ = enabled;
 }
 
-void SnifferConfiguration::set_timeout(unsigned timeout)
-{
-    _timeout = timeout;
+void SnifferConfiguration::set_timeout(unsigned timeout) {
+    timeout_ = timeout;
 }
 
-void SnifferConfiguration::set_immediate_mode(bool enabled) 
-{
-    _flags |= IMMEDIATE_MODE;
-    _immediate_mode = enabled;
+void SnifferConfiguration::set_immediate_mode(bool enabled) {
+    flags_ |= IMMEDIATE_MODE;
+    immediate_mode_ = enabled;
 }
 
-}
+} // Tins
diff --git a/src/stp.cpp b/src/stp.cpp
index f4090a9..db88774 100644
--- a/src/stp.cpp
+++ b/src/stp.cpp
@@ -33,89 +33,89 @@
 #include "exceptions.h"
 #include "memory_helpers.h"
 
+using std::copy;
+
 using Tins::Memory::InputMemoryStream;
 using Tins::Memory::OutputMemoryStream;
 
 namespace Tins {
 
 STP::STP() 
-: _header() 
-{
+: header_() {
     
 }
 
-STP::STP(const uint8_t *buffer, uint32_t total_sz) 
-{
+STP::STP(const uint8_t* buffer, uint32_t total_sz) {
     InputMemoryStream stream(buffer, total_sz);
-    stream.read(_header);
+    stream.read(header_);
 }
 
 void STP::proto_id(uint16_t new_proto_id) {
-    _header.proto_id = Endian::host_to_be(new_proto_id);
+    header_.proto_id = Endian::host_to_be(new_proto_id);
 }
 
 void STP::proto_version(uint8_t new_proto_version) {
-    _header.proto_version = new_proto_version;
+    header_.proto_version = new_proto_version;
 }
 
 void STP::bpdu_type(uint8_t new_bpdu_type) {
-    _header.bpdu_type = new_bpdu_type;
+    header_.bpdu_type = new_bpdu_type;
 }
 
 void STP::bpdu_flags(uint8_t new_bpdu_flags) {
-    _header.bpdu_flags = new_bpdu_flags;
+    header_.bpdu_flags = new_bpdu_flags;
 }
 
 void STP::root_path_cost(uint32_t new_root_path_cost) {
-    _header.root_path_cost = Endian::host_to_be(new_root_path_cost);
+    header_.root_path_cost = Endian::host_to_be(new_root_path_cost);
 }
 
 void STP::port_id(uint16_t new_port_id) {
-    _header.port_id = Endian::host_to_be(new_port_id);
+    header_.port_id = Endian::host_to_be(new_port_id);
 }
 
 void STP::msg_age(uint16_t new_msg_age) {
-    _header.msg_age = Endian::host_to_be<uint16_t>(new_msg_age * 256);
+    header_.msg_age = Endian::host_to_be<uint16_t>(new_msg_age * 256);
 }
 
 void STP::max_age(uint16_t new_max_age) {
-    _header.max_age = Endian::host_to_be<uint16_t>(new_max_age * 256);
+    header_.max_age = Endian::host_to_be<uint16_t>(new_max_age * 256);
 }
 
 void STP::hello_time(uint16_t new_hello_time) {
-    _header.hello_time = Endian::host_to_be<uint16_t>(new_hello_time * 256);
+    header_.hello_time = Endian::host_to_be<uint16_t>(new_hello_time * 256);
 }
 
 void STP::fwd_delay(uint16_t new_fwd_delay) {
-    _header.fwd_delay = Endian::host_to_be<uint16_t>(new_fwd_delay * 256);
+    header_.fwd_delay = Endian::host_to_be<uint16_t>(new_fwd_delay * 256);
 }
 
 STP::bpdu_id_type STP::root_id() const {
-    return convert(_header.root_id);
+    return convert(header_.root_id);
 }
 
 STP::bpdu_id_type STP::bridge_id() const {
-    return convert(_header.bridge_id);
+    return convert(header_.bridge_id);
 }
 
-void STP::root_id(const bpdu_id_type &id) {
-    _header.root_id = convert(id);
+void STP::root_id(const bpdu_id_type& id) {
+    header_.root_id = convert(id);
 }
     
-void STP::bridge_id(const bpdu_id_type &id) {
-    _header.bridge_id = convert(id);
+void STP::bridge_id(const bpdu_id_type& id) {
+    header_.bridge_id = convert(id);
 }
 
-void STP::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *) {
+void STP::write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU *) {
     OutputMemoryStream stream(buffer, total_sz);
-    stream.write(_header);
+    stream.write(header_);
 }
 
 uint32_t STP::header_size() const {
-    return sizeof(_header);
+    return sizeof(header_);
 }
 
-STP::bpdu_id_type STP::convert(const pvt_bpdu_id &id) {
+STP::bpdu_id_type STP::convert(const pvt_bpdu_id& id) {
     bpdu_id_type result(id.priority, 0, id.id);
     #if TINS_IS_LITTLE_ENDIAN
     result.ext_id = (id.ext_id << 8) | id.ext_idL;
@@ -125,10 +125,10 @@ STP::bpdu_id_type STP::convert(const pvt_bpdu_id &id) {
     return result;
 }
 
-STP::pvt_bpdu_id STP::convert(const bpdu_id_type &id) {
+STP::pvt_bpdu_id STP::convert(const bpdu_id_type& id) {
     pvt_bpdu_id result;
     result.priority = id.priority;
-    std::copy(id.id.begin(), id.id.end(), result.id);
+    copy(id.id.begin(), id.id.end(), result.id);
     #if TINS_IS_LITTLE_ENDIAN
     result.ext_id = (id.ext_id >> 8) & 0xf;
     result.ext_idL = id.ext_id & 0xff;
@@ -137,5 +137,5 @@ STP::pvt_bpdu_id STP::convert(const bpdu_id_type &id) {
     #endif
     return result;
 }
-}
 
+} // Tins
diff --git a/src/tcp.cpp b/src/tcp.cpp
index bbfaecc..811dd63 100644
--- a/src/tcp.cpp
+++ b/src/tcp.cpp
@@ -40,6 +40,9 @@
 #include "memory_helpers.h"
 
 using std::find_if;
+using std::min;
+using std::vector;
+using std::pair;
 
 using Tins::Memory::InputMemoryStream;
 using Tins::Memory::OutputMemoryStream;
@@ -49,25 +52,23 @@ namespace Tins {
 const uint16_t TCP::DEFAULT_WINDOW = 32678;
 
 TCP::TCP(uint16_t dport, uint16_t sport) 
-: _tcp(), _options_size(0), _total_options_size(0) 
-{
+: header_(), options_size_(0), total_options_size_(0) {
     this->dport(dport);
     this->sport(sport);
-    data_offset(sizeof(tcphdr) / sizeof(uint32_t));
+    data_offset(sizeof(tcp_header) / sizeof(uint32_t));
     window(DEFAULT_WINDOW);
 }
 
-TCP::TCP(const uint8_t *buffer, uint32_t total_sz) 
-: _options_size(0), _total_options_size(0) 
-{
+TCP::TCP(const uint8_t* buffer, uint32_t total_sz) 
+: options_size_(0), total_options_size_(0) {
     InputMemoryStream stream(buffer, total_sz);
-    stream.read(_tcp);
+    stream.read(header_);
     // Check that we have at least the amount of bytes we need and not less
     if (TINS_UNLIKELY(data_offset() * sizeof(uint32_t) > total_sz || 
-                      data_offset() * sizeof(uint32_t) < sizeof(tcphdr))) {
+                      data_offset() * sizeof(uint32_t) < sizeof(tcp_header))) {
         throw malformed_packet();
     }
-    const uint8_t *header_end = buffer + (data_offset() * sizeof(uint32_t));
+    const uint8_t* header_end = buffer + (data_offset() * sizeof(uint32_t));
 
     while (stream.pointer() < header_end) {
         const OptionTypes option_type = (OptionTypes)stream.read<uint8_t>();
@@ -81,7 +82,7 @@ TCP::TCP(const uint8_t *buffer, uint32_t total_sz)
         else {
             // Extract the length
             uint32_t len = stream.read<uint8_t>();
-            const uint8_t *data_start = stream.pointer();
+            const uint8_t* data_start = stream.pointer();
 
             // We need to subtract the option type and length from the size
             if (TINS_UNLIKELY(len < sizeof(uint8_t) << 1)) {
@@ -109,35 +110,35 @@ TCP::TCP(const uint8_t *buffer, uint32_t total_sz)
 }
 
 void TCP::dport(uint16_t new_dport) {
-    _tcp.dport = Endian::host_to_be(new_dport);
+    header_.dport = Endian::host_to_be(new_dport);
 }
 
 void TCP::sport(uint16_t new_sport) {
-    _tcp.sport = Endian::host_to_be(new_sport);
+    header_.sport = Endian::host_to_be(new_sport);
 }
 
 void TCP::seq(uint32_t new_seq) {
-    _tcp.seq = Endian::host_to_be(new_seq);
+    header_.seq = Endian::host_to_be(new_seq);
 }
 
 void TCP::ack_seq(uint32_t new_ack_seq) {
-    _tcp.ack_seq = Endian::host_to_be(new_ack_seq);
+    header_.ack_seq = Endian::host_to_be(new_ack_seq);
 }
 
 void TCP::window(uint16_t new_window) {
-    _tcp.window = Endian::host_to_be(new_window);
+    header_.window = Endian::host_to_be(new_window);
 }
 
 void TCP::checksum(uint16_t new_check) {
-    _tcp.check = Endian::host_to_be(new_check);
+    header_.check = Endian::host_to_be(new_check);
 }
 
 void TCP::urg_ptr(uint16_t new_urg_ptr) {
-    _tcp.urg_ptr = Endian::host_to_be(new_urg_ptr);
+    header_.urg_ptr = Endian::host_to_be(new_urg_ptr);
 }
 
 void TCP::data_offset(small_uint<4> new_doff) {
-    this->_tcp.doff = new_doff;
+    this->header_.doff = new_doff;
 }
 
 void TCP::mss(uint16_t value) {
@@ -165,28 +166,22 @@ bool TCP::has_sack_permitted() const {
     return search_option(SACK_OK) != NULL;
 }
 
-void TCP::sack(const sack_type &edges) {
-    uint32_t *value = 0;
-    if(edges.size()) {
-        value = new uint32_t[edges.size()];
-        uint32_t *ptr = value;
-        for(sack_type::const_iterator it = edges.begin(); it != edges.end(); ++it)
-            *(ptr++) = Endian::host_to_be(*it);
+void TCP::sack(const sack_type& edges) {
+    vector<uint8_t> value(edges.size() * sizeof(uint32_t));
+    if (edges.size()) {
+        OutputMemoryStream stream(value);
+        for (sack_type::const_iterator it = edges.begin(); it != edges.end(); ++it) {
+            stream.write_be(*it);
+        }
     }
-    add_option(
-        option(
-            SACK, 
-            (uint8_t)(sizeof(uint32_t) * edges.size()), 
-            (const uint8_t*)value
-        )
-    );
-    delete[] value;
+    add_option(option(SACK, (uint8_t)value.size(), &value[0]));
 }
 
 TCP::sack_type TCP::sack() const {
-    const option *opt = search_option(SACK);
-    if(!opt) 
+    const option* opt = search_option(SACK);
+    if (!opt) {
         throw option_not_found();
+    }
     return opt->to<sack_type>();
 }
 
@@ -196,11 +191,12 @@ void TCP::timestamp(uint32_t value, uint32_t reply) {
     add_option(option(TSOPT, 8, (uint8_t*)&buffer));
 }
 
-std::pair<uint32_t, uint32_t> TCP::timestamp() const {
-    const option *opt = search_option(TSOPT);
-    if(!opt)
+pair<uint32_t, uint32_t> TCP::timestamp() const {
+    const option* opt = search_option(TSOPT);
+    if (!opt) {
         throw option_not_found();
-    return opt->to<std::pair<uint32_t, uint32_t> >();
+    }
+    return opt->to<pair<uint32_t, uint32_t> >();
 }
 
 void TCP::altchecksum(AltChecksums value) {
@@ -213,30 +209,30 @@ TCP::AltChecksums TCP::altchecksum() const {
 }
 
 small_uint<1> TCP::get_flag(Flags tcp_flag) const {
-    switch(tcp_flag) {
+    switch (tcp_flag) {
         case FIN:
-            return _tcp.flags.fin;
+            return header_.flags.fin;
             break;
         case SYN:
-            return _tcp.flags.syn;
+            return header_.flags.syn;
             break;
         case RST:
-            return _tcp.flags.rst;
+            return header_.flags.rst;
             break;
         case PSH:
-            return _tcp.flags.psh;
+            return header_.flags.psh;
             break;
         case ACK:
-            return _tcp.flags.ack;
+            return header_.flags.ack;
             break;
         case URG:
-            return _tcp.flags.urg;
+            return header_.flags.urg;
             break;
         case ECE:
-            return _tcp.flags.ece;
+            return header_.flags.ece;
             break;
         case CWR:
-            return _tcp.flags.cwr;
+            return header_.flags.cwr;
             break;
         default:
             return 0;
@@ -245,69 +241,69 @@ small_uint<1> TCP::get_flag(Flags tcp_flag) const {
 }
 
 small_uint<12> TCP::flags() const {
-    return (_tcp.res1 << 8) | _tcp.flags_8;
+    return (header_.res1 << 8) | header_.flags_8;
 }
 
 void TCP::set_flag(Flags tcp_flag, small_uint<1> value) {
-    switch(tcp_flag) {
+    switch (tcp_flag) {
         case FIN:
-            _tcp.flags.fin = value;
+            header_.flags.fin = value;
             break;
         case SYN:
-            _tcp.flags.syn = value;
+            header_.flags.syn = value;
             break;
         case RST:
-            _tcp.flags.rst = value;
+            header_.flags.rst = value;
             break;
         case PSH:
-            _tcp.flags.psh = value;
+            header_.flags.psh = value;
             break;
         case ACK:
-            _tcp.flags.ack = value;
+            header_.flags.ack = value;
             break;
         case URG:
-            _tcp.flags.urg = value;
+            header_.flags.urg = value;
             break;
         case ECE:
-            _tcp.flags.ece = value;
+            header_.flags.ece = value;
             break;
         case CWR:
-            _tcp.flags.cwr = value;
+            header_.flags.cwr = value;
             break;
     };
 }
 
 void TCP::flags(small_uint<12> value) {
-    _tcp.res1 = (value >> 8) & 0x0f;
-    _tcp.flags_8 = value & 0xff;
+    header_.res1 = (value >> 8) & 0x0f;
+    header_.flags_8 = value & 0xff;
 }
 
-void TCP::add_option(const option &opt) {
-    _options.push_back(opt);
+void TCP::add_option(const option& opt) {
+    options_.push_back(opt);
     internal_add_option(opt);
 }
 
 uint32_t TCP::header_size() const {
-    return sizeof(tcphdr) + _total_options_size;
+    return sizeof(header_) + total_options_size_;
 }
 
-void TCP::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent) {
+void TCP::write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent) {
     OutputMemoryStream stream(buffer, total_sz);
     // Set checksum to 0, we'll calculate it at the end
     checksum(0);
-    _tcp.doff = (sizeof(tcphdr) + _total_options_size) / sizeof(uint32_t);
-    stream.write(_tcp);
-    for(options_type::const_iterator it = _options.begin(); it != _options.end(); ++it) {
+    header_.doff = (sizeof(tcp_header) + total_options_size_) / sizeof(uint32_t);
+    stream.write(header_);
+    for (options_type::const_iterator it = options_.begin(); it != options_.end(); ++it) {
         write_option(*it, stream);
     }
 
-    if (_options_size < _total_options_size) {
-        const uint16_t padding = _total_options_size - _options_size;
+    if (options_size_ < total_options_size_) {
+        const uint16_t padding = total_options_size_ - options_size_;
         stream.fill(padding, 1);
     }
 
     uint32_t check = 0;
-    if (const Tins::IP *ip_packet = tins_cast<const Tins::IP*>(parent)) {
+    if (const Tins::IP* ip_packet = tins_cast<const Tins::IP*>(parent)) {
         check = Utils::pseudoheader_checksum(
             ip_packet->src_addr(),  
             ip_packet->dst_addr(), 
@@ -315,7 +311,7 @@ void TCP::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *par
             Constants::IP::PROTO_TCP
         ) + Utils::sum_range(buffer, buffer + total_sz);
     }
-    else if (const Tins::IPv6 *ipv6_packet = tins_cast<const Tins::IPv6*>(parent)) {
+    else if (const Tins::IPv6* ipv6_packet = tins_cast<const Tins::IPv6*>(parent)) {
         check = Utils::pseudoheader_checksum(
             ipv6_packet->src_addr(),  
             ipv6_packet->dst_addr(), 
@@ -331,35 +327,35 @@ void TCP::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *par
             check = (check & 0xffff) + (check >> 16);
     }
     checksum(Endian::host_to_be<uint16_t>(~check));
-    ((tcphdr*)buffer)->check = _tcp.check;
+    ((tcp_header*)buffer)->check = header_.check;
 }
 
-const TCP::option *TCP::search_option(OptionTypes type) const {
+const TCP::option* TCP::search_option(OptionTypes type) const {
     // Search for the iterator. If we found something, return it, otherwise return nullptr.
     options_type::const_iterator iter = search_option_iterator(type);
-    return (iter != _options.end()) ? &*iter : 0;
+    return (iter != options_.end()) ? &*iter : 0;
 }
 
 TCP::options_type::const_iterator TCP::search_option_iterator(OptionTypes type) const {
     Internals::option_type_equality_comparator<option> comparator(type);
-    return find_if(_options.begin(), _options.end(), comparator);
+    return find_if(options_.begin(), options_.end(), comparator);
 }
 
 TCP::options_type::iterator TCP::search_option_iterator(OptionTypes type) {
     Internals::option_type_equality_comparator<option> comparator(type);
-    return find_if(_options.begin(), _options.end(), comparator);
+    return find_if(options_.begin(), options_.end(), comparator);
 }
 
 /* options */
 
-void TCP::write_option(const option &opt, OutputMemoryStream& stream) {
+void TCP::write_option(const option& opt, OutputMemoryStream& stream) {
     stream.write<uint8_t>(opt.option());
     // Only do this for non EOL nor NOP options 
-    if(opt.option() > 1) {
+    if (opt.option() > 1) {
         uint8_t length = opt.length_field();
         // Only add the identifier and size field sizes if the length
         // field hasn't been spoofed.
-        if(opt.length_field() == opt.data_size()) {
+        if (opt.length_field() == opt.data_size()) {
             length += (sizeof(uint8_t) << 1);
         }
         stream.write(length);
@@ -368,47 +364,47 @@ void TCP::write_option(const option &opt, OutputMemoryStream& stream) {
 }
 
 void TCP::update_options_size() {
-    uint8_t padding = _options_size & 3;
-    _total_options_size = (padding) ? (_options_size - padding + 4) : _options_size;
+    uint8_t padding = options_size_ & 3;
+    total_options_size_ = (padding) ? (options_size_ - padding + 4) : options_size_;
 }
 
-void TCP::internal_add_option(const option &opt) {
-    _options_size += sizeof(uint8_t);
+void TCP::internal_add_option(const option& opt) {
+    options_size_ += sizeof(uint8_t);
     // SACK_OK contains length but not data....
-    if(opt.data_size() || opt.option() == SACK_OK) {
-        _options_size += sizeof(uint8_t);    
-        _options_size += static_cast<uint16_t>(opt.data_size());
+    if (opt.data_size() || opt.option() == SACK_OK) {
+        options_size_ += sizeof(uint8_t);    
+        options_size_ += static_cast<uint16_t>(opt.data_size());
     }
     update_options_size();
 }
 
 bool TCP::remove_option(OptionTypes type) {
     options_type::iterator iter = search_option_iterator(type);
-    if (iter == _options.end()) {
+    if (iter == options_.end()) {
         return false;
     }
-    _options_size -= sizeof(uint8_t);
+    options_size_ -= sizeof(uint8_t);
     // SACK_OK contains length but not data....
-    if(iter->data_size() || iter->option() == SACK_OK) {
-        _options_size -= sizeof(uint8_t);
-        _options_size -= static_cast<uint16_t>(iter->data_size());
+    if (iter->data_size() || iter->option() == SACK_OK) {
+        options_size_ -= sizeof(uint8_t);
+        options_size_ -= static_cast<uint16_t>(iter->data_size());
     }
-    _options.erase(iter);
+    options_.erase(iter);
     update_options_size();
     return true;
 }
 
-bool TCP::matches_response(const uint8_t *ptr, uint32_t total_sz) const {
-    if(total_sz < sizeof(tcphdr))
+bool TCP::matches_response(const uint8_t* ptr, uint32_t total_sz) const {
+    if (total_sz < sizeof(header_)) {
         return false;
-    const tcphdr *tcp_ptr = (const tcphdr*)ptr;
-    if(tcp_ptr->sport == _tcp.dport && tcp_ptr->dport == _tcp.sport) {
-        uint32_t sz = std::min<uint32_t>(total_sz, tcp_ptr->doff * sizeof(uint32_t));
+    }
+    const tcp_header* tcp_ptr = (const tcp_header*)ptr;
+    if (tcp_ptr->sport == header_.dport && tcp_ptr->dport == header_.sport) {
+        uint32_t sz = min<uint32_t>(total_sz, tcp_ptr->doff * sizeof(uint32_t));
         return inner_pdu() ? inner_pdu()->matches_response(ptr + sz, total_sz - sz) : true;
     }
     else
         return false;
 }
 
-}
-
+} // Tins
diff --git a/src/tcp_stream.cpp b/src/tcp_stream.cpp
index 964fe22..40a0d2e 100644
--- a/src/tcp_stream.cpp
+++ b/src/tcp_stream.cpp
@@ -31,12 +31,15 @@
 #include "rawpdu.h"
 #include "tcp_stream.h"
 
+using std::numeric_limits;
+using std::make_pair;
+
 namespace Tins {
 
 // As defined by RFC 1982 - 2 ^ (SERIAL_BITS - 1)
 static const uint32_t seq_number_diff = 2147483648U;
 // As defined by RFC 1982 - 2 ^ (SERIAL_BITS)
-static const uint32_t addition_modulo = std::numeric_limits<uint32_t>::max();
+static const uint32_t addition_modulo = numeric_limits<uint32_t>::max();
 
 // Sequence number add as defined by RFC 1982
 uint32_t add_sequence_numbers(uint32_t seq1, uint32_t seq2) {
@@ -45,19 +48,22 @@ uint32_t add_sequence_numbers(uint32_t seq1, uint32_t seq2) {
 
 // Subtract sequence numbers
 uint32_t subtract_sequence_numbers(uint32_t seq1, uint32_t seq2) {
-    if(seq1 > seq2)
+    if (seq1 > seq2) {
         return seq1 - seq2;
-    else 
+    }
+    else  {
         // the numbers between seq2 and the maximum sequence number(including seq1)
         // + the numbers between 0 and seq1
-        return (std::numeric_limits<uint32_t>::max() - seq2) + seq1 + 1;
+        return (numeric_limits<uint32_t>::max() - seq2) + seq1 + 1;
+    }
 }
 
 // Compares sequence numbers as defined by RFC 1982.
 int compare_seq_numbers(uint32_t seq1, uint32_t seq2) {
-    if(seq1 == seq2)
+    if (seq1 == seq2) {
         return 0;
-    if(seq1 < seq2) {
+    }
+    if (seq1 < seq2) {
         return (seq2 - seq1 < seq_number_diff) ? -1 : 1;
     }
     else {
@@ -70,84 +76,87 @@ Iterator erase_iterator(Iterator it, Container& cont) {
     Iterator output = it;
     ++output;
     cont.erase(it);
-    if(output == cont.end())
+    if (output == cont.end()) {
         output = cont.begin();
+    }
     return output;
 }
 
 
 // TCPStreamFollower
 
-TCPStreamFollower::TCPStreamFollower() : last_identifier(0) {
+TCPStreamFollower::TCPStreamFollower()
+: last_identifier_(0) {
     
 }
 
 
 
 TCPStream::StreamInfo::StreamInfo(IPv4Address client, 
-  IPv4Address server, uint16_t cport, uint16_t sport) 
+                                  IPv4Address server,
+                                  uint16_t cport,
+                                  uint16_t sport) 
 : client_addr(client), server_addr(server), client_port(cport), 
-  server_port(sport)
-{
-    
+  server_port(sport) {
 }
 
 
 
 
-TCPStream::TCPStream(IP *ip, TCP *tcp, uint64_t identifier) 
-: client_seq(tcp->seq()), server_seq(0), info(ip->src_addr(), 
-  ip->dst_addr(), tcp->sport(), tcp->dport()), identifier(identifier), 
-  syn_ack_sent(false), fin_sent(false)
-{
-    
+TCPStream::TCPStream(IP* ip, TCP* tcp, uint64_t identifier) 
+: client_seq_(tcp->seq()), server_seq_(0), info_(ip->src_addr(), 
+  ip->dst_addr(), tcp->sport(), tcp->dport()), identifier_(identifier), 
+  syn_ack_sent_(false), fin_sent_(false) {
 }
 
-TCPStream::TCPStream(const TCPStream &rhs) {
+TCPStream::TCPStream(const TCPStream& rhs) {
     *this = rhs;
 }
 
-TCPStream& TCPStream::operator=(const TCPStream &rhs) {
-    client_seq = rhs.client_seq;
-    server_seq = rhs.server_seq;
-    info = rhs.info;
-    identifier = rhs.identifier;
-    syn_ack_sent = rhs.syn_ack_sent;
-    fin_sent = rhs.fin_sent;
+TCPStream& TCPStream::operator=(const TCPStream& rhs) {
+    client_seq_ = rhs.client_seq_;
+    server_seq_ = rhs.server_seq_;
+    info_ = rhs.info_;
+    identifier_ = rhs.identifier_;
+    syn_ack_sent_ = rhs.syn_ack_sent_;
+    fin_sent_ = rhs.fin_sent_;
     client_payload_ = rhs.client_payload_;
     server_payload_ = rhs.server_payload_;
-    client_frags = clone_fragments(rhs.client_frags);
-    server_frags = clone_fragments(rhs.server_frags);
-    return *this;
+    client_frags_ = clone_fragments(rhs.client_frags_);
+    server_frags_ = clone_fragments(rhs.server_frags_);
+    return* this;
 }
 
 TCPStream::~TCPStream() {
-    free_fragments(client_frags);
-    free_fragments(server_frags);
+    free_fragments(client_frags_);
+    free_fragments(server_frags_);
 }
 
-void TCPStream::free_fragments(fragments_type &frags) {
-    for(fragments_type::iterator it = frags.begin(); it != frags.end(); ++it)
+void TCPStream::free_fragments(fragments_type& frags) {
+    for (fragments_type::iterator it = frags.begin(); it != frags.end(); ++it) {
         delete it->second;
+    }
 }
 
-TCPStream::fragments_type TCPStream::clone_fragments(const fragments_type &frags) {
+TCPStream::fragments_type TCPStream::clone_fragments(const fragments_type& frags) {
     fragments_type new_frags;
-    for(fragments_type::const_iterator it = frags.begin(); it != frags.end(); ++it)
-        new_frags.insert(std::make_pair(it->first, it->second->clone()));
+    for (fragments_type::const_iterator it = frags.begin(); it != frags.end(); ++it) {
+        new_frags.insert(make_pair(it->first, it->second->clone()));
+    }
     return new_frags;
 }
 
-void TCPStream::safe_insert(fragments_type &frags, uint32_t seq, RawPDU *raw)
-{
+void TCPStream::safe_insert(fragments_type& frags, uint32_t seq, RawPDU* raw) {
     RawPDU*& stored_raw = frags[seq];
     // New segment, insert it
-    if(stored_raw == 0)
+    if (stored_raw == 0) {
         stored_raw = raw;
+    }
     else {
         // There was a segment in this position. Keep the largest one.
-        if(stored_raw->payload_size() > raw->payload_size())
+        if (stored_raw->payload_size() > raw->payload_size()) {
             delete raw;
+        }
         else {
             delete stored_raw;
             stored_raw = raw;
@@ -155,20 +164,23 @@ void TCPStream::safe_insert(fragments_type &frags, uint32_t seq, RawPDU *raw)
     }
 }
 
-bool TCPStream::generic_process(uint32_t &my_seq, uint32_t &other_seq, 
-  payload_type &pload, fragments_type &frags, TCP *tcp) 
-{
+bool TCPStream::generic_process(uint32_t& my_seq,
+                                uint32_t& other_seq, 
+                                payload_type& pload,
+                                fragments_type& frags,
+                                TCP* tcp) {
     bool added_some(false);
-    if(tcp->get_flag(TCP::FIN) || tcp->get_flag(TCP::RST))
-        fin_sent = true;
-    RawPDU *raw = static_cast<RawPDU*>(tcp->release_inner_pdu()); 
-    if(raw) {
+    if (tcp->get_flag(TCP::FIN) || tcp->get_flag(TCP::RST)) {
+        fin_sent_ = true;
+    }
+    RawPDU* raw = static_cast<RawPDU*>(tcp->release_inner_pdu()); 
+    if (raw) {
         const uint32_t chunk_end = add_sequence_numbers(tcp->seq(), raw->payload_size());
         // If the end of the chunk ends after our current sequence number, process it.
-        if(compare_seq_numbers(chunk_end, my_seq) >= 0) {
+        if (compare_seq_numbers(chunk_end, my_seq) >= 0) {
             uint32_t seq = tcp->seq();
             // If it starts before our sequence number, slice it
-            if(compare_seq_numbers(seq, my_seq) < 0) {
+            if (compare_seq_numbers(seq, my_seq) < 0) {
                 const uint32_t diff = subtract_sequence_numbers(my_seq, seq);
                 raw->payload().erase(
                     raw->payload().begin(),
@@ -179,13 +191,13 @@ bool TCPStream::generic_process(uint32_t &my_seq, uint32_t &other_seq,
             safe_insert(frags, seq, raw);
             fragments_type::iterator it = frags.find(my_seq);
             // Keep looping while the fragments seq is lower or equal to our seq
-            while(it != frags.end() && compare_seq_numbers(it->first, my_seq) <= 0) {
+            while (it != frags.end() && compare_seq_numbers(it->first, my_seq) <= 0) {
                 // Does this fragment start before our sequence number?
-                if(compare_seq_numbers(it->first, my_seq) < 0) {
+                if (compare_seq_numbers(it->first, my_seq) < 0) {
                     uint32_t fragment_end = add_sequence_numbers(it->first, it->second->payload_size());
                     int comparison = compare_seq_numbers(fragment_end, my_seq);
                     // Does it end after our sequence number? 
-                    if(comparison > 0) {
+                    if (comparison > 0) {
                         // Then slice it
                         RawPDU::payload_type& payload = it->second->payload();
                         payload.erase(
@@ -212,48 +224,55 @@ bool TCPStream::generic_process(uint32_t &my_seq, uint32_t &other_seq,
                     delete it->second;
                     it = erase_iterator(it, frags);
                     added_some = true;
-                    if(frags.empty())
+                    if (frags.empty()) {
                         break;
+                    }
                 }
             }
         }
-        else
+        else {
             delete raw;
+        }
     }
     return added_some;
 }
 
-bool TCPStream::update(IP *ip, TCP *tcp) {
-    if(!syn_ack_sent) {
-        if(tcp->flags() == (TCP::SYN | TCP::ACK)) {
-            server_seq = tcp->seq() + 1;
-            client_seq = tcp->ack_seq();
-            syn_ack_sent = true;
+bool TCPStream::update(IP* ip, TCP* tcp) {
+    if (!syn_ack_sent_) {
+        if (tcp->flags() == (TCP::SYN | TCP::ACK)) {
+            server_seq_ = tcp->seq() + 1;
+            client_seq_ = tcp->ack_seq();
+            syn_ack_sent_ = true;
         }
         return false;
     }
     else {
-        if(ip->src_addr() == info.client_addr && tcp->sport() == info.client_port)
-            return generic_process(client_seq, server_seq, client_payload_, client_frags, tcp);
+        if (ip->src_addr() == info_.client_addr && tcp->sport() == info_.client_port) {
+            return generic_process(client_seq_, server_seq_, client_payload_, client_frags_, tcp);
+        }
         else {
-            return generic_process(server_seq, client_seq, server_payload_, server_frags, tcp);
+            return generic_process(server_seq_, client_seq_, server_payload_, server_frags_, tcp);
         }
     }
 }
 
-bool TCPStream::StreamInfo::operator<(const StreamInfo &rhs) const {
-    if(client_addr == rhs.client_addr) {
-        if(server_addr == rhs.server_addr) {
-            if(client_port == rhs.client_port) {
+bool TCPStream::StreamInfo::operator<(const StreamInfo& rhs) const {
+    if (client_addr == rhs.client_addr) {
+        if (server_addr == rhs.server_addr) {
+            if (client_port == rhs.client_port) {
                 return server_port < rhs.server_port;
             }
-            else
+            else {
                 return client_port < rhs.client_port;
+            }
         }
-        else
+        else {
             return server_addr < rhs.server_addr;
+        }
     }
-    else
+    else {
         return client_addr < rhs.client_addr;
+    }
 }
-}
+
+} // Tins
diff --git a/src/udp.cpp b/src/udp.cpp
index 525aa57..9561b64 100644
--- a/src/udp.cpp
+++ b/src/udp.cpp
@@ -43,50 +43,49 @@ using Tins::Memory::OutputMemoryStream;
 
 namespace Tins {
 
-UDP::UDP(uint16_t dport, uint16_t sport) : _udp()
-{
+UDP::UDP(uint16_t dport, uint16_t sport)
+: header_() {
     this->dport(dport);
     this->sport(sport);
 }
 
-UDP::UDP(const uint8_t *buffer, uint32_t total_sz) 
-{
+UDP::UDP(const uint8_t* buffer, uint32_t total_sz)  {
     InputMemoryStream stream(buffer, total_sz);
-    stream.read(_udp);
+    stream.read(header_);
     if (stream) {
         inner_pdu(new RawPDU(stream.pointer(), stream.size()));
     }
 }
 
 void UDP::dport(uint16_t new_dport) {
-    _udp.dport = Endian::host_to_be(new_dport);
+    header_.dport = Endian::host_to_be(new_dport);
 }
 
 void UDP::sport(uint16_t new_sport) {
-    _udp.sport = Endian::host_to_be(new_sport);
+    header_.sport = Endian::host_to_be(new_sport);
 }
 
 void UDP::length(uint16_t new_len) {
-    _udp.len = Endian::host_to_be(new_len);
+    header_.len = Endian::host_to_be(new_len);
 }
 
 uint32_t UDP::header_size() const {
-    return sizeof(udphdr);
+    return sizeof(udp_header);
 }
 
-uint32_t sum_range(const uint8_t *start, const uint8_t *end) {
+uint32_t sum_range(const uint8_t* start, const uint8_t* end) {
     uint32_t checksum(0);
-    const uint8_t *last = end;
+    const uint8_t* last = end;
     uint16_t buffer = 0;
     uint16_t padding = 0;
-    const uint8_t *ptr = start;
+    const uint8_t* ptr = start;
 
-    if(((end - start) & 1) == 1) {
+    if (((end - start) & 1) == 1) {
         last = end - 1;
         padding = Endian::host_to_le<uint16_t>(*(end - 1));
     }
 
-    while(ptr < last) {
+    while (ptr < last) {
         memcpy(&buffer, ptr, sizeof(uint16_t));
         checksum += buffer;
         ptr += sizeof(uint16_t);
@@ -104,26 +103,26 @@ uint32_t pseudoheader_checksum(IPv4Address source_ip, IPv4Address dest_ip, uint3
     stream.write(dest_ip);
     stream.write(Endian::host_to_be<uint16_t>(flag));
     stream.write(Endian::host_to_be<uint16_t>(len));
-    uint16_t *ptr = (uint16_t*)buffer, *end = (uint16_t*)(buffer + sizeof(buffer));
+    uint16_t* ptr = (uint16_t*)buffer, *end = (uint16_t*)(buffer + sizeof(buffer));
     while (ptr < end) {
         checksum += *ptr++;
     }
     return checksum;
 }
 
-void UDP::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent) {
+void UDP::write_serialization(uint8_t* buffer, uint32_t total_sz, const PDU* parent) {
     OutputMemoryStream stream(buffer, total_sz);
     // Set checksum to 0, we'll calculate it at the end
-    _udp.check = 0;
-    if(inner_pdu()) {
-        length(static_cast<uint16_t>(sizeof(udphdr) + inner_pdu()->size()));
+    header_.check = 0;
+    if (inner_pdu()) {
+        length(static_cast<uint16_t>(sizeof(udp_header) + inner_pdu()->size()));
     }
     else {
-        length(static_cast<uint16_t>(sizeof(udphdr)));
+        length(static_cast<uint16_t>(sizeof(udp_header)));
     }
-    stream.write(_udp);
+    stream.write(header_);
     uint32_t checksum = 0;
-    if (const Tins::IP *ip_packet = tins_cast<const Tins::IP*>(parent)) {
+    if (const Tins::IP* ip_packet = tins_cast<const Tins::IP*>(parent)) {
         checksum = Utils::pseudoheader_checksum(
             ip_packet->src_addr(), 
             ip_packet->dst_addr(), 
@@ -131,7 +130,7 @@ void UDP::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *par
             Constants::IP::PROTO_UDP
         ) + Utils::sum_range(buffer, buffer + total_sz);
     }
-    else if (const Tins::IPv6 *ip6_packet = tins_cast<const Tins::IPv6*>(parent)) {
+    else if (const Tins::IPv6* ip6_packet = tins_cast<const Tins::IPv6*>(parent)) {
         checksum = Utils::pseudoheader_checksum(
             ip6_packet->src_addr(), 
             ip6_packet->dst_addr(), 
@@ -145,27 +144,29 @@ void UDP::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *par
     while (checksum >> 16) {
         checksum = (checksum & 0xffff)+(checksum >> 16);
     }
-    _udp.check = ~checksum;
+    header_.check = ~checksum;
     // If checksum is 0, it has to be set to 0xffff
-    _udp.check = (_udp.check == 0) ? 0xffff : _udp.check;
-    ((udphdr*)buffer)->check = _udp.check;
+    header_.check = (header_.check == 0) ? 0xffff : header_.check;
+    ((udp_header*)buffer)->check = header_.check;
 }
 
-bool UDP::matches_response(const uint8_t *ptr, uint32_t total_sz) const {
-    if(total_sz < sizeof(udphdr))
+bool UDP::matches_response(const uint8_t* ptr, uint32_t total_sz) const {
+    if (total_sz < sizeof(udp_header)) {
         return false;
-    const udphdr *udp_ptr = (const udphdr*)ptr;
-    if(udp_ptr->sport == _udp.dport && udp_ptr->dport == _udp.sport) {
-        return inner_pdu() 
-                ? 
-                inner_pdu()->matches_response(
-                    ptr + sizeof(udphdr), 
-                    total_sz - sizeof(udphdr)
-                ) 
-                : 
-                0;
+    }
+    const udp_header* udp_ptr = (const udp_header*)ptr;
+    if (udp_ptr->sport == header_.dport && udp_ptr->dport == header_.sport) {
+        if (inner_pdu()) { 
+            return inner_pdu()->matches_response(
+                ptr + sizeof(udp_header), 
+                total_sz - sizeof(udp_header)
+            );
+        }
+        else {
+            return 0;
+        }
     }
     return false;
 }
 
-}
+} // Tins
diff --git a/src/utils.cpp b/src/utils.cpp
index 4fe9e57..52fcdb8 100644
--- a/src/utils.cpp
+++ b/src/utils.cpp
@@ -58,8 +58,13 @@
 #include "cxxstd.h"
 #include "memory_helpers.h"
 
-using namespace std;
+using std::string;
+using std::set;
+using std::vector;
+using std::back_inserter;
+using std::runtime_error;
 
+using Tins::Memory::InputMemoryStream;
 using Tins::Memory::OutputMemoryStream;
 
 /** \cond */
@@ -72,22 +77,23 @@ struct InterfaceCollector {
         return false;
     }
     #else
-    bool operator() (struct ifaddrs *addr) {
+    bool operator() (struct ifaddrs* addr) {
         ifaces.insert(addr->ifa_name);
         return false;
     }
     #endif
 };
 
-addrinfo *resolve_domain(const std::string &to_resolve, int family) {
-    addrinfo *result, hints = addrinfo();
+addrinfo* resolve_domain(const string& to_resolve, int family) {
+    addrinfo* result, hints = addrinfo();
     hints.ai_socktype = SOCK_STREAM;
     hints.ai_protocol = IPPROTO_TCP;
     hints.ai_family = family;
-    if(!getaddrinfo(to_resolve.c_str(), 0, &hints, &result)) 
+    if (!getaddrinfo(to_resolve.c_str(), 0, &hints, &result)) {
         return result;
+    }
     else {
-        throw std::runtime_error("Could not resolve address");
+        throw runtime_error("Could not resolve address");
     }
 }
 
@@ -96,51 +102,53 @@ namespace Tins {
 /** \endcond */
 namespace Utils {
 
-IPv4Address resolve_domain(const std::string &to_resolve) {
-    addrinfo *result = ::resolve_domain(to_resolve, AF_INET);
+IPv4Address resolve_domain(const string& to_resolve) {
+    addrinfo* result = ::resolve_domain(to_resolve, AF_INET);
     IPv4Address addr(((sockaddr_in*)result->ai_addr)->sin_addr.s_addr);
     freeaddrinfo(result);
     return addr;
 }
 
-IPv6Address resolve_domain6(const std::string &to_resolve) {
-    addrinfo *result = ::resolve_domain(to_resolve, AF_INET6);
+IPv6Address resolve_domain6(const string& to_resolve) {
+    addrinfo* result = ::resolve_domain(to_resolve, AF_INET6);
     IPv6Address addr((const uint8_t*)&((sockaddr_in6*)result->ai_addr)->sin6_addr);
     freeaddrinfo(result);
     return addr;
 }
 
-HWAddress<6> resolve_hwaddr(const NetworkInterface &iface, IPv4Address ip, PacketSender &sender) 
-{
+HWAddress<6> resolve_hwaddr(const NetworkInterface& iface,
+                            IPv4Address ip,
+                            PacketSender& sender) {
     IPv4Address my_ip;
     NetworkInterface::Info info(iface.addresses());
     EthernetII packet = ARP::make_arp_request(ip, info.ip_addr, info.hw_addr);
     Internals::smart_ptr<PDU>::type response(sender.send_recv(packet, iface));
-    if(response.get()) {
-        const ARP *arp_resp = response->find_pdu<ARP>();
-        if(arp_resp)
+    if (response.get()) {
+        const ARP* arp_resp = response->find_pdu<ARP>();
+        if (arp_resp) {
             return arp_resp->sender_hw_addr();
+        }
     }
-    throw std::runtime_error("Could not resolve hardware address");
+    throw runtime_error("Could not resolve hardware address");
 }
 
-HWAddress<6> resolve_hwaddr(IPv4Address ip, PacketSender &sender) {
+HWAddress<6> resolve_hwaddr(IPv4Address ip, PacketSender& sender) {
     return resolve_hwaddr(sender.default_interface(), ip, sender);
 }
 
-std::vector<RouteEntry> route_entries() {
-    std::vector<RouteEntry> entries;
-    route_entries(std::back_inserter(entries));
+vector<RouteEntry> route_entries() {
+    vector<RouteEntry> entries;
+    route_entries(back_inserter(entries));
     return entries;
 }
 
-bool gateway_from_ip(IPv4Address ip, IPv4Address &gw_addr) {
-    typedef std::vector<RouteEntry> entries_type;
+bool gateway_from_ip(IPv4Address ip, IPv4Address& gw_addr) {
+    typedef vector<RouteEntry> entries_type;
     entries_type entries;
     uint32_t ip_int = ip;
-    route_entries(std::back_inserter(entries));
-    for(entries_type::const_iterator it(entries.begin()); it != entries.end(); ++it) {
-        if((ip_int & it->mask) == it->destination) {
+    route_entries(back_inserter(entries));
+    for (entries_type::const_iterator it(entries.begin()); it != entries.end(); ++it) {
+        if ((ip_int & it->mask) == it->destination) {
             gw_addr = it->gateway;
             return true;
         }
@@ -162,9 +170,9 @@ uint16_t mhz_to_channel(uint16_t mhz) {
     return (mhz - 2407) / 5;
 }
     
-std::string to_string(PDU::PDUType pduType) {
+string to_string(PDU::PDUType pduType) {
 #define ENUM_TEXT(p) case(PDU::p): return #p;
-    switch(pduType){
+    switch (pduType){
         ENUM_TEXT(RAW);
         ENUM_TEXT(ETHERNET_II);
         ENUM_TEXT(IEEE802_3);
@@ -215,29 +223,32 @@ std::string to_string(PDU::PDUType pduType) {
         ENUM_TEXT(PPI);
         ENUM_TEXT(IPSEC_AH);
         ENUM_TEXT(IPSEC_ESP);
+        ENUM_TEXT(PKTAP);
+        ENUM_TEXT(MPLS);
         ENUM_TEXT(USER_DEFINED_PDU);
-        default: return "";
+        default: 
+            return "";
     }
 #undef ENUM_TEXT
 }
 
-uint32_t do_checksum(const uint8_t *start, const uint8_t *end) {
+uint32_t do_checksum(const uint8_t* start, const uint8_t* end) {
     return Endian::host_to_be<uint32_t>(sum_range(start, end));
 }
 
-uint16_t sum_range(const uint8_t *start, const uint8_t *end) {
+uint16_t sum_range(const uint8_t* start, const uint8_t* end) {
     uint32_t checksum(0);
-    const uint8_t *last = end;
+    const uint8_t* last = end;
     uint16_t buffer = 0;
     uint16_t padding = 0;
-    const uint8_t *ptr = start;
+    const uint8_t* ptr = start;
 
-    if(((end - start) & 1) == 1) {
+    if (((end - start) & 1) == 1) {
         last = end - 1;
         padding = Endian::host_to_le<uint16_t>(*(end - 1));
     }
 
-    while(ptr < last) {
+    while (ptr < last) {
         memcpy(&buffer, ptr, sizeof(uint16_t));
         checksum += buffer;
         ptr += sizeof(uint16_t);
@@ -251,9 +262,10 @@ uint16_t sum_range(const uint8_t *start, const uint8_t *end) {
 }
 
 template <size_t buffer_size, typename AddressType>
-uint32_t generic_pseudoheader_checksum(const AddressType& source_ip, const AddressType& dest_ip,
-    uint16_t len, uint16_t flag) {
-    uint32_t checksum(0);
+uint32_t generic_pseudoheader_checksum(const AddressType& source_ip, 
+                                       const AddressType& dest_ip,
+                                       uint16_t len,
+                                       uint16_t flag) {
     uint8_t buffer[buffer_size];
     OutputMemoryStream stream(buffer, sizeof(buffer));
     stream.write(source_ip);
@@ -261,20 +273,27 @@ uint32_t generic_pseudoheader_checksum(const AddressType& source_ip, const Addre
     stream.write(Endian::host_to_be(flag));
     stream.write(Endian::host_to_be(len));
 
-    uint16_t *ptr = (uint16_t*)buffer, *end = (uint16_t*)(buffer + sizeof(buffer));
-    while (ptr < end) {
-        checksum += *ptr++;
+    InputMemoryStream input_stream(buffer, sizeof(buffer));
+    uint32_t checksum = 0;
+    while (input_stream) {
+        checksum += input_stream.read<uint16_t>();
     }
     return checksum;
 }
 
-uint32_t pseudoheader_checksum(IPv4Address source_ip, IPv4Address dest_ip, uint16_t len, uint16_t flag) {
+uint32_t pseudoheader_checksum(IPv4Address source_ip, 
+                               IPv4Address dest_ip,
+                               uint16_t len,
+                               uint16_t flag) {
     return generic_pseudoheader_checksum<sizeof(uint32_t) * 3>(
         source_ip, dest_ip, len, flag
     );
 }
 
-uint32_t pseudoheader_checksum(IPv6Address source_ip, IPv6Address dest_ip, uint16_t len, uint16_t flag) {
+uint32_t pseudoheader_checksum(IPv6Address source_ip,
+                               IPv6Address dest_ip,
+                               uint16_t len,
+                               uint16_t flag) {
     return generic_pseudoheader_checksum<IPv6Address::address_size * 2 + sizeof(uint16_t) * 2>(
         source_ip, dest_ip, len, flag
     );
@@ -296,5 +315,6 @@ uint32_t crc32(const uint8_t* data, uint32_t data_size) {
 
     return crc;
 }
-}
-}
+
+} // Utils
+} // Tins
diff --git a/tests/include/tests/dot11.h b/tests/include/tests/dot11.h
index 9301554..affb369 100644
--- a/tests/include/tests/dot11.h
+++ b/tests/include/tests/dot11.h
@@ -7,7 +7,7 @@ using Tins::Dot11;
 
 typedef Dot11::address_type address_type;
 
-inline void test_equals(const Dot11 &dot1, const Dot11 &dot2) {
+inline void test_equals(const Dot11& dot1, const Dot11& dot2) {
     EXPECT_EQ(dot1.protocol(), dot2.protocol());
     EXPECT_EQ(dot1.type(), dot2.type());
     EXPECT_EQ(dot1.subtype(), dot2.subtype());
@@ -22,7 +22,7 @@ inline void test_equals(const Dot11 &dot1, const Dot11 &dot2) {
     EXPECT_EQ(dot1.addr1(), dot2.addr1());
 }
 
-inline void test_equals_empty(const Dot11 &dot11) {
+inline void test_equals_empty(const Dot11& dot11) {
     Dot11::address_type empty_addr;
     
     EXPECT_EQ(dot11.protocol(), 0);
diff --git a/tests/include/tests/dot11_control.h b/tests/include/tests/dot11_control.h
index 83afad8..808677c 100644
--- a/tests/include/tests/dot11_control.h
+++ b/tests/include/tests/dot11_control.h
@@ -12,12 +12,12 @@ inline void test_equals(const Dot11ControlTA& b1, const Dot11ControlTA& b2) {
 }
 
 
-inline void test_equals_expected(const Dot11ControlTA &dot11) {
+inline void test_equals_expected(const Dot11ControlTA& dot11) {
     EXPECT_EQ(dot11.target_addr(), "01:02:03:04:05:06");
     EXPECT_EQ(dot11.addr1(), "00:01:02:03:04:05");
 }
 
-inline void test_equals_empty(const Dot11ControlTA &dot11) {
+inline void test_equals_empty(const Dot11ControlTA& dot11) {
     Dot11::address_type empty_addr;
     
     EXPECT_EQ(dot11.target_addr(), empty_addr);
diff --git a/tests/include/tests/dot11_data.h b/tests/include/tests/dot11_data.h
index 3671fcb..3c0d430 100644
--- a/tests/include/tests/dot11_data.h
+++ b/tests/include/tests/dot11_data.h
@@ -16,7 +16,7 @@ inline void test_equals(const Dot11Data& b1, const Dot11Data& b2) {
     test_equals(static_cast<const Dot11&>(b1), static_cast<const Dot11&>(b2));
 }
 
-inline void test_equals_expected(const Dot11Data &dot11) {
+inline void test_equals_expected(const Dot11Data& dot11) {
     EXPECT_EQ(dot11.type(), Dot11::DATA);
     EXPECT_EQ(dot11.addr1(), "00:01:02:03:04:05");
     EXPECT_EQ(dot11.addr2(), "01:02:03:04:05:06");
@@ -25,7 +25,7 @@ inline void test_equals_expected(const Dot11Data &dot11) {
     EXPECT_EQ(dot11.seq_num(), 0xf1d);
 }
 
-inline void test_equals_empty(const Dot11Data &dot11) {
+inline void test_equals_empty(const Dot11Data& dot11) {
     Dot11::address_type empty_addr;
     
     EXPECT_EQ(dot11.addr1(), empty_addr);
diff --git a/tests/include/tests/dot11_mgmt.h b/tests/include/tests/dot11_mgmt.h
index 5e51458..bdf5bf4 100644
--- a/tests/include/tests/dot11_mgmt.h
+++ b/tests/include/tests/dot11_mgmt.h
@@ -18,7 +18,7 @@ inline void test_equals(const Dot11ManagementFrame& b1, const Dot11ManagementFra
     test_equals(static_cast<const Dot11&>(b1), static_cast<const Dot11&>(b2));
 }
 
-inline void test_equals_expected(const Dot11ManagementFrame &dot11) {
+inline void test_equals_expected(const Dot11ManagementFrame& dot11) {
     EXPECT_EQ(dot11.protocol(), 1);
     EXPECT_EQ(dot11.type(), Dot11::MANAGEMENT);
     EXPECT_EQ(dot11.to_ds(), 1);
@@ -34,7 +34,7 @@ inline void test_equals_expected(const Dot11ManagementFrame &dot11) {
     EXPECT_EQ(dot11.addr3(), "02:03:04:05:06:07");
 }
 
-inline void test_equals_empty(const Dot11ManagementFrame &dot11) {
+inline void test_equals_empty(const Dot11ManagementFrame& dot11) {
     Dot11::address_type empty_addr;
     
     EXPECT_EQ(dot11.type(), Dot11::MANAGEMENT);
@@ -48,7 +48,7 @@ inline void test_equals_empty(const Dot11ManagementFrame &dot11) {
 }
 
 
-inline void test_equals(const capability_information &info1, const capability_information &info2) {
+inline void test_equals(const capability_information& info1, const capability_information& info2) {
      EXPECT_EQ(info1.ess(), info2.ess());
      EXPECT_EQ(info1.ibss(), info2.ibss());
      EXPECT_EQ(info1.cf_poll(), info2.cf_poll());
@@ -67,7 +67,7 @@ inline void test_equals(const capability_information &info1, const capability_in
      EXPECT_EQ(info1.immediate_block_ack(), info2.immediate_block_ack());
 }
 
-inline void test_equals_empty(const capability_information &info) {
+inline void test_equals_empty(const capability_information& info) {
     EXPECT_EQ(info.ess(), false);
     EXPECT_EQ(info.ibss(), false);
     EXPECT_EQ(info.cf_poll(), false);
diff --git a/tests/src/address_range.cpp b/tests/src/address_range.cpp
index 68a3dff..2b8baaa 100644
--- a/tests/src/address_range.cpp
+++ b/tests/src/address_range.cpp
@@ -12,12 +12,12 @@ using namespace Tins;
 
 class AddressRangeTest : public testing::Test {
 public:
-    void contain_tests24(const IPv4Range &range);
-    void contain_tests24(const IPv6Range &range);
-    void contain_tests26(const IPv4Range &range);
+    void contain_tests24(const IPv4Range& range);
+    void contain_tests24(const IPv6Range& range);
+    void contain_tests26(const IPv4Range& range);
 };
 
-void AddressRangeTest::contain_tests24(const IPv4Range &range) {
+void AddressRangeTest::contain_tests24(const IPv4Range& range) {
     EXPECT_TRUE(range.contains("192.168.0.0"));
     EXPECT_TRUE(range.contains("192.168.0.1"));
     EXPECT_TRUE(range.contains("192.168.0.254"));
@@ -26,14 +26,14 @@ void AddressRangeTest::contain_tests24(const IPv4Range &range) {
     EXPECT_FALSE(range.contains("192.168.1.1"));
 }
 
-void AddressRangeTest::contain_tests26(const IPv4Range &range) {
+void AddressRangeTest::contain_tests26(const IPv4Range& range) {
     EXPECT_TRUE(range.contains("192.168.254.192"));
     EXPECT_TRUE(range.contains("192.168.254.255"));
     EXPECT_FALSE(range.contains("192.168.254.0"));
     EXPECT_FALSE(range.contains("192.168.254.191"));
 }
 
-void AddressRangeTest::contain_tests24(const IPv6Range &range) {
+void AddressRangeTest::contain_tests24(const IPv6Range& range) {
     EXPECT_TRUE(range.contains("dead::1"));
     EXPECT_TRUE(range.contains("dead::1fee"));
     EXPECT_TRUE(range.contains("dead::ffee"));
diff --git a/tests/src/allocators.cpp b/tests/src/allocators.cpp
index 18ba6d7..e298f8c 100644
--- a/tests/src/allocators.cpp
+++ b/tests/src/allocators.cpp
@@ -49,10 +49,10 @@ public:
     static const PDU::PDUType pdu_flag;
 
     DummyPDU(const uint8_t* data, uint32_t sz) : buffer(data, data + sz) { }
-    DummyPDU *clone() const { return new DummyPDU<n>(*this); }
+    DummyPDU* clone() const { return new DummyPDU<n>(*this); }
     uint32_t header_size() const { return (uint32_t)buffer.size(); }
     PDUType pdu_type() const { return pdu_flag; }
-    void write_serialization(uint8_t *data, uint32_t, const PDU *) 
+    void write_serialization(uint8_t* data, uint32_t, const PDU *) 
     { 
         std::copy(buffer.begin(), buffer.end(), data);
     }
diff --git a/tests/src/arp.cpp b/tests/src/arp.cpp
index 6d0f55a..036d8e4 100644
--- a/tests/src/arp.cpp
+++ b/tests/src/arp.cpp
@@ -22,7 +22,7 @@ public:
     static const uint8_t expected_packet[];
     static const IPv4Address addr1, addr2;
 
-    void test_equals(const ARP &arp1, const ARP &arp2);
+    void test_equals(const ARP& arp1, const ARP& arp2);
 };
 
 const address_type ARPTest::empty_addr;
@@ -34,7 +34,7 @@ const uint8_t ARPTest::expected_packet[] = {
 };
 const IPv4Address ARPTest::addr1(0x1234), ARPTest::addr2(0xa3f1);
 
-void ARPTest::test_equals(const ARP &arp1, const ARP &arp2) {
+void ARPTest::test_equals(const ARP& arp1, const ARP& arp2) {
     EXPECT_EQ(arp1.opcode(), arp2.opcode());
     ASSERT_EQ(arp1.hw_addr_length(), arp2.hw_addr_length());
     EXPECT_EQ(arp1.hw_addr_format(), arp2.hw_addr_format());
@@ -69,7 +69,7 @@ TEST_F(ARPTest, CopyAssignmentOperator) {
 }
 
 TEST_F(ARPTest, NestedCopy) {
-    ARP *nested_arp = new ARP(addr1, addr2, hw_addr1, hw_addr2);
+    ARP* nested_arp = new ARP(addr1, addr2, hw_addr1, hw_addr2);
     ARP arp1(addr1, addr2, hw_addr1, hw_addr2);
     arp1.inner_pdu(nested_arp);
     ARP arp2(arp1);
diff --git a/tests/src/dhcp.cpp b/tests/src/dhcp.cpp
index ee925d7..2fee7a8 100644
--- a/tests/src/dhcp.cpp
+++ b/tests/src/dhcp.cpp
@@ -20,8 +20,8 @@ public:
     static const uint8_t sname[], file[];
     static const IPv4Address addr;
 
-    void test_equals(const DHCP &dhcp1, const DHCP &dhcp2);
-    void test_option(const DHCP &dhcp, DHCP::OptionTypes opt, uint32_t len = 0, uint8_t *value = 0);
+    void test_equals(const DHCP& dhcp1, const DHCP& dhcp2);
+    void test_option(const DHCP& dhcp, DHCP::OptionTypes opt, uint32_t len = 0, uint8_t* value = 0);
 };
 
 const BootP::chaddr_type DHCPTest::chaddr("16:ab:54:12:fa:ca:56:7f:1b:65:11:fa:da:ab:19:18");
@@ -167,8 +167,8 @@ TEST_F(DHCPTest, File) {
     EXPECT_TRUE(memcmp(dhcp.file(), file, 128) == 0);
 }
 
-void DHCPTest::test_option(const DHCP &dhcp, DHCP::OptionTypes opt, uint32_t len, uint8_t *value) {
-    const DHCP::option *option = dhcp.search_option(opt);
+void DHCPTest::test_option(const DHCP& dhcp, DHCP::OptionTypes opt, uint32_t len, uint8_t* value) {
+    const DHCP::option* option = dhcp.search_option(opt);
     ASSERT_TRUE(option != 0);
     EXPECT_EQ(option->option(), opt);
     ASSERT_EQ(option->data_size(), len);
@@ -244,7 +244,7 @@ TEST_F(DHCPTest, BroadcastOption) {
     EXPECT_EQ(ip, dhcp.broadcast());
 }
 
-void DHCPTest::test_equals(const DHCP &dhcp1, const DHCP &dhcp2) {
+void DHCPTest::test_equals(const DHCP& dhcp1, const DHCP& dhcp2) {
     EXPECT_EQ(dhcp1.opcode(), dhcp2.opcode());
     EXPECT_EQ(dhcp1.htype(), dhcp2.htype());
     ASSERT_EQ(dhcp1.hlen(), dhcp2.hlen());
diff --git a/tests/src/dhcpv6.cpp b/tests/src/dhcpv6.cpp
index d6e70fc..4885e6f 100644
--- a/tests/src/dhcpv6.cpp
+++ b/tests/src/dhcpv6.cpp
@@ -10,7 +10,7 @@ class DHCPv6Test : public testing::Test {
 public:
     static const uint8_t expected_packet[];
 
-    void test_equals(const DHCPv6 &dhcp1, const DHCPv6 &dhcp2);
+    void test_equals(const DHCPv6& dhcp1, const DHCPv6& dhcp2);
 };
 
 const uint8_t DHCPv6Test::expected_packet[] = {
diff --git a/tests/src/dns.cpp b/tests/src/dns.cpp
index 63a0946..8b3624e 100644
--- a/tests/src/dns.cpp
+++ b/tests/src/dns.cpp
@@ -15,9 +15,9 @@ public:
     static const uint8_t expected_packet[], dns_response1[],
                         dns_packet1[];
     
-    void test_equals(const DNS &dns1, const DNS &dns2);
-    void test_equals(const DNS::Query &q1, const DNS::Query &q2);
-    void test_equals(const DNS::Resource &q1, const DNS::Resource &q2);
+    void test_equals(const DNS& dns1, const DNS& dns2);
+    void test_equals(const DNS::Query& q1, const DNS::Query& q2);
+    void test_equals(const DNS::Resource& q1, const DNS::Resource& q2);
 };
 
 const uint8_t DNSTest::expected_packet[] = {
@@ -45,7 +45,7 @@ const uint8_t DNSTest::dns_packet1[] = {
 
 
 
-void DNSTest::test_equals(const DNS &dns1, const DNS &dns2) {
+void DNSTest::test_equals(const DNS& dns1, const DNS& dns2) {
     EXPECT_EQ(dns1.id(), dns2.id());
     EXPECT_EQ(dns1.type(), dns2.type());
     EXPECT_EQ(dns1.opcode(), dns2.opcode());
@@ -66,13 +66,13 @@ void DNSTest::test_equals(const DNS &dns1, const DNS &dns2) {
     EXPECT_EQ(dns1.inner_pdu() != NULL, dns2.inner_pdu() != NULL);
 }
 
-void DNSTest::test_equals(const DNS::Query &q1, const DNS::Query &q2) {
+void DNSTest::test_equals(const DNS::Query& q1, const DNS::Query& q2) {
     EXPECT_EQ(q1.dname(), q2.dname());
     EXPECT_EQ(q1.type(), q2.type());
     EXPECT_EQ(q1.query_class(), q2.query_class());
 }
 
-void DNSTest::test_equals(const DNS::Resource &q1, const DNS::Resource &q2) {
+void DNSTest::test_equals(const DNS::Resource& q1, const DNS::Resource& q2) {
     EXPECT_EQ(q1.dname(), q2.dname());
     EXPECT_EQ(q1.data(), q2.data());
     EXPECT_EQ(q1.type(), q2.type());
@@ -179,7 +179,7 @@ TEST_F(DNSTest, CopyAssignmentOperator) {
 }
 
 TEST_F(DNSTest, NestedCopy) {
-    DNS *nested = new DNS(expected_packet, sizeof(expected_packet));
+    DNS* nested = new DNS(expected_packet, sizeof(expected_packet));
     DNS dns1(expected_packet, sizeof(expected_packet));
     dns1.inner_pdu(nested);
     DNS dns2(dns1);
@@ -307,7 +307,7 @@ TEST_F(DNSTest, Answers) {
 TEST_F(DNSTest, Authority) {
     DNS dns;
     
-    const char *domain = "carlos.example.com";
+    const char* domain = "carlos.example.com";
     dns.add_authority(
         DNS::Resource("www.example.com", domain, DNS::CNAME, DNS::IN, 0x762)
     );
@@ -331,7 +331,7 @@ TEST_F(DNSTest, Authority) {
 TEST_F(DNSTest, Additional) {
     DNS dns;
     
-    const char *domain = "carlos.example.com";
+    const char* domain = "carlos.example.com";
     dns.add_additional(
         DNS::Resource("www.example.com", domain, DNS::CNAME, DNS::IN, 0x762)
     );
@@ -395,7 +395,7 @@ TEST_F(DNSTest, ItAintGonnaCorrupt) {
     EXPECT_EQ(dns.questions_count(), 1);
     EXPECT_EQ(dns.answers_count(), 5);
 
-    const char *domain = "carlos.example.com";
+    const char* domain = "carlos.example.com";
     dns.add_additional(
         DNS::Resource("www.example.com", domain, DNS::CNAME, DNS::IN, 0x762)
     );
diff --git a/tests/src/dot11/ack.cpp b/tests/src/dot11/ack.cpp
index 4b8d114..8a579dd 100644
--- a/tests/src/dot11/ack.cpp
+++ b/tests/src/dot11/ack.cpp
@@ -22,14 +22,14 @@ const uint8_t Dot11AckTest::expected_packet[] = {
     213, 1, 79, 35, 0, 1, 2, 3, 4, 5
 };
 
-void test_equals(const Dot11Ack &dot1, const Dot11Ack &dot2) {
+void test_equals(const Dot11Ack& dot1, const Dot11Ack& dot2) {
     test_equals(
         static_cast<const Dot11&>(dot1),
         static_cast<const Dot11&>(dot2)
     );
 }
 
-void test_equals_expected(const Dot11Ack &dot11) {
+void test_equals_expected(const Dot11Ack& dot11) {
     EXPECT_EQ(dot11.protocol(), 1);
     EXPECT_EQ(dot11.type(), Dot11::CONTROL);
     EXPECT_EQ(dot11.subtype(), Dot11::ACK);
@@ -89,7 +89,7 @@ TEST_F(Dot11AckTest, ClonePDU) {
 TEST_F(Dot11AckTest, FromBytes) {
     Internals::smart_ptr<PDU>::type dot11(Dot11::from_bytes(expected_packet, sizeof(expected_packet)));
     ASSERT_TRUE(dot11.get() != NULL);
-    const Dot11Ack *inner = dot11->find_pdu<Dot11Ack>();
+    const Dot11Ack* inner = dot11->find_pdu<Dot11Ack>();
     ASSERT_TRUE(inner != NULL);
     test_equals_expected(*inner);
 }
diff --git a/tests/src/dot11/assoc_request.cpp b/tests/src/dot11/assoc_request.cpp
index 0ab0fa2..5adc7a6 100644
--- a/tests/src/dot11/assoc_request.cpp
+++ b/tests/src/dot11/assoc_request.cpp
@@ -23,7 +23,7 @@ const uint8_t Dot11AssocRequestTest::expected_packet[] = {
     0, 0, 21, 32, 243, 146
 };
 
-void test_equals(const Dot11AssocRequest &dot1, const Dot11AssocRequest &dot2) {
+void test_equals(const Dot11AssocRequest& dot1, const Dot11AssocRequest& dot2) {
     test_equals(dot1.capabilities(), dot2.capabilities());
     EXPECT_EQ(dot1.listen_interval(), dot2.listen_interval());
     test_equals(
@@ -32,7 +32,7 @@ void test_equals(const Dot11AssocRequest &dot1, const Dot11AssocRequest &dot2) {
     );
 }
 
-void test_equals_expected(const Dot11AssocRequest &dot11) {
+void test_equals_expected(const Dot11AssocRequest& dot11) {
     test_equals_expected(static_cast<const Dot11ManagementFrame&>(dot11));
     EXPECT_EQ(dot11.listen_interval(), 0x92f3);
     EXPECT_EQ(dot11.subtype(), Dot11::ASSOC_REQ);
@@ -78,7 +78,7 @@ TEST_F(Dot11AssocRequestTest, ClonePDU) {
 TEST_F(Dot11AssocRequestTest, FromBytes) {
     Internals::smart_ptr<PDU>::type dot11(Dot11::from_bytes(expected_packet, sizeof(expected_packet)));
     ASSERT_TRUE(dot11.get() != NULL);
-    const Dot11AssocRequest *inner = dot11->find_pdu<Dot11AssocRequest>();
+    const Dot11AssocRequest* inner = dot11->find_pdu<Dot11AssocRequest>();
     ASSERT_TRUE(inner != NULL);
     test_equals_expected(*inner);
 }
diff --git a/tests/src/dot11/assoc_response.cpp b/tests/src/dot11/assoc_response.cpp
index 452c29c..ebbb45d 100644
--- a/tests/src/dot11/assoc_response.cpp
+++ b/tests/src/dot11/assoc_response.cpp
@@ -22,7 +22,7 @@ const uint8_t Dot11AssocResponseTest::expected_packet[] = {
     0, 0, 21, 32, 243, 146, 58, 242
 };
 
-void test_equals(const Dot11AssocResponse &dot1, const Dot11AssocResponse &dot2) {
+void test_equals(const Dot11AssocResponse& dot1, const Dot11AssocResponse& dot2) {
     test_equals(dot1.capabilities(), dot2.capabilities());
     EXPECT_EQ(dot1.status_code(), dot2.status_code());
     EXPECT_EQ(dot1.aid(), dot2.aid());
@@ -32,7 +32,7 @@ void test_equals(const Dot11AssocResponse &dot1, const Dot11AssocResponse &dot2)
     );
 }
 
-void test_equals_expected(const Dot11AssocResponse &dot11) {
+void test_equals_expected(const Dot11AssocResponse& dot11) {
     test_equals_expected(static_cast<const Dot11ManagementFrame&>(dot11));
     EXPECT_EQ(dot11.status_code(), 0x92f3);
     EXPECT_EQ(dot11.aid(), 0xf23a);
@@ -86,7 +86,7 @@ TEST_F(Dot11AssocResponseTest, ClonePDU) {
 TEST_F(Dot11AssocResponseTest, FromBytes) {
     Internals::smart_ptr<PDU>::type dot11(Dot11::from_bytes(expected_packet, sizeof(expected_packet)));
     ASSERT_TRUE(dot11.get() != NULL);
-    const Dot11AssocResponse *inner = dot11->find_pdu<Dot11AssocResponse>();
+    const Dot11AssocResponse* inner = dot11->find_pdu<Dot11AssocResponse>();
     ASSERT_TRUE(inner != NULL);
     test_equals_expected(*inner);
 }
diff --git a/tests/src/dot11/authentication.cpp b/tests/src/dot11/authentication.cpp
index 00d35d3..fa821cc 100644
--- a/tests/src/dot11/authentication.cpp
+++ b/tests/src/dot11/authentication.cpp
@@ -22,7 +22,7 @@ const uint8_t Dot11AuthenticationTest::expected_packet[] = {
     7, 0, 0, 162, 40, 58, 242, 243, 146
 };
 
-void test_equals(const Dot11Authentication &dot1, const Dot11Authentication &dot2) {
+void test_equals(const Dot11Authentication& dot1, const Dot11Authentication& dot2) {
     EXPECT_EQ(dot1.status_code(), dot2.status_code());
     EXPECT_EQ(dot1.auth_seq_number(), dot2.auth_seq_number());
     EXPECT_EQ(dot1.auth_algorithm(), dot2.auth_algorithm());
@@ -32,7 +32,7 @@ void test_equals(const Dot11Authentication &dot1, const Dot11Authentication &dot
     );
 }
 
-void test_equals_expected(const Dot11Authentication &dot11) {
+void test_equals_expected(const Dot11Authentication& dot11) {
     test_equals_expected(static_cast<const Dot11ManagementFrame&>(dot11));
     EXPECT_EQ(dot11.status_code(), 0x92f3);
     EXPECT_EQ(dot11.auth_seq_number(), 0xf23a);    
@@ -94,7 +94,7 @@ TEST_F(Dot11AuthenticationTest, ClonePDU) {
 TEST_F(Dot11AuthenticationTest, FromBytes) {
     Internals::smart_ptr<PDU>::type dot11(Dot11::from_bytes(expected_packet, sizeof(expected_packet)));
     ASSERT_TRUE(dot11.get() != NULL);
-    const Dot11Authentication *inner = dot11->find_pdu<Dot11Authentication>();
+    const Dot11Authentication* inner = dot11->find_pdu<Dot11Authentication>();
     ASSERT_TRUE(inner != NULL);
     test_equals_expected(*inner);
 }
diff --git a/tests/src/dot11/beacon.cpp b/tests/src/dot11/beacon.cpp
index 6d9ba8e..0ca8dd7 100644
--- a/tests/src/dot11/beacon.cpp
+++ b/tests/src/dot11/beacon.cpp
@@ -27,12 +27,12 @@ const uint8_t Dot11BeaconTest::expected_packet[] = {
     7, 0, 0, 250, 1, 147, 40, 65, 35, 173, 31, 250, 20, 149, 32
 };
 
-void test_equals_expected(const Dot11Beacon &dot11) {
+void test_equals_expected(const Dot11Beacon& dot11) {
     EXPECT_EQ(dot11.subtype(), 8);
     EXPECT_EQ(dot11.timestamp(), 0x1fad2341289301faULL);
     EXPECT_EQ(dot11.interval(), 0x14fa);
     
-    const Dot11Beacon::capability_information &info = dot11.capabilities();
+    const Dot11Beacon::capability_information& info = dot11.capabilities();
     EXPECT_EQ(info.ess(), true);
     EXPECT_EQ(info.ibss(), false);
     EXPECT_EQ(info.cf_poll(), true);
@@ -111,7 +111,7 @@ TEST_F(Dot11BeaconTest, SeqNum) {
 TEST_F(Dot11BeaconTest, FromBytes) {
     Internals::smart_ptr<PDU>::type dot11(Dot11::from_bytes(expected_packet, sizeof(expected_packet)));
     ASSERT_TRUE(dot11.get() != NULL);
-    const Dot11Beacon *beacon = dot11->find_pdu<Dot11Beacon>();
+    const Dot11Beacon* beacon = dot11->find_pdu<Dot11Beacon>();
     ASSERT_TRUE(beacon != NULL);
     test_equals_expected(*beacon);
 }
diff --git a/tests/src/dot11/block_ack_request.cpp b/tests/src/dot11/block_ack_request.cpp
index 080ecca..e5e92a2 100644
--- a/tests/src/dot11/block_ack_request.cpp
+++ b/tests/src/dot11/block_ack_request.cpp
@@ -22,13 +22,13 @@ const uint8_t Dot11BlockAckRequestTest::expected_packet[] = {
     0, 176, 33
 };
 
-void test_equals(const Dot11BlockAckRequest &dot1, const Dot11BlockAckRequest &dot2) {
+void test_equals(const Dot11BlockAckRequest& dot1, const Dot11BlockAckRequest& dot2) {
     EXPECT_EQ(dot1.fragment_number(), dot2.fragment_number());
     EXPECT_EQ(dot1.start_sequence(), dot2.start_sequence());
     EXPECT_EQ(dot1.bar_control(), dot2.bar_control());
 }
 
-void test_equals_expected(const Dot11BlockAckRequest &dot11) {
+void test_equals_expected(const Dot11BlockAckRequest& dot11) {
     EXPECT_EQ(dot11.type(), Dot11::CONTROL);
     EXPECT_EQ(dot11.subtype(), Dot11::BLOCK_ACK_REQ);
     EXPECT_EQ(dot11.bar_control(), 4);
@@ -82,7 +82,7 @@ TEST_F(Dot11BlockAckRequestTest, ClonePDU) {
 TEST_F(Dot11BlockAckRequestTest, FromBytes) {
     Internals::smart_ptr<PDU>::type dot11(Dot11::from_bytes(expected_packet, sizeof(expected_packet)));
     ASSERT_TRUE(dot11.get() != NULL);
-    const Dot11BlockAckRequest *inner = dot11->find_pdu<Dot11BlockAckRequest>();
+    const Dot11BlockAckRequest* inner = dot11->find_pdu<Dot11BlockAckRequest>();
     ASSERT_TRUE(inner != NULL);
     test_equals_expected(*inner);
 }
diff --git a/tests/src/dot11/cfend.cpp b/tests/src/dot11/cfend.cpp
index ebe2452..77d81b1 100644
--- a/tests/src/dot11/cfend.cpp
+++ b/tests/src/dot11/cfend.cpp
@@ -21,14 +21,14 @@ const uint8_t Dot11CFEndTest::expected_packet[] = {
     229, 1, 79, 35, 0, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 6
 };
 
-void test_equals(const Dot11CFEnd &dot1, const Dot11CFEnd &dot2) {
+void test_equals(const Dot11CFEnd& dot1, const Dot11CFEnd& dot2) {
     test_equals(
         static_cast<const Dot11ControlTA&>(dot1),
         static_cast<const Dot11ControlTA&>(dot2)
     );
 }
 
-void test_equals_expected(const Dot11CFEnd &dot11) {
+void test_equals_expected(const Dot11CFEnd& dot11) {
     test_equals_expected(static_cast<const Dot11ControlTA&>(dot11));
     EXPECT_EQ(dot11.subtype(), Dot11::CF_END);
 }
@@ -66,7 +66,7 @@ TEST_F(Dot11CFEndTest, ClonePDU) {
 TEST_F(Dot11CFEndTest, FromBytes) {
     Internals::smart_ptr<PDU>::type dot11(Dot11::from_bytes(expected_packet, sizeof(expected_packet)));
     ASSERT_TRUE(dot11.get() != NULL);
-    const Dot11CFEnd *inner = dot11->find_pdu<Dot11CFEnd>();
+    const Dot11CFEnd* inner = dot11->find_pdu<Dot11CFEnd>();
     ASSERT_TRUE(inner != NULL);
     test_equals_expected(*inner);
 }
diff --git a/tests/src/dot11/cfendack.cpp b/tests/src/dot11/cfendack.cpp
index a409ae2..c2d0dd5 100644
--- a/tests/src/dot11/cfendack.cpp
+++ b/tests/src/dot11/cfendack.cpp
@@ -21,14 +21,14 @@ const uint8_t Dot11EndCFAckTest::expected_packet[] = {
     245, 1, 79, 35, 0, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 6
 };
 
-void test_equals(const Dot11EndCFAck &dot1, const Dot11EndCFAck &dot2) {
+void test_equals(const Dot11EndCFAck& dot1, const Dot11EndCFAck& dot2) {
     test_equals(
         static_cast<const Dot11ControlTA&>(dot1),
         static_cast<const Dot11ControlTA&>(dot2)
     );
 }
 
-void test_equals_expected(const Dot11EndCFAck &dot11) {
+void test_equals_expected(const Dot11EndCFAck& dot11) {
     test_equals_expected(static_cast<const Dot11ControlTA&>(dot11));
     EXPECT_EQ(dot11.subtype(), Dot11::CF_END_ACK);
 }
@@ -66,7 +66,7 @@ TEST_F(Dot11EndCFAckTest, ClonePDU) {
 TEST_F(Dot11EndCFAckTest, FromBytes) {
     Internals::smart_ptr<PDU>::type dot11(Dot11::from_bytes(expected_packet, sizeof(expected_packet)));
     ASSERT_TRUE(dot11.get() != NULL);
-    const Dot11EndCFAck *inner = dot11->find_pdu<Dot11EndCFAck>();
+    const Dot11EndCFAck* inner = dot11->find_pdu<Dot11EndCFAck>();
     ASSERT_TRUE(inner != NULL);
     test_equals_expected(*inner);
 }
diff --git a/tests/src/dot11/data.cpp b/tests/src/dot11/data.cpp
index d2a5609..7904779 100644
--- a/tests/src/dot11/data.cpp
+++ b/tests/src/dot11/data.cpp
@@ -104,7 +104,7 @@ TEST_F(Dot11DataTest, ClonePDU) {
 TEST_F(Dot11DataTest, FromBytes) {
     Internals::smart_ptr<PDU>::type dot11(Dot11::from_bytes(expected_packet, sizeof(expected_packet)));
     ASSERT_TRUE(dot11.get() != NULL);
-    const Dot11Data *inner = dot11->find_pdu<Dot11Data>();
+    const Dot11Data* inner = dot11->find_pdu<Dot11Data>();
     ASSERT_TRUE(inner != NULL);
     test_equals_expected(*inner);
 }
diff --git a/tests/src/dot11/deauthentication.cpp b/tests/src/dot11/deauthentication.cpp
index 02f0dc3..ceb3430 100644
--- a/tests/src/dot11/deauthentication.cpp
+++ b/tests/src/dot11/deauthentication.cpp
@@ -22,7 +22,7 @@ const uint8_t Dot11DeauthenticationTest::expected_packet[] = {
     7, 0, 0, 243, 146
 };
 
-void test_equals(const Dot11Deauthentication &dot1, const Dot11Deauthentication &dot2) {
+void test_equals(const Dot11Deauthentication& dot1, const Dot11Deauthentication& dot2) {
     EXPECT_EQ(dot1.reason_code(), dot2.reason_code());
     test_equals(
         static_cast<const Dot11ManagementFrame&>(dot1),
@@ -30,7 +30,7 @@ void test_equals(const Dot11Deauthentication &dot1, const Dot11Deauthentication
     );
 }
 
-void test_equals_expected(const Dot11Deauthentication &dot11) {
+void test_equals_expected(const Dot11Deauthentication& dot11) {
     test_equals_expected(static_cast<const Dot11ManagementFrame&>(dot11));
     EXPECT_EQ(dot11.reason_code(), 0x92f3);
     EXPECT_EQ(dot11.subtype(), Dot11::DEAUTH);
@@ -76,7 +76,7 @@ TEST_F(Dot11DeauthenticationTest, ClonePDU) {
 TEST_F(Dot11DeauthenticationTest, FromBytes) {
     Internals::smart_ptr<PDU>::type dot11(Dot11::from_bytes(expected_packet, sizeof(expected_packet)));
     ASSERT_TRUE(dot11.get() != NULL);
-    const Dot11Deauthentication *inner = dot11->find_pdu<Dot11Deauthentication>();
+    const Dot11Deauthentication* inner = dot11->find_pdu<Dot11Deauthentication>();
     ASSERT_TRUE(inner != NULL);
     test_equals_expected(*inner);
 }
diff --git a/tests/src/dot11/disassoc.cpp b/tests/src/dot11/disassoc.cpp
index 9ca8c19..534ebb7 100644
--- a/tests/src/dot11/disassoc.cpp
+++ b/tests/src/dot11/disassoc.cpp
@@ -23,7 +23,7 @@ const uint8_t Dot11DisassocTest::expected_packet[] = {
     7, 0, 0, 18, 35
 };
 
-void test_equals(const Dot11Disassoc &dot1, const Dot11Disassoc &dot2) {
+void test_equals(const Dot11Disassoc& dot1, const Dot11Disassoc& dot2) {
     EXPECT_EQ(dot1.reason_code(), dot2.reason_code());
     test_equals(
         static_cast<const Dot11ManagementFrame&>(dot1),
@@ -31,7 +31,7 @@ void test_equals(const Dot11Disassoc &dot1, const Dot11Disassoc &dot2) {
     );
 }
 
-void test_equals_expected(const Dot11Disassoc &dot11) {
+void test_equals_expected(const Dot11Disassoc& dot11) {
     test_equals_expected(static_cast<const Dot11ManagementFrame&>(dot11));
     EXPECT_EQ(dot11.reason_code(), 0x2312);
     EXPECT_EQ(dot11.subtype(), Dot11::DISASSOC);
@@ -77,7 +77,7 @@ TEST_F(Dot11DisassocTest, ClonePDU) {
 TEST_F(Dot11DisassocTest, FromBytes) {
     Internals::smart_ptr<PDU>::type dot11(Dot11::from_bytes(expected_packet, sizeof(expected_packet)));
     ASSERT_TRUE(dot11.get() != NULL);
-    const Dot11Disassoc *inner = dot11->find_pdu<Dot11Disassoc>();
+    const Dot11Disassoc* inner = dot11->find_pdu<Dot11Disassoc>();
     ASSERT_TRUE(inner != NULL);
     test_equals_expected(*inner);
 }
diff --git a/tests/src/dot11/dot11.cpp b/tests/src/dot11/dot11.cpp
index a32c2d1..d28cff2 100644
--- a/tests/src/dot11/dot11.cpp
+++ b/tests/src/dot11/dot11.cpp
@@ -151,7 +151,7 @@ TEST_F(Dot11Test, Addr1) {
 TEST_F(Dot11Test, AddTaggedOption) {
     Dot11 dot11;
     dot11.add_option(Dot11::option(Dot11::SSID, hwaddr.begin(), hwaddr.end()));
-    const Dot11::option *option = dot11.search_option(Dot11::SSID);
+    const Dot11::option* option = dot11.search_option(Dot11::SSID);
     ASSERT_TRUE(option != NULL);
     EXPECT_EQ(option->data_size(), hwaddr.size());
     EXPECT_EQ(option->option(), Dot11::SSID);
diff --git a/tests/src/dot11/probe_request.cpp b/tests/src/dot11/probe_request.cpp
index eaadde4..b2c7dff 100644
--- a/tests/src/dot11/probe_request.cpp
+++ b/tests/src/dot11/probe_request.cpp
@@ -22,14 +22,14 @@ const uint8_t Dot11ProbeRequestTest::expected_packet[] = {
     0, 0
 };
 
-void test_equals(const Dot11ProbeRequest &dot1, const Dot11ProbeRequest &dot2) {
+void test_equals(const Dot11ProbeRequest& dot1, const Dot11ProbeRequest& dot2) {
     test_equals(
         static_cast<const Dot11ManagementFrame&>(dot1),
         static_cast<const Dot11ManagementFrame&>(dot2)
     );
 }
 
-void test_equals_expected(const Dot11ProbeRequest &dot11) {
+void test_equals_expected(const Dot11ProbeRequest& dot11) {
     test_equals_expected(static_cast<const Dot11ManagementFrame&>(dot11));
     EXPECT_EQ(dot11.subtype(), Dot11::PROBE_REQ);
 }
@@ -67,7 +67,7 @@ TEST_F(Dot11ProbeRequestTest, ClonePDU) {
 TEST_F(Dot11ProbeRequestTest, FromBytes) {
     Internals::smart_ptr<PDU>::type dot11(Dot11::from_bytes(expected_packet, sizeof(expected_packet)));
     ASSERT_TRUE(dot11.get() != NULL);
-    const Dot11ProbeRequest *inner = dot11->find_pdu<Dot11ProbeRequest>();
+    const Dot11ProbeRequest* inner = dot11->find_pdu<Dot11ProbeRequest>();
     ASSERT_TRUE(inner != NULL);
     test_equals_expected(*inner);
 }
diff --git a/tests/src/dot11/probe_response.cpp b/tests/src/dot11/probe_response.cpp
index 07c82cf..0309bdc 100644
--- a/tests/src/dot11/probe_response.cpp
+++ b/tests/src/dot11/probe_response.cpp
@@ -22,7 +22,7 @@ const uint8_t Dot11ProbeResponseTest::expected_packet[] = {
     0, 0, 145, 138, 131, 39, 223, 152, 166, 23, 141, 146, 0, 0
 };
 
-void test_equals(const Dot11ProbeResponse &dot1, const Dot11ProbeResponse &dot2) {
+void test_equals(const Dot11ProbeResponse& dot1, const Dot11ProbeResponse& dot2) {
     EXPECT_EQ(dot1.interval(), dot2.interval());
     EXPECT_EQ(dot1.timestamp(), dot2.timestamp());
     test_equals(
@@ -31,7 +31,7 @@ void test_equals(const Dot11ProbeResponse &dot1, const Dot11ProbeResponse &dot2)
     );
 }
 
-void test_equals_expected(const Dot11ProbeResponse &dot11) {
+void test_equals_expected(const Dot11ProbeResponse& dot11) {
     test_equals_expected(static_cast<const Dot11ManagementFrame&>(dot11));
     EXPECT_EQ(dot11.timestamp(), 0x17a698df27838a91ULL);
     EXPECT_EQ(dot11.interval(), 0x928d);
@@ -85,7 +85,7 @@ TEST_F(Dot11ProbeResponseTest, ClonePDU) {
 TEST_F(Dot11ProbeResponseTest, FromBytes) {
     Internals::smart_ptr<PDU>::type dot11(Dot11::from_bytes(expected_packet, sizeof(expected_packet)));
     ASSERT_TRUE(dot11.get() != NULL);
-    const Dot11ProbeResponse *inner = dot11->find_pdu<Dot11ProbeResponse>();
+    const Dot11ProbeResponse* inner = dot11->find_pdu<Dot11ProbeResponse>();
     ASSERT_TRUE(inner != NULL);
     test_equals_expected(*inner);
 }
diff --git a/tests/src/dot11/pspoll.cpp b/tests/src/dot11/pspoll.cpp
index a591c8b..25cf849 100644
--- a/tests/src/dot11/pspoll.cpp
+++ b/tests/src/dot11/pspoll.cpp
@@ -21,14 +21,14 @@ const uint8_t Dot11PSPollTest::expected_packet[] = {
     165, 1, 79, 35, 0, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 6
 };
 
-void test_equals(const Dot11PSPoll &dot1, const Dot11PSPoll &dot2) {
+void test_equals(const Dot11PSPoll& dot1, const Dot11PSPoll& dot2) {
     test_equals(
         static_cast<const Dot11ControlTA&>(dot1),
         static_cast<const Dot11ControlTA&>(dot2)
     );
 }
 
-void test_equals_expected(const Dot11PSPoll &dot11) {
+void test_equals_expected(const Dot11PSPoll& dot11) {
     test_equals_expected(static_cast<const Dot11ControlTA&>(dot11));
     EXPECT_EQ(dot11.subtype(), Dot11::PS);
 }
@@ -66,7 +66,7 @@ TEST_F(Dot11PSPollTest, ClonePDU) {
 TEST_F(Dot11PSPollTest, FromBytes) {
     Internals::smart_ptr<PDU>::type dot11(Dot11::from_bytes(expected_packet, sizeof(expected_packet)));
     ASSERT_TRUE(dot11.get() != NULL);
-    const Dot11PSPoll *inner = dot11->find_pdu<Dot11PSPoll>();
+    const Dot11PSPoll* inner = dot11->find_pdu<Dot11PSPoll>();
     ASSERT_TRUE(inner != NULL);
     test_equals_expected(*inner);
 }
diff --git a/tests/src/dot11/reassoc_request.cpp b/tests/src/dot11/reassoc_request.cpp
index 4ba0bef..136548b 100644
--- a/tests/src/dot11/reassoc_request.cpp
+++ b/tests/src/dot11/reassoc_request.cpp
@@ -22,7 +22,7 @@ const uint8_t Dot11ReAssocRequestTest::expected_packet[] = {
     0, 0, 21, 32, 243, 146, 3, 4, 5, 6, 7, 8
 };
 
-void test_equals(const Dot11ReAssocRequest &dot1, const Dot11ReAssocRequest &dot2) {
+void test_equals(const Dot11ReAssocRequest& dot1, const Dot11ReAssocRequest& dot2) {
     test_equals(dot1.capabilities(), dot2.capabilities());
     EXPECT_EQ(dot1.listen_interval(), dot2.listen_interval());
     EXPECT_EQ(dot1.current_ap(), dot2.current_ap());
@@ -32,7 +32,7 @@ void test_equals(const Dot11ReAssocRequest &dot1, const Dot11ReAssocRequest &dot
     );
 }
 
-void test_equals_expected(const Dot11ReAssocRequest &dot11) {
+void test_equals_expected(const Dot11ReAssocRequest& dot11) {
     test_equals_expected(static_cast<const Dot11ManagementFrame&>(dot11));
     EXPECT_EQ(dot11.listen_interval(), 0x92f3);
     EXPECT_EQ(dot11.subtype(), Dot11::REASSOC_REQ);
@@ -85,7 +85,7 @@ TEST_F(Dot11ReAssocRequestTest, ClonePDU) {
 TEST_F(Dot11ReAssocRequestTest, FromBytes) {
     Internals::smart_ptr<PDU>::type dot11(Dot11::from_bytes(expected_packet, sizeof(expected_packet)));
     ASSERT_TRUE(dot11.get() != NULL);
-    const Dot11ReAssocRequest *inner = dot11->find_pdu<Dot11ReAssocRequest>();
+    const Dot11ReAssocRequest* inner = dot11->find_pdu<Dot11ReAssocRequest>();
     ASSERT_TRUE(inner != NULL);
     test_equals_expected(*inner);
 }
diff --git a/tests/src/dot11/reassoc_response.cpp b/tests/src/dot11/reassoc_response.cpp
index 2e8b0eb..ecac10e 100644
--- a/tests/src/dot11/reassoc_response.cpp
+++ b/tests/src/dot11/reassoc_response.cpp
@@ -22,7 +22,7 @@ const uint8_t Dot11ReAssocResponseTest::expected_packet[] = {
     0, 0, 21, 32, 243, 146, 58, 242
 };
 
-void test_equals(const Dot11ReAssocResponse &dot1, const Dot11ReAssocResponse &dot2) {
+void test_equals(const Dot11ReAssocResponse& dot1, const Dot11ReAssocResponse& dot2) {
     test_equals(dot1.capabilities(), dot2.capabilities());
     EXPECT_EQ(dot1.status_code(), dot2.status_code());
     EXPECT_EQ(dot1.aid(), dot2.aid());
@@ -32,7 +32,7 @@ void test_equals(const Dot11ReAssocResponse &dot1, const Dot11ReAssocResponse &d
     );
 }
 
-void test_equals_expected(const Dot11ReAssocResponse &dot11) {
+void test_equals_expected(const Dot11ReAssocResponse& dot11) {
     test_equals_expected(static_cast<const Dot11ManagementFrame&>(dot11));
     EXPECT_EQ(dot11.status_code(), 0x92f3);
     EXPECT_EQ(dot11.aid(), 0xf23a);
@@ -74,7 +74,7 @@ TEST_F(Dot11ReAssocResponseTest, ClonePDU) {
 TEST_F(Dot11ReAssocResponseTest, FromBytes) {
     Internals::smart_ptr<PDU>::type dot11(Dot11::from_bytes(expected_packet, sizeof(expected_packet)));
     ASSERT_TRUE(dot11.get() != NULL);
-    const Dot11ReAssocResponse *inner = dot11->find_pdu<Dot11ReAssocResponse>();
+    const Dot11ReAssocResponse* inner = dot11->find_pdu<Dot11ReAssocResponse>();
     ASSERT_TRUE(inner != NULL);
     test_equals_expected(*inner);
 }
diff --git a/tests/src/dot11/rts.cpp b/tests/src/dot11/rts.cpp
index 213fdea..9a6d47f 100644
--- a/tests/src/dot11/rts.cpp
+++ b/tests/src/dot11/rts.cpp
@@ -21,14 +21,14 @@ const uint8_t Dot11RTSTest::expected_packet[] = {
     181, 1, 79, 35, 0, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 6
 };
 
-void test_equals(const Dot11RTS &dot1, const Dot11RTS &dot2) {
+void test_equals(const Dot11RTS& dot1, const Dot11RTS& dot2) {
     test_equals(
         static_cast<const Dot11ControlTA&>(dot1),
         static_cast<const Dot11ControlTA&>(dot2)
     );
 }
 
-void test_equals_expected(const Dot11RTS &dot11) {
+void test_equals_expected(const Dot11RTS& dot11) {
     test_equals_expected(static_cast<const Dot11ControlTA&>(dot11));
     EXPECT_EQ(dot11.subtype(), Dot11::RTS);
 }
@@ -66,7 +66,7 @@ TEST_F(Dot11RTSTest, ClonePDU) {
 TEST_F(Dot11RTSTest, FromBytes) {
     Internals::smart_ptr<PDU>::type dot11(Dot11::from_bytes(expected_packet, sizeof(expected_packet)));
     ASSERT_TRUE(dot11.get() != NULL);
-    const Dot11RTS *inner = dot11->find_pdu<Dot11RTS>();
+    const Dot11RTS* inner = dot11->find_pdu<Dot11RTS>();
     ASSERT_TRUE(inner != NULL);
     test_equals_expected(*inner);
 }
diff --git a/tests/src/dot1q.cpp b/tests/src/dot1q.cpp
index 8f4f993..2b496c7 100644
--- a/tests/src/dot1q.cpp
+++ b/tests/src/dot1q.cpp
@@ -13,7 +13,7 @@ class Dot1QTest : public testing::Test {
 public:
     static const uint8_t expected_packet[];
     
-    void test_equals(const Dot1Q &pdu1, const Dot1Q &pdu2);
+    void test_equals(const Dot1Q& pdu1, const Dot1Q& pdu2);
 };
 
 const uint8_t Dot1QTest::expected_packet[] = { 
@@ -34,14 +34,14 @@ TEST_F(Dot1QTest, DefaultConstructor) {
 
 TEST_F(Dot1QTest, ConstructorFromBuffer) {
     EthernetII eth(expected_packet, sizeof(expected_packet));
-    const Dot1Q *dot1 = eth.find_pdu<Dot1Q>();
+    const Dot1Q* dot1 = eth.find_pdu<Dot1Q>();
     ASSERT_TRUE(dot1 != NULL);
     EXPECT_EQ(0x806, dot1->payload_type());
     EXPECT_EQ(5, dot1->priority());
     EXPECT_EQ(1, dot1->cfi());
     EXPECT_EQ(123, dot1->id());
     
-    const ARP *arp = dot1->find_pdu<ARP>();
+    const ARP* arp = dot1->find_pdu<ARP>();
     ASSERT_TRUE(arp != NULL);
     // just to check it the offset's OK
     EXPECT_EQ(ARP::hwaddress_type("00:19:06:ea:b8:c1"), arp->sender_hw_addr());
diff --git a/tests/src/ethernetII.cpp b/tests/src/ethernetII.cpp
index 56bd3f8..40f29ae 100644
--- a/tests/src/ethernetII.cpp
+++ b/tests/src/ethernetII.cpp
@@ -20,7 +20,7 @@ public:
     static address_type empty_addr;
     static const uint16_t p_type;
 
-    void test_equals(const EthernetII &eth1, const EthernetII &eth2);
+    void test_equals(const EthernetII& eth1, const EthernetII& eth2);
 };
 
 const uint8_t EthernetIITest::expected_packet[] = {
@@ -53,7 +53,7 @@ address_type EthernetIITest::empty_addr;
 
 const uint16_t EthernetIITest::p_type = 0xd0ab;
 
-void EthernetIITest::test_equals(const EthernetII &eth1, const EthernetII &eth2) {
+void EthernetIITest::test_equals(const EthernetII& eth1, const EthernetII& eth2) {
     EXPECT_EQ(eth1.dst_addr(), eth2.dst_addr());
     EXPECT_EQ(eth1.src_addr(), eth2.src_addr());
     EXPECT_EQ(eth1.payload_type(), eth2.payload_type());
@@ -83,7 +83,7 @@ TEST_F(EthernetIITest, CopyAssignmentOperator) {
 }
 
 TEST_F(EthernetIITest, NestedCopy) {
-    EthernetII *nested = new EthernetII(expected_packet, sizeof(expected_packet));
+    EthernetII* nested = new EthernetII(expected_packet, sizeof(expected_packet));
     EthernetII eth1(expected_packet, sizeof(expected_packet));
     eth1.inner_pdu(nested);
     EthernetII eth2(eth1);
diff --git a/tests/src/hwaddress.cpp b/tests/src/hwaddress.cpp
index 2ab7dd1..a7f300f 100644
--- a/tests/src/hwaddress.cpp
+++ b/tests/src/hwaddress.cpp
@@ -12,11 +12,11 @@ using namespace Tins;
 class HWAddressTest : public testing::Test {
 public:
     static const std::string address;
-    static const uint8_t *byte_address, *empty_addr;
+    static const uint8_t* byte_address, *empty_addr;
 };
 
 const std::string HWAddressTest::address = "00:de:ad:be:ef:00";
-const uint8_t *HWAddressTest::byte_address = (const uint8_t*)"\x00\xde\xad\xbe\xef\x00",
+const uint8_t* HWAddressTest::byte_address = (const uint8_t*)"\x00\xde\xad\xbe\xef\x00",
               *HWAddressTest::empty_addr = (const uint8_t*)"\x00\x00\x00\x00\x00\x00";
 
 
diff --git a/tests/src/icmp.cpp b/tests/src/icmp.cpp
index e69afef..a9a86ab 100644
--- a/tests/src/icmp.cpp
+++ b/tests/src/icmp.cpp
@@ -19,7 +19,7 @@ public:
                          packet_with_extensions_and_length[];
     static const uint32_t expected_packet_count;
     
-    void test_equals(const ICMP &icmp1, const ICMP &icmp2);
+    void test_equals(const ICMP& icmp1, const ICMP& icmp2);
 };
 
 const uint8_t ICMPTest::expected_packets[][8] = {
@@ -78,7 +78,7 @@ TEST_F(ICMPTest, CopyAssignmentOperator) {
 }
 
 TEST_F(ICMPTest, NestedCopy) {
-    ICMP *nested = new ICMP(expected_packets[0], sizeof(expected_packets[0]));
+    ICMP* nested = new ICMP(expected_packets[0], sizeof(expected_packets[0]));
     ICMP icmp1(expected_packets[0], sizeof(expected_packets[0]));
     icmp1.inner_pdu(nested);
     ICMP icmp2(icmp1);
@@ -256,7 +256,7 @@ TEST_F(ICMPTest, SetRedirect) {
     EXPECT_EQ(IPv4Address("1.2.3.4"), icmp.gateway());
 }
 
-void ICMPTest::test_equals(const ICMP &icmp1, const ICMP &icmp2) {
+void ICMPTest::test_equals(const ICMP& icmp1, const ICMP& icmp2) {
     EXPECT_EQ(icmp1.type(), icmp2.type());
     EXPECT_EQ(icmp1.code(), icmp2.code());
     EXPECT_EQ(icmp1.gateway(), icmp2.gateway());
diff --git a/tests/src/icmpv6.cpp b/tests/src/icmpv6.cpp
index 1a17a29..5406ade 100644
--- a/tests/src/icmpv6.cpp
+++ b/tests/src/icmpv6.cpp
@@ -21,7 +21,7 @@ public:
     static const uint8_t packet_with_extensions_and_length[];
     static const uint8_t mld2_icmpv6_layer[];
 
-    void test_equals(const ICMPv6 &icmp1, const ICMPv6 &icmp2);
+    void test_equals(const ICMPv6& icmp1, const ICMPv6& icmp2);
 };
 
 const uint8_t ICMPv6Test::expected_packet[] = {
@@ -114,7 +114,7 @@ TEST_F(ICMPv6Test, ConstructorFromBuffer2) {
     EXPECT_EQ(icmp.router_lifetime(), 1800);
     EXPECT_EQ(icmp.reachable_time(), 30000U);
     EXPECT_EQ(icmp.retransmit_timer(), 1000U);
-    const ICMPv6::option *opt = icmp.search_option(ICMPv6::SOURCE_ADDRESS);
+    const ICMPv6::option* opt = icmp.search_option(ICMPv6::SOURCE_ADDRESS);
     ASSERT_TRUE(opt != NULL);
     EXPECT_EQ(opt->data_size(), 6U);
     EXPECT_EQ(HWAddress<6>(opt->data_ptr()), "00:60:97:07:69:ea");
@@ -281,7 +281,7 @@ TEST_F(ICMPv6Test, PrefixInformation) {
     EXPECT_EQ(result.L, info.L);
     EXPECT_EQ(result.valid_lifetime, info.valid_lifetime);
     EXPECT_EQ(result.preferred_lifetime, info.preferred_lifetime);
-    EXPECT_EQ(IPv6Address(result.prefix), IPv6Address(result.prefix));
+    EXPECT_EQ(IPv6Address(info.prefix), IPv6Address(result.prefix));
     EXPECT_EQ(IPv6Address(result.prefix), "827d:adae::1");
 }
 
@@ -325,7 +325,7 @@ TEST_F(ICMPv6Test, NewAdvertisementInterval) {
 TEST_F(ICMPv6Test, NewHomeAgentInformation) {
     ICMPv6 icmp;
     ICMPv6::new_ha_info_type data;
-    data.push_back(0);
+    data.push_back(0xfeed);
     data.push_back(0x92fa);
     data.push_back(0xaab3);
     icmp.new_home_agent_info(data);
@@ -426,6 +426,7 @@ TEST_F(ICMPv6Test, MAP) {
     EXPECT_EQ(output.dist, data.dist);
     EXPECT_EQ(output.pref, data.pref);
     EXPECT_EQ(output.r, data.r);
+    EXPECT_EQ(output.valid_lifetime, data.valid_lifetime);
     EXPECT_EQ(output.address, data.address);
 }
 
diff --git a/tests/src/ip.cpp b/tests/src/ip.cpp
index 9a6ffbc..79a72ce 100644
--- a/tests/src/ip.cpp
+++ b/tests/src/ip.cpp
@@ -26,7 +26,7 @@ public:
     static const uint8_t expected_packet[], fragmented_packet[], 
         fragmented_ether_ip_packet[], tot_len_zero_packet[];
     
-    void test_equals(const IP &ip1, const IP &ip2);
+    void test_equals(const IP& ip1, const IP& ip2);
     void test_overwrite_source_address(IP& ip);
 };
 
@@ -475,7 +475,7 @@ TEST_F(IPTest, CopyAssignmentOperator) {
 }
 
 TEST_F(IPTest, NestedCopy) {
-    IP *nested = new IP(expected_packet, sizeof(expected_packet));
+    IP* nested = new IP(expected_packet, sizeof(expected_packet));
     IP ip1;
     ip1.inner_pdu(nested);
     IP ip2(ip1);
@@ -625,13 +625,13 @@ TEST_F(IPTest, AddOption) {
     const uint8_t data[] = { 0x15, 0x17, 0x94, 0x66, 0xff };
     IP::option_identifier id(IP::SEC, IP::CONTROL, 1);
     ip.add_option(IP::option(id, data, data + sizeof(data)));
-    const IP::option *opt = ip.search_option(id);
+    const IP::option* opt = ip.search_option(id);
     ASSERT_TRUE(opt != NULL);
     ASSERT_EQ(opt->data_size(), sizeof(data));
     EXPECT_TRUE(memcmp(opt->data_ptr(), data, sizeof(data)) == 0);
 }
 
-void IPTest::test_equals(const IP &ip1, const IP &ip2) {
+void IPTest::test_equals(const IP& ip1, const IP& ip2) {
     EXPECT_EQ(ip1.dst_addr(), ip2.dst_addr());
     EXPECT_EQ(ip1.src_addr(), ip2.src_addr());
     EXPECT_EQ(ip1.id(), ip2.id());
diff --git a/tests/src/ip_reassembler.cpp b/tests/src/ip_reassembler.cpp
index c661427..4bca051 100644
--- a/tests/src/ip_reassembler.cpp
+++ b/tests/src/ip_reassembler.cpp
@@ -14,7 +14,7 @@ public:
     static const uint8_t packets[][1514];
     static const size_t packet_sizes[], orderings[][11];
     
-    void test_packets(const std::vector<std::pair<const uint8_t*, size_t> > &vt);
+    void test_packets(const std::vector<std::pair<const uint8_t*, size_t> >& vt);
 };
 
 const uint8_t IPv4ReassemblerTest::packets[][1514] = {
@@ -42,7 +42,7 @@ const size_t IPv4ReassemblerTest::orderings[][11] = {
     { 1, 9, 8, 5, 4, 2, 0, 7, 6, 3, 10 }
 };
 
-void IPv4ReassemblerTest::test_packets(const std::vector<std::pair<const uint8_t*, size_t> > &vt) {
+void IPv4ReassemblerTest::test_packets(const std::vector<std::pair<const uint8_t*, size_t> >& vt) {
     IPv4Reassembler reassembler;
     for(size_t i = 0; i < vt.size(); ++i) {
         EthernetII eth(vt[i].first, (uint32_t)vt[i].second);
@@ -51,7 +51,7 @@ void IPv4ReassemblerTest::test_packets(const std::vector<std::pair<const uint8_t
         if(status == IPv4Reassembler::REASSEMBLED) {
             ASSERT_EQ(static_cast<size_t>(vt.size() - 1), i);
             ASSERT_TRUE(eth.find_pdu<UDP>() != NULL);
-            RawPDU *raw = eth.find_pdu<RawPDU>();
+            RawPDU* raw = eth.find_pdu<RawPDU>();
             ASSERT_TRUE(raw != NULL);
             ASSERT_EQ(15000ULL, raw->payload().size());
         }
diff --git a/tests/src/ipsec.cpp b/tests/src/ipsec.cpp
index f148b94..42071a4 100644
--- a/tests/src/ipsec.cpp
+++ b/tests/src/ipsec.cpp
@@ -79,7 +79,7 @@ TEST_F(IPSecAHTest, EthPacket) {
 
 TEST_F(IPSecAHTest, ConstructorFromBuffer) {
     IPSecAH ipsec(expected_packet, sizeof(expected_packet));
-    const char *icv_ptr = "\x27\xcf\xc0\xa5\xe4\x3d\x69\xb3\x72\x8e\xc5\xb0";
+    const char* icv_ptr = "\x27\xcf\xc0\xa5\xe4\x3d\x69\xb3\x72\x8e\xc5\xb0";
     EXPECT_EQ(0x32, ipsec.next_header());
     EXPECT_EQ(4, ipsec.length());
     EXPECT_EQ(0x8179b705U, ipsec.spi());
diff --git a/tests/src/ipv6.cpp b/tests/src/ipv6.cpp
index 0a0c18a..54755ef 100644
--- a/tests/src/ipv6.cpp
+++ b/tests/src/ipv6.cpp
@@ -26,7 +26,7 @@ public:
     static const uint8_t expected_packet1[], expected_packet2[], 
                          hop_by_hop_options[];
     
-    void test_equals(IPv6 &ip1, IPv6 &ip2);
+    void test_equals(IPv6& ip1, IPv6& ip2);
 };
 
 const uint8_t IPv6Test::expected_packet1[] = {
@@ -55,7 +55,7 @@ const uint8_t IPv6Test::hop_by_hop_options[] = {
     222, 173, 190, 239, 190, 173, 254, 237
 };
 
-void IPv6Test::test_equals(IPv6 &ip1, IPv6 &ip2) {
+void IPv6Test::test_equals(IPv6& ip1, IPv6& ip2) {
     EXPECT_EQ(ip1.version(), ip2.version());
     EXPECT_EQ(ip1.traffic_class(), ip2.traffic_class());
     EXPECT_EQ(ip1.flow_label(), ip2.flow_label());
@@ -67,7 +67,7 @@ void IPv6Test::test_equals(IPv6 &ip1, IPv6 &ip2) {
     
     EXPECT_EQ(ip1.search_header(IPv6::HOP_BY_HOP) != NULL, 
                 ip2.search_header(IPv6::HOP_BY_HOP) != NULL);
-    const IPv6::ext_header *header1 = ip1.search_header(IPv6::HOP_BY_HOP),
+    const IPv6::ext_header* header1 = ip1.search_header(IPv6::HOP_BY_HOP),
                                     *header2 = ip2.search_header(IPv6::HOP_BY_HOP);
     if(header1 && header2) {
         EXPECT_EQ(header1->data_size(), header2->data_size());
@@ -75,7 +75,7 @@ void IPv6Test::test_equals(IPv6 &ip1, IPv6 &ip2) {
     
     EXPECT_EQ(ip1.inner_pdu() != NULL, ip2.inner_pdu() != NULL);
     
-    const ICMPv6 *icmp1 = ip1.find_pdu<ICMPv6>(), *icmp2 = ip2.find_pdu<ICMPv6>();
+    const ICMPv6* icmp1 = ip1.find_pdu<ICMPv6>(), *icmp2 = ip2.find_pdu<ICMPv6>();
     ASSERT_EQ(icmp1 != NULL, icmp2 != NULL);
     
     if(icmp1 && icmp2) {
@@ -106,7 +106,7 @@ TEST_F(IPv6Test, ConstructorFromBuffer) {
     EXPECT_EQ(ipv6.dst_addr(), "::1");
     EXPECT_EQ(ipv6.src_addr(), "::1");
     ASSERT_TRUE(ipv6.inner_pdu() != NULL);
-    TCP *tcp = ipv6.find_pdu<TCP>();
+    TCP* tcp = ipv6.find_pdu<TCP>();
     ASSERT_TRUE(tcp != NULL);
     EXPECT_EQ(tcp->sport(), 50828);
     EXPECT_EQ(tcp->dport(), 80);
@@ -124,14 +124,14 @@ TEST_F(IPv6Test, ConstructorFromBuffer2) {
     EXPECT_EQ(ipv6.dst_addr(), "ff02::16");
     EXPECT_EQ(ipv6.src_addr(), "fe80::2d0:9ff:fee3:e8de");
     
-    ICMPv6 *pdu = ipv6.find_pdu<ICMPv6>();
+    ICMPv6* pdu = ipv6.find_pdu<ICMPv6>();
     ASSERT_TRUE(pdu != NULL);
     EXPECT_EQ(pdu->type(), 143);
     EXPECT_EQ(pdu->code(), 0);
     EXPECT_EQ(pdu->checksum(), 0x74fe);
     EXPECT_EQ(pdu->checksum(), 0x74fe);
     
-    const IPv6::ext_header *header = ipv6.search_header(IPv6::HOP_BY_HOP);
+    const IPv6::ext_header* header = ipv6.search_header(IPv6::HOP_BY_HOP);
     ASSERT_TRUE(header != NULL);
     EXPECT_EQ(header->data_size(), 6U);
 }
diff --git a/tests/src/ipv6address.cpp b/tests/src/ipv6address.cpp
index 725992b..fad5019 100644
--- a/tests/src/ipv6address.cpp
+++ b/tests/src/ipv6address.cpp
@@ -12,7 +12,7 @@ using namespace Tins;
 
 const uint8_t empty_addr[IPv6Address::address_size] = { 0 };
 
-void test_to_string(const std::string &str) {
+void test_to_string(const std::string& str) {
     EXPECT_EQ(str, IPv6Address(str).to_string());
 }
 
diff --git a/tests/src/llc.cpp b/tests/src/llc.cpp
index 35644d2..1671034 100644
--- a/tests/src/llc.cpp
+++ b/tests/src/llc.cpp
@@ -14,7 +14,7 @@ public:
     static const uint8_t from_buffer_info[];
     static const uint8_t from_buffer_super[];
 
-    //void test_equals(const IP &ip1, const IP &ip2);
+    //void test_equals(const IP& ip1, const IP& ip2);
 };
 
 const uint8_t LLCTest::from_buffer_info[] = {
diff --git a/tests/src/main.cpp b/tests/src/main.cpp
index b7c2235..c7a8d74 100644
--- a/tests/src/main.cpp
+++ b/tests/src/main.cpp
@@ -3,7 +3,7 @@
 
 
 
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
     testing::InitGoogleTest(&argc, argv);
     return RUN_ALL_TESTS();
 }
diff --git a/tests/src/matches_response.cpp b/tests/src/matches_response.cpp
index 7fdf77c..8264885 100644
--- a/tests/src/matches_response.cpp
+++ b/tests/src/matches_response.cpp
@@ -104,8 +104,8 @@ TEST_F(MatchesResponseTest, DHCP) {
     };
     
     EthernetII discover(dhcp_discover, sizeof(dhcp_discover));
-    UDP *udp = discover.find_pdu<UDP>();
-    const RawPDU *raw = discover.find_pdu<RawPDU>();
+    UDP* udp = discover.find_pdu<UDP>();
+    const RawPDU* raw = discover.find_pdu<RawPDU>();
     ASSERT_TRUE(udp != NULL);
     ASSERT_TRUE(raw != NULL);
     
@@ -221,8 +221,8 @@ TEST_F(MatchesResponseTest, DHCPv6) {
     };
     
     EthernetII pkt(request, sizeof(request));
-    UDP *udp = pkt.find_pdu<UDP>();
-    const RawPDU *raw = pkt.find_pdu<RawPDU>();
+    UDP* udp = pkt.find_pdu<UDP>();
+    const RawPDU* raw = pkt.find_pdu<RawPDU>();
     ASSERT_TRUE(udp != NULL);
     ASSERT_TRUE(raw != NULL);
     
diff --git a/tests/src/pdu.cpp b/tests/src/pdu.cpp
index 5db4744..5d6df86 100644
--- a/tests/src/pdu.cpp
+++ b/tests/src/pdu.cpp
@@ -21,8 +21,8 @@ TEST_F(PDUTest, FindPDU) {
     EXPECT_TRUE(ip.find_pdu<TCP>() != NULL);
     EXPECT_TRUE(ip.find_pdu<RawPDU>() != NULL);
     EXPECT_FALSE(ip.find_pdu<UDP>() != NULL);
-    TCP &t1 = ip.rfind_pdu<TCP>();
-    const TCP &t2 = ip.rfind_pdu<TCP>();
+    TCP& t1 = ip.rfind_pdu<TCP>();
+    const TCP& t2 = ip.rfind_pdu<TCP>();
     (void)t1;
     (void)t2;
     EXPECT_THROW(ip.rfind_pdu<UDP>(), pdu_not_found);
@@ -33,12 +33,12 @@ TEST_F(PDUTest, OperatorConcat) {
     IP ip = IP("192.168.0.1") / TCP(22, 52) / RawPDU(raw_payload); 
     EXPECT_EQ(ip.dst_addr(), "192.168.0.1"); 
     ASSERT_TRUE(ip.inner_pdu() != NULL);
-    TCP *tcp = ip.find_pdu<TCP>();
+    TCP* tcp = ip.find_pdu<TCP>();
     ASSERT_TRUE(tcp != NULL);
     EXPECT_EQ(tcp->dport(), 22);
     EXPECT_EQ(tcp->sport(), 52);
     ASSERT_TRUE(tcp->inner_pdu() != NULL);
-    RawPDU *raw = tcp->find_pdu<RawPDU>();
+    RawPDU* raw = tcp->find_pdu<RawPDU>();
     ASSERT_TRUE(raw != NULL);
     ASSERT_EQ(raw->payload_size(), raw_payload.size());
     EXPECT_TRUE(std::equal(raw_payload.begin(), raw_payload.end(), raw->payload().begin()));
@@ -47,10 +47,10 @@ TEST_F(PDUTest, OperatorConcat) {
 TEST_F(PDUTest, OperatorConcatOnPointers) {
     std::string raw_payload = "Test";
     IP ip = IP("192.168.0.1") / TCP(22, 52);
-    TCP *tcp = ip.find_pdu<TCP>();
+    TCP* tcp = ip.find_pdu<TCP>();
     ASSERT_TRUE(tcp != NULL);
     tcp /= RawPDU(raw_payload);
-    RawPDU *raw = ip.find_pdu<RawPDU>();
+    RawPDU* raw = ip.find_pdu<RawPDU>();
     ASSERT_TRUE(raw != NULL);
     ASSERT_EQ(raw->payload_size(), raw_payload.size());
     EXPECT_TRUE(std::equal(raw->payload().begin(), raw->payload().end(), raw_payload.begin()));
@@ -59,19 +59,19 @@ TEST_F(PDUTest, OperatorConcatOnPointers) {
 TEST_F(PDUTest, OperatorConcatOnPacket) {
     std::string raw_payload = "Test";
     Packet packet = IP("192.168.0.1") / TCP(22, 52);
-    TCP *tcp = packet.pdu()->find_pdu<TCP>();
+    TCP* tcp = packet.pdu()->find_pdu<TCP>();
     ASSERT_TRUE(tcp != NULL);
     tcp /= RawPDU(raw_payload);
-    RawPDU *raw = packet.pdu()->find_pdu<RawPDU>();
+    RawPDU* raw = packet.pdu()->find_pdu<RawPDU>();
     ASSERT_TRUE(raw != NULL);
     ASSERT_EQ(raw->payload_size(), raw_payload.size());
     EXPECT_TRUE(std::equal(raw->payload().begin(), raw->payload().end(), raw_payload.begin()));
 }
 
 TEST_F(PDUTest, TinsCast) {
-    PDU *null_pdu = 0;
+    PDU* null_pdu = 0;
     TCP tcp;
-    PDU *pdu = &tcp;
+    PDU* pdu = &tcp;
     EXPECT_EQ(tins_cast<TCP*>(pdu), &tcp);
     EXPECT_EQ(tins_cast<const TCP*>(pdu), &tcp);
     EXPECT_EQ(tins_cast<TCP*>(null_pdu), null_pdu);
diff --git a/tests/src/rsn_eapol.cpp b/tests/src/rsn_eapol.cpp
index af94b73..3339251 100644
--- a/tests/src/rsn_eapol.cpp
+++ b/tests/src/rsn_eapol.cpp
@@ -17,7 +17,7 @@ public:
     static const uint8_t eapol_over_snap[];
     static const uint8_t broken_eapol[];
     
-    void test_equals(const RSNEAPOL &eapol1, const RSNEAPOL &eapol2);
+    void test_equals(const RSNEAPOL& eapol1, const RSNEAPOL& eapol2);
 };
 
 uint8_t empty_iv[RSNEAPOL::key_iv_size] = { 0 };
@@ -79,7 +79,7 @@ const uint8_t RSNEAPOLTest::broken_eapol[] = {
     179, 86
 };
 
-void RSNEAPOLTest::test_equals(const RSNEAPOL &eapol1, const RSNEAPOL &eapol2) {
+void RSNEAPOLTest::test_equals(const RSNEAPOL& eapol1, const RSNEAPOL& eapol2) {
     EXPECT_EQ(eapol1.version(), eapol2.version());
     EXPECT_EQ(eapol1.packet_type(), eapol2.packet_type());
     EXPECT_EQ(eapol1.type(), eapol2.type());
diff --git a/tests/src/sll.cpp b/tests/src/sll.cpp
index 1120c8c..80538c2 100644
--- a/tests/src/sll.cpp
+++ b/tests/src/sll.cpp
@@ -14,7 +14,7 @@ class SLLTest : public testing::Test {
 public:
     static const uint8_t expected_packet[];
     
-    void test_equals(const SLL &sll1, const SLL &sll2);
+    void test_equals(const SLL& sll1, const SLL& sll2);
 };
 
 const uint8_t SLLTest::expected_packet[] = { 
diff --git a/tests/src/snap.cpp b/tests/src/snap.cpp
index 2de1e03..a716cee 100644
--- a/tests/src/snap.cpp
+++ b/tests/src/snap.cpp
@@ -12,7 +12,7 @@ class SNAPTest : public testing::Test {
 public:
     static const uint8_t expected_packet[];
     
-    void test_equals(const SNAP &snap1, const SNAP &snap2);
+    void test_equals(const SNAP& snap1, const SNAP& snap2);
 };
 
 const uint8_t SNAPTest::expected_packet[] = {
@@ -87,7 +87,7 @@ TEST_F(SNAPTest, ClonePDU) {
     snap1.eth_type(0xfab1);
     snap1.org_code(0xfab1c3);
     snap1.control(0x1);
-    SNAP *snap2 = static_cast<SNAP*>(snap1.clone());
+    SNAP* snap2 = static_cast<SNAP*>(snap1.clone());
     ASSERT_TRUE(snap2 != NULL);
     test_equals(snap1, *snap2);
     
@@ -108,7 +108,7 @@ TEST_F(SNAPTest, ConstructorFromBuffer) {
     test_equals(snap1, snap2);
 }
 
-void SNAPTest::test_equals(const SNAP &snap1, const SNAP &snap2) {
+void SNAPTest::test_equals(const SNAP& snap1, const SNAP& snap2) {
     EXPECT_EQ(snap1.dsap(), snap2.dsap());
     EXPECT_EQ(snap1.ssap(), snap2.ssap());
     EXPECT_EQ(snap1.control(), snap2.control());
diff --git a/tests/src/stp.cpp b/tests/src/stp.cpp
index f1192fd..539f1d2 100644
--- a/tests/src/stp.cpp
+++ b/tests/src/stp.cpp
@@ -12,7 +12,7 @@ using namespace Tins;
 class STPTest : public testing::Test {
 public:
     static const uint8_t expected_packet[];
-    static void test_equals(const STP::bpdu_id_type &lhs, const STP::bpdu_id_type &rhs);
+    static void test_equals(const STP::bpdu_id_type& lhs, const STP::bpdu_id_type& rhs);
 };
 
 const uint8_t STPTest::expected_packet[] = { 
@@ -21,7 +21,7 @@ const uint8_t STPTest::expected_packet[] = {
     0
 };
 
-void STPTest::test_equals(const STP::bpdu_id_type &lhs, const STP::bpdu_id_type &rhs) {
+void STPTest::test_equals(const STP::bpdu_id_type& lhs, const STP::bpdu_id_type& rhs) {
     EXPECT_EQ(lhs.priority, rhs.priority);
     EXPECT_EQ(lhs.ext_id, rhs.ext_id);
     EXPECT_EQ(lhs.id, rhs.id);
@@ -78,8 +78,8 @@ TEST_F(STPTest, ChainedPDUs) {
         0, 0, 144, 76, 8, 23, 181, 128, 1, 0, 0, 20, 0, 2, 0, 0, 0
     };
     Dot3 pkt(input, sizeof(input));
-    STP *stp = pkt.find_pdu<STP>();
-    LLC *llc = pkt.find_pdu<LLC>();
+    STP* stp = pkt.find_pdu<STP>();
+    LLC* llc = pkt.find_pdu<LLC>();
     ASSERT_TRUE(stp != NULL);
     ASSERT_TRUE(llc != NULL);
     EXPECT_EQ(0x8001, stp->port_id());
diff --git a/tests/src/tcp.cpp b/tests/src/tcp.cpp
index 40724e5..4aef600 100644
--- a/tests/src/tcp.cpp
+++ b/tests/src/tcp.cpp
@@ -16,7 +16,7 @@ public:
     static const uint8_t expected_packet[], checksum_packet[],
                             partial_packet[];
     
-    void test_equals(const TCP &tcp1, const TCP &tcp2);
+    void test_equals(const TCP& tcp1, const TCP& tcp2);
 };
 
 const uint8_t TCPTest::expected_packet[] = {
@@ -47,7 +47,7 @@ TEST_F(TCPTest, DefaultConstructor) {
 
 TEST_F(TCPTest, ChecksumCheck) {
     EthernetII pkt1(checksum_packet, sizeof(checksum_packet)); 
-    const TCP &tcp1 = pkt1.rfind_pdu<TCP>();
+    const TCP& tcp1 = pkt1.rfind_pdu<TCP>();
     uint16_t checksum = tcp1.checksum();
     
     PDU::serialization_type buffer = pkt1.serialize();
@@ -60,7 +60,7 @@ TEST_F(TCPTest, ChecksumCheck) {
     );
 
     EthernetII pkt2(&buffer[0], (uint32_t)buffer.size());
-    const TCP &tcp2 = pkt2.rfind_pdu<TCP>();
+    const TCP& tcp2 = pkt2.rfind_pdu<TCP>();
     EXPECT_EQ(checksum, tcp2.checksum());
     EXPECT_EQ(tcp1.checksum(), tcp2.checksum());
     
@@ -79,7 +79,7 @@ TEST_F(TCPTest, CopyAssignmentOperator) {
 }
 
 TEST_F(TCPTest, NestedCopy) {
-    TCP *nested_tcp = new TCP(0x6d1f, 0x78f2);
+    TCP* nested_tcp = new TCP(0x6d1f, 0x78f2);
     TCP tcp1(0x6d1f, 0x78f2);
     tcp1.inner_pdu(nested_tcp);
     TCP tcp2(tcp1);
@@ -200,7 +200,7 @@ TEST_F(TCPTest, Timestamp) {
     EXPECT_EQ(tcp.timestamp(), data);
 }
 
-void TCPTest::test_equals(const TCP &tcp1, const TCP &tcp2) {
+void TCPTest::test_equals(const TCP& tcp1, const TCP& tcp2) {
     EXPECT_EQ(tcp1.dport(), tcp2.dport());
     EXPECT_EQ(tcp2.sport(), tcp2.sport());
     EXPECT_EQ(tcp1.seq(), tcp2.seq());
diff --git a/tests/src/udp.cpp b/tests/src/udp.cpp
index 4cf1a13..4c7ca45 100644
--- a/tests/src/udp.cpp
+++ b/tests/src/udp.cpp
@@ -75,7 +75,7 @@ TEST_F(UDPTest, DefaultConstructor) {
 
 TEST_F(UDPTest, ChecksumCheck) {
     EthernetII pkt1(checksum_packet, sizeof(checksum_packet)); 
-    const UDP &udp1 = pkt1.rfind_pdu<UDP>();
+    const UDP& udp1 = pkt1.rfind_pdu<UDP>();
     uint16_t checksum = udp1.checksum();
     PDU::serialization_type buffer = pkt1.serialize();
     EXPECT_EQ(
@@ -87,7 +87,7 @@ TEST_F(UDPTest, ChecksumCheck) {
     );
 
     EthernetII pkt2(&buffer[0], (uint32_t)buffer.size());
-    const UDP &udp2 = pkt2.rfind_pdu<UDP>();
+    const UDP& udp2 = pkt2.rfind_pdu<UDP>();
     EXPECT_EQ(checksum, udp2.checksum());
     EXPECT_EQ(udp1.checksum(), udp2.checksum());
 }
@@ -171,7 +171,7 @@ TEST_F(UDPTest, ClonePDU) {
     udp1.sport(sport);
     udp1.length(length);
     
-    UDP *udp2 = udp1.clone();
+    UDP* udp2 = udp1.clone();
     ASSERT_TRUE(udp2 != NULL);
     EXPECT_EQ(udp2->sport(), sport);
     EXPECT_EQ(udp2->dport(), dport);
diff --git a/tests/src/wep_decrypt.cpp b/tests/src/wep_decrypt.cpp
index 1649f69..7f96652 100644
--- a/tests/src/wep_decrypt.cpp
+++ b/tests/src/wep_decrypt.cpp
@@ -35,7 +35,7 @@ TEST_F(WEPDecryptTest, Decrypt1) {
     
     ASSERT_TRUE(decrypter.decrypt(dot11));
     
-    ARP *arp = dot11.find_pdu<ARP>();
+    ARP* arp = dot11.find_pdu<ARP>();
     ASSERT_TRUE(arp != NULL);
     EXPECT_EQ(arp->sender_hw_addr(), "00:0e:a6:6b:fb:69");
     EXPECT_EQ(arp->target_hw_addr(), "00:00:00:00:00:00");
diff --git a/tests/src/wpa2_decrypt.cpp b/tests/src/wpa2_decrypt.cpp
index f11d872..3bfb742 100644
--- a/tests/src/wpa2_decrypt.cpp
+++ b/tests/src/wpa2_decrypt.cpp
@@ -19,11 +19,11 @@ public:
     static const uint8_t tkip_packets[7][211];
     static const size_t ccmp_packets_size[], tkip_packets_size[];
     
-    void check_ccmp_packet5(const PDU &pdu);
-    void check_ccmp_packet6(const PDU &pdu);
+    void check_ccmp_packet5(const PDU& pdu);
+    void check_ccmp_packet6(const PDU& pdu);
     
-    void check_tkip_packet5(const PDU &pdu);
-    void check_tkip_packet6(const PDU &pdu);
+    void check_tkip_packet5(const PDU& pdu);
+    void check_tkip_packet6(const PDU& pdu);
 };
 
 // packet taken from aircrack's site.
@@ -63,30 +63,30 @@ const size_t WPA2DecryptTest::tkip_packets_size[] = {
     108, 149, 171, 211, 149, 134, 134
 };
 
-void WPA2DecryptTest::check_ccmp_packet5(const PDU &pdu) {
-    const UDP *udp = pdu.find_pdu<UDP>();
+void WPA2DecryptTest::check_ccmp_packet5(const PDU& pdu) {
+    const UDP* udp = pdu.find_pdu<UDP>();
     ASSERT_TRUE(udp);
     EXPECT_EQ(udp->sport(), 68);
     EXPECT_EQ(udp->dport(), 67);
 }
 
-void WPA2DecryptTest::check_ccmp_packet6(const PDU &pdu) {
-    const UDP *udp = pdu.find_pdu<UDP>();
+void WPA2DecryptTest::check_ccmp_packet6(const PDU& pdu) {
+    const UDP* udp = pdu.find_pdu<UDP>();
     ASSERT_TRUE(udp);
     EXPECT_EQ(udp->sport(), 67);
     EXPECT_EQ(udp->dport(), 68);
 }
 
-void WPA2DecryptTest::check_tkip_packet5(const PDU &pdu) {
-    const TCP *tcp = pdu.find_pdu<TCP>();
+void WPA2DecryptTest::check_tkip_packet5(const PDU& pdu) {
+    const TCP* tcp = pdu.find_pdu<TCP>();
     ASSERT_TRUE(tcp);
     EXPECT_EQ(tcp->sport(), 44934);
     EXPECT_EQ(tcp->dport(), 80);
     EXPECT_EQ(tcp->window(), 1215);
 }
 
-void WPA2DecryptTest::check_tkip_packet6(const PDU &pdu) {
-    const TCP *tcp = pdu.find_pdu<TCP>();
+void WPA2DecryptTest::check_tkip_packet6(const PDU& pdu) {
+    const TCP* tcp = pdu.find_pdu<TCP>();
     ASSERT_TRUE(tcp);
     EXPECT_EQ(tcp->sport(), 44934);
     EXPECT_EQ(tcp->dport(), 80);