diff --git a/examples/arpspoofing.cpp b/examples/arpspoofing.cpp
index 7b0130f..c47e3ba 100644
--- a/examples/arpspoofing.cpp
+++ b/examples/arpspoofing.cpp
@@ -28,6 +28,7 @@
 #include <tins/network_interface.h>
 #include <tins/utils.h>
 #include <tins/ethernetII.h>
+#include <tins/packet_sender.h>
 
 using namespace std;
 using namespace Tins;
@@ -40,13 +41,13 @@ int do_arp_spoofing(NetworkInterface iface, IPv4Address gw, IPv4Address victim,
     EthernetII::address_type gw_hw, victim_hw;
     
     // Resolves gateway's hardware address.
-    if(!Utils::resolve_hwaddr(iface, gw, &gw_hw, &sender)) {
+    if(!Utils::resolve_hwaddr(iface, gw, &gw_hw, sender)) {
         cout << "Could not resolve gateway's ip address.\n";
         return 5;
     }
     
     // Resolves victim's hardware address.
-    if(!Utils::resolve_hwaddr(iface, victim, &victim_hw, &sender)) {
+    if(!Utils::resolve_hwaddr(iface, victim, &victim_hw, sender)) {
         cout << "Could not resolve victim's ip address.\n";
         return 6;
     }
@@ -71,7 +72,7 @@ int do_arp_spoofing(NetworkInterface iface, IPv4Address gw, IPv4Address victim,
     EthernetII to_victim(iface, victim_hw, info.hw_addr, victim_arp);
     while(true) {
         // Just send them once every 5 seconds.
-        if(!sender.send(&to_gw) || !sender.send(&to_victim))
+        if(!sender.send(to_gw) || !sender.send(to_victim))
             return 7;
         sleep(5);
     }
diff --git a/examples/portscan.cpp b/examples/portscan.cpp
index ac92553..ad22888 100644
--- a/examples/portscan.cpp
+++ b/examples/portscan.cpp
@@ -27,12 +27,12 @@
 #include <pthread.h>
 #include <tins/ip.h>
 #include <tins/tcp.h>
-#include <tins/ipaddress.h>
+#include <tins/ip_address.h>
 #include <tins/ethernetII.h>
 #include <tins/network_interface.h>
 #include <tins/sniffer.h>
 #include <tins/utils.h>
-#include <tins/packetsender.h>
+#include <tins/packet_sender.h>
 
 
 using namespace std;
@@ -44,8 +44,8 @@ typedef std::pair<Sniffer*, std::string> sniffer_data;
 /* Our scan handler. This will receive SYNs and RSTs and inform us
  * the scanned port's status.
  */
-bool handler(PDU *pdu) {
-    TCP *tcp = pdu->find_pdu<TCP>();
+bool handler(PDU &pdu) {
+    TCP *tcp = pdu.find_pdu<TCP>();
     if(tcp) {
         // Ok, it's a TCP PDU. Is RST flag on? Then port is closed.
         if(tcp->get_flag(TCP::RST)) {
@@ -77,7 +77,7 @@ void send_syns(const NetworkInterface &iface, IPv4Address dest_ip, const vector<
     for(vector<string>::const_iterator it = ips.begin(); it != ips.end(); ++it) {
         // Set the new port and send the packet!
         tcp->dport(atoi(it->c_str()));
-        sender.send(&ip);
+        sender.send(ip);
     }
     // Wait 1 second.
     sleep(1);
@@ -89,7 +89,7 @@ void send_syns(const NetworkInterface &iface, IPv4Address dest_ip, const vector<
     ip.src_addr(dest_ip);
     // We use an ethernet pdu, otherwise the kernel will drop it.
     EthernetII eth(iface, info.hw_addr, info.hw_addr, ip.clone_pdu());
-    sender.send(&eth);
+    sender.send(eth);
 }
 
 void *thread_proc(void *param) {
diff --git a/examples/traceroute.cpp b/examples/traceroute.cpp
index 4a92161..6a5524b 100644
--- a/examples/traceroute.cpp
+++ b/examples/traceroute.cpp
@@ -92,9 +92,9 @@ private:
         sender.send(&ip);
     }
 
-    bool sniff_callback(PDU *pdu) {
-        IP *ip = pdu->find_pdu<IP>();
-        RawPDU *raw = pdu->find_pdu<RawPDU>();
+    bool sniff_callback(PDU &pdu) {
+        IP *ip = pdu.find_pdu<IP>();
+        RawPDU *raw = pdu.find_pdu<RawPDU>();
         if(ip && raw) {
             ttl_map::const_iterator iter;
             IP inner_ip;
diff --git a/include/dot11.h b/include/dot11.h
index bae5972..f4df509 100644
--- a/include/dot11.h
+++ b/include/dot11.h
@@ -377,7 +377,7 @@ namespace Tins {
         /**
          * \sa PDU::send()
          */
-        bool send(PacketSender* sender);
+        bool send(PacketSender &sender);
 
         /**
          * \brief Adds a new option to this Dot11 PDU.
diff --git a/include/ethernetII.h b/include/ethernetII.h
index 1c097ba..ee16d7c 100644
--- a/include/ethernetII.h
+++ b/include/ethernetII.h
@@ -147,7 +147,7 @@ namespace Tins {
         /**
          * \sa PDU::send()
          */
-        bool send(PacketSender* sender);
+        bool send(PacketSender &sender);
 
         /** \brief Check wether ptr points to a valid response for this PDU.
          *
@@ -162,7 +162,7 @@ namespace Tins {
          * \sa PDU::recv_response
          * \param sender The packet sender which will receive the packet.
          */
-        PDU *recv_response(PacketSender *sender);
+        PDU *recv_response(PacketSender &sender);
 
         /**
          * \brief Getter for the PDU's type.
diff --git a/include/ieee802_3.h b/include/ieee802_3.h
index b78e25a..550dce1 100644
--- a/include/ieee802_3.h
+++ b/include/ieee802_3.h
@@ -145,7 +145,7 @@ namespace Tins {
         /**
          * \sa PDU::send()
          */
-        bool send(PacketSender* sender);
+        bool send(PacketSender &sender);
 
         /** \brief Check wether ptr points to a valid response for this PDU.
          *
@@ -160,7 +160,7 @@ namespace Tins {
          * \sa PDU::recv_response
          * \param sender The packet sender which will receive the packet.
          */
-        PDU *recv_response(PacketSender *sender);
+        PDU *recv_response(PacketSender &sender);
 
         /**
          * \brief Getter for the PDU's type.
diff --git a/include/ip.h b/include/ip.h
index 34fdebc..d7a505e 100644
--- a/include/ip.h
+++ b/include/ip.h
@@ -510,7 +510,7 @@ namespace Tins {
         /**
          * \sa PDU::send()
          */
-        bool send(PacketSender* sender);
+        bool send(PacketSender &sender);
 
         /**
          * \brief Check wether ptr points to a valid response for this PDU.
@@ -527,7 +527,7 @@ namespace Tins {
          * \sa PDU::recv_response
          * \param sender The packet sender which will receive the packet.
          */
-        PDU *recv_response(PacketSender *sender);
+        PDU *recv_response(PacketSender &sender);
 
         /**
          * \brief Getter for the PDU's type.
diff --git a/include/packet_sender.h b/include/packet_sender.h
index 0af4f98..0f65fe8 100644
--- a/include/packet_sender.h
+++ b/include/packet_sender.h
@@ -96,7 +96,7 @@ namespace Tins {
          * \param pdu The PDU to send.
          * \return Returns true if the PDU is sent successfully, false otherwise.
          */
-        bool send(PDU* pdu);
+        bool send(PDU &pdu);
 
         /** \brief Sends a PDU and waits for its response. 
          * 
@@ -108,7 +108,7 @@ namespace Tins {
          * \param pdu The PDU to send.
          * \return Returns the response PDU, 0 if not response was received.
          */
-        PDU *send_recv(PDU *pdu);
+        PDU *send_recv(PDU &pdu);
 
         /** \brief Receives a layer 2 PDU response to a previously sent PDU.
          * 
@@ -120,7 +120,7 @@ namespace Tins {
          * \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);
+        PDU *recv_l2(PDU &pdu, struct sockaddr *link_addr, uint32_t len_addr);
 
         /** \brief Sends a level 2 PDU.
          * 
@@ -132,7 +132,7 @@ namespace Tins {
          * \param len_addr The sockaddr struct length.
          * \return Returns true if the PDU was successfully sent, false otherwise.
          */
-        bool send_l2(PDU *pdu, struct sockaddr* link_addr, uint32_t len_addr);
+        bool send_l2(PDU &pdu, struct sockaddr* link_addr, uint32_t len_addr);
 
         /** \brief Receives a layer 3 PDU response to a previously sent PDU.
          * 
@@ -145,7 +145,7 @@ namespace Tins {
          * \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);
+        PDU *recv_l3(PDU &pdu, struct sockaddr *link_addr, uint32_t len_addr, SocketType type);
 
         /** \brief Sends a level 3 PDU.
          * 
@@ -158,7 +158,7 @@ namespace Tins {
          * \param type The socket protocol type.
          * \return Returns true if the PDU was successfully sent, false otherwise.
          */
-        bool send_l3(PDU *pdu, struct sockaddr *link_addr, uint32_t len_addr, SocketType type);
+        bool send_l3(PDU &pdu, struct sockaddr *link_addr, uint32_t len_addr, SocketType type);
     private:
         static const int INVALID_RAW_SOCKET;
 
@@ -167,7 +167,7 @@ namespace Tins {
         int find_type(SocketType type);
         int timeval_subtract (struct timeval *result, struct timeval *x, struct timeval *y);
         
-        PDU *recv_match_loop(int sock, PDU *pdu, struct sockaddr* link_addr, uint32_t addrlen);
+        PDU *recv_match_loop(int sock, PDU &pdu, struct sockaddr* link_addr, uint32_t addrlen);
 
         std::vector<int> _sockets;
         SocketTypeMap _types;
diff --git a/include/pdu.h b/include/pdu.h
index 834032c..d92ba76 100644
--- a/include/pdu.h
+++ b/include/pdu.h
@@ -228,14 +228,14 @@ namespace Tins {
          * those methods.
          * \param sender The PacketSender which will send the packet.
          */
-        virtual bool send(PacketSender *sender);
+        virtual bool send(PacketSender &sender);
 
         /** \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.
          */
-        virtual PDU *recv_response(PacketSender *sender);
+        virtual PDU *recv_response(PacketSender &sender);
 
         /** \brief Check wether ptr points to a valid response for this PDU.
          *
diff --git a/include/radiotap.h b/include/radiotap.h
index 6661b41..41a8632 100644
--- a/include/radiotap.h
+++ b/include/radiotap.h
@@ -117,7 +117,7 @@ namespace Tins {
         /**
          * \sa PDU::send()
          */
-        bool send(PacketSender* sender);
+        bool send(PacketSender &sender);
         
         /**
          * \brief Setter for the version field.
diff --git a/include/sniffer.h b/include/sniffer.h
index 83b5831..38564c6 100644
--- a/include/sniffer.h
+++ b/include/sniffer.h
@@ -69,12 +69,12 @@ namespace Tins {
          * The callback object must implement an operator with the 
          * following(or compatible) signature:
          * 
-         * bool operator()(PDU*);
+         * bool operator()(PDU&);
          * 
          * This operator will be called using the sniffed packets 
-         * as arguments. The callback object <b>must not</b> delete the
-         * PDU parameter. You can modify it as you wish, though. Calling
-         * PDU methods like PDU::release_inner_pdu is perfectly valid.
+         * as arguments. You can modify the PDU argument as you wish. 
+         * Calling PDU methods like PDU::release_inner_pdu is perfectly 
+         * valid.
          * 
          * Note that the Functor object will be copied using its copy
          * constructor, so that object should be some kind of proxy to
@@ -128,6 +128,9 @@ namespace Tins {
         BaseSniffer(const BaseSniffer&);
         BaseSniffer &operator=(const BaseSniffer&);
         
+        template<class ConcretePDU, class Functor>
+        static bool call_functor(LoopData<Functor> *data, const u_char *packet, size_t len);
+        
         bool compile_set_filter(const std::string &filter, bpf_program &prog);
         
         template<class Functor>
@@ -185,16 +188,26 @@ namespace Tins {
         pcap_loop(handle, max_packets, &BaseSniffer::callback_handler<Functor>, (u_char*)&data);
     }
     
+    template<class ConcretePDU, class Functor>
+    bool Tins::BaseSniffer::call_functor(LoopData<Functor> *data, const u_char *packet, size_t len) {
+        ConcretePDU some_pdu((const uint8_t*)packet, len);
+        return data->c_handler(some_pdu);
+    }
+    
     template<class Functor>
     void Tins::BaseSniffer::callback_handler(u_char *args, const struct pcap_pkthdr *header, const u_char *packet) {
         try {
             std::auto_ptr<PDU> pdu;
             LoopData<Functor> *data = reinterpret_cast<LoopData<Functor>*>(args);
-            if(data->wired)
-                pdu.reset(new Tins::EthernetII((const uint8_t*)packet, header->caplen));
+            bool ret_val(false);
+            /*if(data->wired)
+                ret_val = data->c_handler(Tins::EthernetII((const uint8_t*)packet, header->caplen));
             else
-                pdu.reset(new Tins::RadioTap((const uint8_t*)packet, header->caplen));
-            bool ret_val = data->c_handler(pdu.get());
+                pdu.reset(new Tins::RadioTap((const uint8_t*)packet, header->caplen));*/
+            if(data->wired)
+                ret_val = call_functor<Tins::EthernetII>(data, packet, header->caplen);
+            else
+                ret_val = call_functor<Tins::RadioTap>(data, packet, header->caplen);
             if(!ret_val)
                 pcap_breakloop(data->handle);
         }
@@ -207,12 +220,12 @@ namespace Tins {
     class HandlerProxy {
     public:
         typedef T* ptr_type;
-        typedef bool (T::*fun_type)(PDU*) ;
+        typedef bool (T::*fun_type)(PDU&) ;
     
         HandlerProxy(ptr_type ptr, fun_type function) 
         : object(ptr), fun(function) {}
         
-        bool operator()(PDU *pdu) {
+        bool operator()(PDU &pdu) {
             return (object->*fun)(pdu);
         }
     private:
diff --git a/include/tcp_stream.h b/include/tcp_stream.h
index 5433fb5..2db935c 100644
--- a/include/tcp_stream.h
+++ b/include/tcp_stream.h
@@ -217,7 +217,7 @@ 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);
         }
         
@@ -227,7 +227,7 @@ private:
     };
     
     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);
     
     sessions_type sessions;
     uint64_t last_identifier;
@@ -241,9 +241,9 @@ void TCPStreamFollower::follow_streams(BaseSniffer &sniffer, DataFunctor data_fu
 }
 
 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>();
+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) {
         TCPStream::StreamInfo info = { 
             ip->src_addr(), ip->dst_addr(),
diff --git a/include/utils.h b/include/utils.h
index f58c58c..3c3bc80 100644
--- a/include/utils.h
+++ b/include/utils.h
@@ -79,23 +79,6 @@ namespace Tins {
          * \param to_resolve The domain name/ip address to resolve.
          */
         IPv4Address resolve_ip(const std::string &to_resolve);
-        
-        /**
-         * \brief Pings an ip address.
-         * 
-         * This function pings an IP address and returns the ICMP response.
-         * If no response is received, 0 is returned
-         * 
-         * \param ip The IP address to ping.
-         * \param sender The PacketSender that will send the ping request.
-         * \param ip_src The source IP address that will be used in the packet.
-         * If 0, or no parameter is provided, then that IP address is looked
-         * up using Utils::interface_ip.
-         * 
-         * \return PDU * containing either 0 if no response was received,
-         * or the ICMP response otherwise.
-         */
-        PDU *ping_address(IPv4Address ip, PacketSender *sender, IPv4Address ip_src = 0);
 
         /** \brief Resolves the hardware address for a given ip.
          *
@@ -107,7 +90,7 @@ namespace Tins {
          * false otherwise.
          */
         bool resolve_hwaddr(const NetworkInterface &iface, IPv4Address ip, 
-          HWAddress<6> *address, PacketSender *sender);
+          HWAddress<6> *address, PacketSender &sender);
 
         /** \brief List all network interfaces.
          *
diff --git a/src/dot11.cpp b/src/dot11.cpp
index 3f18f30..4f5a33b 100644
--- a/src/dot11.cpp
+++ b/src/dot11.cpp
@@ -155,7 +155,7 @@ uint32_t Dot11::header_size() const {
     return sz;
 }
 
-bool Dot11::send(PacketSender* sender) {
+bool Dot11::send(PacketSender &sender) {
     struct sockaddr_ll addr;
 
     memset(&addr, 0, sizeof(struct sockaddr_ll));
@@ -166,7 +166,7 @@ bool Dot11::send(PacketSender* sender) {
     addr.sll_ifindex = _iface.id();
     memcpy(&(addr.sll_addr), _header.addr1, 6);
 
-    return sender->send_l2(this, (struct sockaddr*)&addr, (uint32_t)sizeof(addr));
+    return sender.send_l2(*this, (struct sockaddr*)&addr, (uint32_t)sizeof(addr));
 }
 
 void Dot11::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent) {
diff --git a/src/ethernetII.cpp b/src/ethernetII.cpp
index 9283c2e..111259f 100644
--- a/src/ethernetII.cpp
+++ b/src/ethernetII.cpp
@@ -95,7 +95,7 @@ uint32_t EthernetII::header_size() const {
     return sizeof(ethhdr);
 }
 
-bool EthernetII::send(PacketSender* sender) {
+bool EthernetII::send(PacketSender &sender) {
     if(!_iface)
         throw std::runtime_error("Interface has not been set");
     struct sockaddr_ll addr;
@@ -108,7 +108,7 @@ bool EthernetII::send(PacketSender* sender) {
     addr.sll_ifindex = _iface.id();
     memcpy(&(addr.sll_addr), _eth.dst_mac, address_type::address_size);
 
-    return sender->send_l2(this, (struct sockaddr*)&addr, (uint32_t)sizeof(addr));
+    return sender.send_l2(*this, (struct sockaddr*)&addr, (uint32_t)sizeof(addr));
 }
 
 bool EthernetII::matches_response(uint8_t *ptr, uint32_t total_sz) {
@@ -144,7 +144,7 @@ void EthernetII::write_serialization(uint8_t *buffer, uint32_t total_sz, const P
     memcpy(buffer, &_eth, sizeof(ethhdr));
 }
 
-PDU *EthernetII::recv_response(PacketSender *sender) {
+PDU *EthernetII::recv_response(PacketSender &sender) {
     struct sockaddr_ll addr;
     memset(&addr, 0, sizeof(struct sockaddr_ll));
 
@@ -154,7 +154,7 @@ PDU *EthernetII::recv_response(PacketSender *sender) {
     addr.sll_ifindex = _iface.id();
     memcpy(&(addr.sll_addr), _eth.dst_mac, address_type::address_size);
 
-    return sender->recv_l2(this, (struct sockaddr*)&addr, (uint32_t)sizeof(addr));
+    return sender.recv_l2(*this, (struct sockaddr*)&addr, (uint32_t)sizeof(addr));
 }
 
 PDU *EthernetII::clone_packet(const uint8_t *ptr, uint32_t total_sz) {
diff --git a/src/ieee802_3.cpp b/src/ieee802_3.cpp
index 052823e..19ec6d0 100644
--- a/src/ieee802_3.cpp
+++ b/src/ieee802_3.cpp
@@ -80,7 +80,7 @@ uint32_t IEEE802_3::header_size() const {
     return sizeof(ethhdr);
 }
 
-bool IEEE802_3::send(PacketSender* sender) {
+bool IEEE802_3::send(PacketSender &sender) {
     struct sockaddr_ll addr;
 
     memset(&addr, 0, sizeof(struct sockaddr_ll));
@@ -91,7 +91,7 @@ bool IEEE802_3::send(PacketSender* sender) {
     addr.sll_ifindex = _iface.id();
     memcpy(&(addr.sll_addr), _eth.dst_mac, sizeof(_eth.dst_mac));
 
-    return sender->send_l2(this, (struct sockaddr*)&addr, (uint32_t)sizeof(addr));
+    return sender.send_l2(*this, (struct sockaddr*)&addr, (uint32_t)sizeof(addr));
 }
 
 bool IEEE802_3::matches_response(uint8_t *ptr, uint32_t total_sz) {
@@ -118,7 +118,7 @@ void IEEE802_3::write_serialization(uint8_t *buffer, uint32_t total_sz, const PD
     	_eth.length = 0;
 }
 
-PDU *IEEE802_3::recv_response(PacketSender *sender) {
+PDU *IEEE802_3::recv_response(PacketSender &sender) {
     struct sockaddr_ll addr;
     memset(&addr, 0, sizeof(struct sockaddr_ll));
 
@@ -128,7 +128,7 @@ PDU *IEEE802_3::recv_response(PacketSender *sender) {
     addr.sll_ifindex = _iface.id();
     memcpy(&(addr.sll_addr), _eth.dst_mac, sizeof(_eth.dst_mac));
 
-    return sender->recv_l2(this, (struct sockaddr*)&addr, (uint32_t)sizeof(addr));
+    return sender.recv_l2(*this, (struct sockaddr*)&addr, (uint32_t)sizeof(addr));
 }
 
 PDU *IEEE802_3::clone_packet(const uint8_t *ptr, uint32_t total_sz) {
diff --git a/src/ip.cpp b/src/ip.cpp
index 5805a0b..195878d 100644
--- a/src/ip.cpp
+++ b/src/ip.cpp
@@ -320,7 +320,7 @@ uint32_t IP::header_size() const {
     return sizeof(iphdr) + _padded_options_size;
 }
 
-bool IP::send(PacketSender* sender) {
+bool IP::send(PacketSender& sender) {
     struct sockaddr_in link_addr;
     PacketSender::SocketType type = PacketSender::IP_SOCKET;
     link_addr.sin_family = AF_INET;
@@ -329,10 +329,10 @@ bool IP::send(PacketSender* sender) {
     if(inner_pdu() && inner_pdu()->flag() == IPPROTO_ICMP)
         type = PacketSender::ICMP_SOCKET;
 
-    return sender->send_l3(this, (struct sockaddr*)&link_addr, sizeof(link_addr), type);
+    return sender.send_l3(*this, (struct sockaddr*)&link_addr, sizeof(link_addr), type);
 }
 
-PDU *IP::recv_response(PacketSender *sender) {
+PDU *IP::recv_response(PacketSender &sender) {
     struct sockaddr_in link_addr;
     PacketSender::SocketType type = PacketSender::IP_SOCKET;
     link_addr.sin_family = AF_INET;
@@ -341,7 +341,7 @@ PDU *IP::recv_response(PacketSender *sender) {
     if(inner_pdu() && inner_pdu()->flag() == IPPROTO_ICMP)
         type = PacketSender::ICMP_SOCKET;
 
-    return sender->recv_l3(this, (struct sockaddr*)&link_addr, sizeof(link_addr), type);
+    return sender.recv_l3(*this, (struct sockaddr*)&link_addr, sizeof(link_addr), type);
 }
 
 void IP::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU* parent) {
diff --git a/src/packet_sender.cpp b/src/packet_sender.cpp
index 2c7fb99..41ff6c4 100644
--- a/src/packet_sender.cpp
+++ b/src/packet_sender.cpp
@@ -90,22 +90,22 @@ bool Tins::PacketSender::close_socket(uint32_t flag) {
     return true;
 }
 
-bool Tins::PacketSender::send(PDU *pdu) {
-    return pdu->send(this);
+bool Tins::PacketSender::send(PDU &pdu) {
+    return pdu.send(*this);
 }
 
-Tins::PDU *Tins::PacketSender::send_recv(PDU *pdu) {
-    if(!pdu->send(this))
+Tins::PDU *Tins::PacketSender::send_recv(PDU &pdu) {
+    if(!pdu.send(*this))
         return 0;
-    return pdu->recv_response(this);
+    return pdu.recv_response(*this);
 }
 
-bool Tins::PacketSender::send_l2(PDU *pdu, struct sockaddr* link_addr, uint32_t len_addr) {
+bool Tins::PacketSender::send_l2(PDU &pdu, struct sockaddr* link_addr, uint32_t len_addr) {
     if(!open_l2_socket())
         return false;
 
     int sock = _sockets[ETHER_SOCKET];
-    PDU::serialization_type buffer = pdu->serialize();
+    PDU::serialization_type buffer = pdu.serialize();
     if(buffer.size() == 0)
         return false;
     bool ret_val = (sendto(sock, &buffer[0], buffer.size(), 0, link_addr, len_addr) != -1);
@@ -113,31 +113,31 @@ bool Tins::PacketSender::send_l2(PDU *pdu, struct sockaddr* link_addr, uint32_t
     return ret_val;
 }
 
-Tins::PDU *Tins::PacketSender::recv_l2(PDU *pdu, struct sockaddr *link_addr, uint32_t len_addr) {
+Tins::PDU *Tins::PacketSender::recv_l2(PDU &pdu, struct sockaddr *link_addr, uint32_t len_addr) {
     if(!open_l2_socket())
         return 0;
     return recv_match_loop(_sockets[ETHER_SOCKET], pdu, link_addr, len_addr);
 }
 
-Tins::PDU *Tins::PacketSender::recv_l3(PDU *pdu, struct sockaddr* link_addr, uint32_t len_addr, SocketType type) {
+Tins::PDU *Tins::PacketSender::recv_l3(PDU &pdu, struct sockaddr* link_addr, uint32_t len_addr, SocketType type) {
     if(!open_l3_socket(type))
         return 0;
     return recv_match_loop(_sockets[type], pdu, link_addr, len_addr);
 }
 
-bool Tins::PacketSender::send_l3(PDU *pdu, struct sockaddr* link_addr, uint32_t len_addr, SocketType type) {
+bool Tins::PacketSender::send_l3(PDU &pdu, struct sockaddr* link_addr, uint32_t len_addr, SocketType type) {
     bool ret_val = true;
     if(!open_l3_socket(type))
         ret_val = false;
     if (ret_val) {
         int sock = _sockets[type];
-        PDU::serialization_type buffer = pdu->serialize();
+        PDU::serialization_type buffer = pdu.serialize();
         ret_val = (sendto(sock, &buffer[0], buffer.size(), 0, link_addr, len_addr) != -1);
     }
     return ret_val;
 }
 
-Tins::PDU *Tins::PacketSender::recv_match_loop(int sock, PDU *pdu, struct sockaddr* link_addr, uint32_t addrlen) {
+Tins::PDU *Tins::PacketSender::recv_match_loop(int sock, PDU &pdu, struct sockaddr* link_addr, uint32_t addrlen) {
     fd_set readfds;
     struct timeval timeout,  end_time;
     int read;
@@ -153,8 +153,8 @@ Tins::PDU *Tins::PacketSender::recv_match_loop(int sock, PDU *pdu, struct sockad
         }
         if(FD_ISSET(sock, &readfds)) {
             ssize_t size = recvfrom(sock, buffer, 2048, 0, link_addr, &addrlen);
-            if(pdu->matches_response(buffer, size)) {
-                return pdu->clone_packet(buffer, size);
+            if(pdu.matches_response(buffer, size)) {
+                return pdu.clone_packet(buffer, size);
             }
         }
         struct timeval this_time, diff;
diff --git a/src/pdu.cpp b/src/pdu.cpp
index d5a7a03..04081ad 100644
--- a/src/pdu.cpp
+++ b/src/pdu.cpp
@@ -60,11 +60,11 @@ uint32_t PDU::size() const {
     return sz;
 }
 
-bool PDU::send(PacketSender *) { 
+bool PDU::send(PacketSender &) { 
     return false; 
 }
 
-PDU *PDU::recv_response(PacketSender *) { 
+PDU *PDU::recv_response(PacketSender &) { 
     return false; 
 }
 
diff --git a/src/radiotap.cpp b/src/radiotap.cpp
index d614926..98e86c2 100644
--- a/src/radiotap.cpp
+++ b/src/radiotap.cpp
@@ -196,7 +196,7 @@ uint32_t Tins::RadioTap::trailer_size() const {
     return ((_flags & 0x10) != 0) ? sizeof(uint32_t) : 0;
 }
 
-bool Tins::RadioTap::send(PacketSender* sender) {
+bool Tins::RadioTap::send(PacketSender &sender) {
     struct sockaddr_ll addr;
 
     memset(&addr, 0, sizeof(struct sockaddr_ll));
@@ -212,7 +212,7 @@ bool Tins::RadioTap::send(PacketSender* sender) {
         std::copy(dot11_addr.begin(), dot11_addr.end(), addr.sll_addr);
     }
 
-    return sender->send_l2(this, (struct sockaddr*)&addr, (uint32_t)sizeof(addr));
+    return sender.send_l2(*this, (struct sockaddr*)&addr, (uint32_t)sizeof(addr));
 }
 
 void Tins::RadioTap::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent) {
diff --git a/src/utils.cpp b/src/utils.cpp
index d9a9434..f25cf1a 100644
--- a/src/utils.cpp
+++ b/src/utils.cpp
@@ -102,27 +102,13 @@ IPv4Address Utils::resolve_ip(const string &to_resolve) {
     return IPv4Address(((struct in_addr**)data->h_addr_list)[0]->s_addr);
 }
 
-PDU *Utils::ping_address(IPv4Address ip, PacketSender *sender, IPv4Address ip_src) {
-    if(!ip_src) {
-        try {
-            NetworkInterface iface(ip);
-            ip_src = iface.addresses().ip_addr;
-        } catch(...) {
-            return 0;
-        }
-    }
-    ICMP *icmp = new ICMP(ICMP::ECHO_REQUEST);
-    IP ip_packet(ip, ip_src, icmp);
-    return sender->send_recv(&ip_packet);
-}
-
 bool Utils::resolve_hwaddr(const NetworkInterface &iface, IPv4Address ip, 
-  HWAddress<6> *address, PacketSender *sender) 
+  HWAddress<6> *address, PacketSender &sender) 
 {
     IPv4Address my_ip;
     NetworkInterface::Info info(iface.addresses());
     std::auto_ptr<PDU> packet(ARP::make_arp_request(iface, ip, info.ip_addr, info.hw_addr));
-    std::auto_ptr<PDU> response(sender->send_recv(packet.get()));
+    std::auto_ptr<PDU> response(sender.send_recv(*packet));
     if(response.get()) {
         ARP *arp_resp = response->find_pdu<ARP>();
         if(arp_resp)