Code cleanup and use same syntax on the entire project

Initial code cleanup

More code cleanup

Cleanup more code

Cleanup Dot11 code

Fix OSX build issue

Cleanup examples

Fix ref and pointer declaration syntax

Fix braces

examples/arpmonitor.cpp

@@ -32,58 +32,60 @@
 #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
         )
     );
 }
 
-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;

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,17 +95,19 @@ 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 {
         // Convert dotted-notation ip addresses to integer. 
         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;
     }
 }

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);
 }

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

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,27 +69,26 @@ 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);
         }
     }
     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