3rd-party/libtins
1
0
Fork 0
mirror of https://github.com/mfontanini/libtins synced 2026-01-23 02:35:57 +01:00
Code Issues Releases Wiki Activity

Modified some PacketSender and BaseSniffer functions to take references instead of pointers.

Browse Source
This commit is contained in:
Matias Fontanini
2012-09-11 08:51:25 -03:00
parent b977697367
commit 7cbd32361a
21 changed files with 93 additions and 110 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
examples/arpspoofing.cpp
View File

@@ -28,6 +28,7 @@
#include <tins/network_interface.h> #include <tins/network_interface.h>
#include <tins/utils.h> #include <tins/utils.h>
#include <tins/ethernetII.h> #include <tins/ethernetII.h>
#include <tins/packet_sender.h>
using namespace std; using namespace std;
using namespace Tins; using namespace Tins;
@@ -40,13 +41,13 @@ int do_arp_spoofing(NetworkInterface iface, IPv4Address gw, IPv4Address victim,
EthernetII::address_type gw_hw, victim_hw; EthernetII::address_type gw_hw, victim_hw;
// Resolves gateway's hardware address. // 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"; cout << "Could not resolve gateway's ip address.\n";
return 5; return 5;
} }
// Resolves victim's hardware address. // 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"; cout << "Could not resolve victim's ip address.\n";
return 6; 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); EthernetII to_victim(iface, victim_hw, info.hw_addr, victim_arp);
while(true) { while(true) {
// Just send them once every 5 seconds. // 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; return 7;
sleep(5); sleep(5);
} }

12
examples/portscan.cpp
View File

@@ -27,12 +27,12 @@
#include <pthread.h> #include <pthread.h>
#include <tins/ip.h> #include <tins/ip.h>
#include <tins/tcp.h> #include <tins/tcp.h>
#include <tins/ipaddress.h> #include <tins/ip_address.h>
#include <tins/ethernetII.h> #include <tins/ethernetII.h>
#include <tins/network_interface.h> #include <tins/network_interface.h>
#include <tins/sniffer.h> #include <tins/sniffer.h>
#include <tins/utils.h> #include <tins/utils.h>
#include <tins/packetsender.h> #include <tins/packet_sender.h>
using namespace std; 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 /* Our scan handler. This will receive SYNs and RSTs and inform us
* the scanned port's status. * the scanned port's status.
*/ */
bool handler(PDU *pdu) { bool handler(PDU &pdu) {
TCP *tcp = pdu->find_pdu<TCP>(); TCP *tcp = pdu.find_pdu<TCP>();
if(tcp) { if(tcp) {
// Ok, it's a TCP PDU. Is RST flag on? Then port is closed. // Ok, it's a TCP PDU. Is RST flag on? Then port is closed.
if(tcp->get_flag(TCP::RST)) { 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) { for(vector<string>::const_iterator it = ips.begin(); it != ips.end(); ++it) {
// Set the new port and send the packet! // Set the new port and send the packet!
tcp->dport(atoi(it->c_str())); tcp->dport(atoi(it->c_str()));
sender.send(&ip); sender.send(ip);
} }
// Wait 1 second. // Wait 1 second.
sleep(1); sleep(1);
@@ -89,7 +89,7 @@ void send_syns(const NetworkInterface &iface, IPv4Address dest_ip, const vector<
ip.src_addr(dest_ip); ip.src_addr(dest_ip);
// We use an ethernet pdu, otherwise the kernel will drop it. // We use an ethernet pdu, otherwise the kernel will drop it.
EthernetII eth(iface, info.hw_addr, info.hw_addr, ip.clone_pdu()); EthernetII eth(iface, info.hw_addr, info.hw_addr, ip.clone_pdu());
sender.send(&eth); sender.send(eth);
} }
void *thread_proc(void *param) { void *thread_proc(void *param) {

6
examples/traceroute.cpp
View File

@@ -92,9 +92,9 @@ private:
sender.send(&ip); sender.send(&ip);
} }
bool sniff_callback(PDU *pdu) { bool sniff_callback(PDU &pdu) {
IP *ip = pdu->find_pdu<IP>(); IP *ip = pdu.find_pdu<IP>();
RawPDU *raw = pdu->find_pdu<RawPDU>(); RawPDU *raw = pdu.find_pdu<RawPDU>();
if(ip && raw) { if(ip && raw) {
ttl_map::const_iterator iter; ttl_map::const_iterator iter;
IP inner_ip; IP inner_ip;

2
include/dot11.h
View File

@@ -377,7 +377,7 @@ namespace Tins {
/** /**
* \sa PDU::send() * \sa PDU::send()
*/ */
bool send(PacketSender* sender); bool send(PacketSender &sender);
/** /**
* \brief Adds a new option to this Dot11 PDU. * \brief Adds a new option to this Dot11 PDU.

4
include/ethernetII.h
View File

@@ -147,7 +147,7 @@ namespace Tins {
/** /**
* \sa PDU::send() * \sa PDU::send()
*/ */
bool send(PacketSender* sender); bool send(PacketSender &sender);
/** \brief Check wether ptr points to a valid response for this PDU. /** \brief Check wether ptr points to a valid response for this PDU.
* *
@@ -162,7 +162,7 @@ namespace Tins {
* \sa PDU::recv_response * \sa PDU::recv_response
* \param sender The packet sender which will receive the packet. * \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. * \brief Getter for the PDU's type.

4
include/ieee802_3.h
View File

@@ -145,7 +145,7 @@ namespace Tins {
/** /**
* \sa PDU::send() * \sa PDU::send()
*/ */
bool send(PacketSender* sender); bool send(PacketSender &sender);
/** \brief Check wether ptr points to a valid response for this PDU. /** \brief Check wether ptr points to a valid response for this PDU.
* *
@@ -160,7 +160,7 @@ namespace Tins {
* \sa PDU::recv_response * \sa PDU::recv_response
* \param sender The packet sender which will receive the packet. * \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. * \brief Getter for the PDU's type.

4
include/ip.h
View File

@@ -510,7 +510,7 @@ namespace Tins {
/** /**
* \sa PDU::send() * \sa PDU::send()
*/ */
bool send(PacketSender* sender); bool send(PacketSender &sender);
/** /**
* \brief Check wether ptr points to a valid response for this PDU. * \brief Check wether ptr points to a valid response for this PDU.
@@ -527,7 +527,7 @@ namespace Tins {
* \sa PDU::recv_response * \sa PDU::recv_response
* \param sender The packet sender which will receive the packet. * \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. * \brief Getter for the PDU's type.

14
include/packet_sender.h
View File

@@ -96,7 +96,7 @@ namespace Tins {
* \param pdu The PDU to send. * \param pdu The PDU to send.
* \return Returns true if the PDU is sent successfully, false otherwise. * \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. /** \brief Sends a PDU and waits for its response.
* *
@@ -108,7 +108,7 @@ namespace Tins {
* \param pdu The PDU to send. * \param pdu The PDU to send.
* \return Returns the response PDU, 0 if not response was received. * \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. /** \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. * \param len_addr The sockaddr struct length.
* \return Returns the response PDU. If no response is received, then 0 is returned. * \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. /** \brief Sends a level 2 PDU.
* *
@@ -132,7 +132,7 @@ namespace Tins {
* \param len_addr The sockaddr struct length. * \param len_addr The sockaddr struct length.
* \return Returns true if the PDU was successfully sent, false otherwise. * \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. /** \brief Receives a layer 3 PDU response to a previously sent PDU.
* *
@@ -145,7 +145,7 @@ namespace Tins {
* \param type The socket protocol type. * \param type The socket protocol type.
* \return Returns the response PDU. If no response is received, then 0 is returned. * \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. /** \brief Sends a level 3 PDU.
* *
@@ -158,7 +158,7 @@ namespace Tins {
* \param type The socket protocol type. * \param type The socket protocol type.
* \return Returns true if the PDU was successfully sent, false otherwise. * \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: private:
static const int INVALID_RAW_SOCKET; static const int INVALID_RAW_SOCKET;
@@ -167,7 +167,7 @@ namespace Tins {
int find_type(SocketType type); int find_type(SocketType type);
int timeval_subtract (struct timeval *result, struct timeval *x, struct timeval *y); 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; std::vector<int> _sockets;
SocketTypeMap _types; SocketTypeMap _types;

4
include/pdu.h
View File

@@ -228,14 +228,14 @@ namespace Tins {
* those methods. * those methods.
* \param sender The PacketSender which will send the packet. * \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. /** \brief Receives a matching response for this packet.
* *
* This method should act as a proxy for PacketSender::recv_lX methods. * This method should act as a proxy for PacketSender::recv_lX methods.
* \param sender The packet sender which will receive the packet. * \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. /** \brief Check wether ptr points to a valid response for this PDU.
* *

2
include/radiotap.h
View File

@@ -117,7 +117,7 @@ namespace Tins {
/** /**
* \sa PDU::send() * \sa PDU::send()
*/ */
bool send(PacketSender* sender); bool send(PacketSender &sender);
/** /**
* \brief Setter for the version field. * \brief Setter for the version field.

33
include/sniffer.h
View File

@@ -69,12 +69,12 @@ namespace Tins {
* The callback object must implement an operator with the * The callback object must implement an operator with the
* following(or compatible) signature: * following(or compatible) signature:
* *
* bool operator()(PDU*); * bool operator()(PDU&);
* *
* This operator will be called using the sniffed packets * This operator will be called using the sniffed packets
* as arguments. The callback object <b>must not</b> delete the * as arguments. You can modify the PDU argument as you wish.
* PDU parameter. You can modify it as you wish, though. Calling * Calling PDU methods like PDU::release_inner_pdu is perfectly
* PDU methods like PDU::release_inner_pdu is perfectly valid. * valid.
* *
* Note that the Functor object will be copied using its copy * Note that the Functor object will be copied using its copy
* constructor, so that object should be some kind of proxy to * constructor, so that object should be some kind of proxy to
@@ -128,6 +128,9 @@ namespace Tins {
BaseSniffer(const BaseSniffer&); BaseSniffer(const BaseSniffer&);
BaseSniffer &operator=(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); bool compile_set_filter(const std::string &filter, bpf_program &prog);
template<class Functor> template<class Functor>
@@ -185,16 +188,26 @@ namespace Tins {
pcap_loop(handle, max_packets, &BaseSniffer::callback_handler<Functor>, (u_char*)&data); 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> template<class Functor>
void Tins::BaseSniffer::callback_handler(u_char *args, const struct pcap_pkthdr *header, const u_char *packet) { void Tins::BaseSniffer::callback_handler(u_char *args, const struct pcap_pkthdr *header, const u_char *packet) {
try { try {
std::auto_ptr<PDU> pdu; std::auto_ptr<PDU> pdu;
LoopData<Functor> *data = reinterpret_cast<LoopData<Functor>*>(args); LoopData<Functor> *data = reinterpret_cast<LoopData<Functor>*>(args);
if(data->wired) bool ret_val(false);
pdu.reset(new Tins::EthernetII((const uint8_t*)packet, header->caplen)); /*if(data->wired)
ret_val = data->c_handler(Tins::EthernetII((const uint8_t*)packet, header->caplen));
else else
pdu.reset(new Tins::RadioTap((const uint8_t*)packet, header->caplen)); pdu.reset(new Tins::RadioTap((const uint8_t*)packet, header->caplen));*/
bool ret_val = data->c_handler(pdu.get()); 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) if(!ret_val)
pcap_breakloop(data->handle); pcap_breakloop(data->handle);
} }
@@ -207,12 +220,12 @@ namespace Tins {
class HandlerProxy { class HandlerProxy {
public: public:
typedef T* ptr_type; typedef T* ptr_type;
typedef bool (T::*fun_type)(PDU*) ; typedef bool (T::*fun_type)(PDU&) ;
HandlerProxy(ptr_type ptr, fun_type function) HandlerProxy(ptr_type ptr, fun_type function)
: object(ptr), fun(function) {} : object(ptr), fun(function) {}
bool operator()(PDU *pdu) { bool operator()(PDU &pdu) {
return (object->*fun)(pdu); return (object->*fun)(pdu);
} }
private: private:

10
include/tcp_stream.h
View File

@@ -217,7 +217,7 @@ private:
template<typename DataFunctor, typename EndFunctor> template<typename DataFunctor, typename EndFunctor>
struct proxy_caller { struct proxy_caller {
bool callback(PDU *pdu) { bool callback(PDU &pdu) {
return stream->callback(pdu, data_fun, end_fun); return stream->callback(pdu, data_fun, end_fun);
} }
@@ -227,7 +227,7 @@ private:
}; };
template<typename DataFunctor, typename EndFunctor> 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; sessions_type sessions;
uint64_t last_identifier; uint64_t last_identifier;
@@ -241,9 +241,9 @@ void TCPStreamFollower::follow_streams(BaseSniffer &sniffer, DataFunctor data_fu
} }
template<typename DataFunctor, typename EndFunctor> template<typename DataFunctor, typename EndFunctor>
bool TCPStreamFollower::callback(PDU *pdu, const DataFunctor &data_fun, const EndFunctor &end_fun) { bool TCPStreamFollower::callback(PDU &pdu, const DataFunctor &data_fun, const EndFunctor &end_fun) {
IP *ip = pdu->find_pdu<IP>(); IP *ip = pdu.find_pdu<IP>();
TCP *tcp = pdu->find_pdu<TCP>(); TCP *tcp = pdu.find_pdu<TCP>();
if(ip && tcp) { if(ip && tcp) {
TCPStream::StreamInfo info = { TCPStream::StreamInfo info = {
ip->src_addr(), ip->dst_addr(), ip->src_addr(), ip->dst_addr(),

19
include/utils.h
View File

@@ -79,23 +79,6 @@ namespace Tins {
* \param to_resolve The domain name/ip address to resolve. * \param to_resolve The domain name/ip address to resolve.
*/ */
IPv4Address resolve_ip(const std::string &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. /** \brief Resolves the hardware address for a given ip.
* *
@@ -107,7 +90,7 @@ namespace Tins {
* false otherwise. * false otherwise.
*/ */
bool resolve_hwaddr(const NetworkInterface &iface, IPv4Address ip, bool resolve_hwaddr(const NetworkInterface &iface, IPv4Address ip,
HWAddress<6> *address, PacketSender *sender); HWAddress<6> *address, PacketSender &sender);
/** \brief List all network interfaces. /** \brief List all network interfaces.
* *

4
src/dot11.cpp
View File

@@ -155,7 +155,7 @@ uint32_t Dot11::header_size() const {
return sz; return sz;
} }
bool Dot11::send(PacketSender* sender) { bool Dot11::send(PacketSender &sender) {
struct sockaddr_ll addr; struct sockaddr_ll addr;
memset(&addr, 0, sizeof(struct sockaddr_ll)); memset(&addr, 0, sizeof(struct sockaddr_ll));
@@ -166,7 +166,7 @@ bool Dot11::send(PacketSender* sender) {
addr.sll_ifindex = _iface.id(); addr.sll_ifindex = _iface.id();
memcpy(&(addr.sll_addr), _header.addr1, 6); 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) { void Dot11::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent) {

8
src/ethernetII.cpp
View File

@@ -95,7 +95,7 @@ uint32_t EthernetII::header_size() const {
return sizeof(ethhdr); return sizeof(ethhdr);
} }
bool EthernetII::send(PacketSender* sender) { bool EthernetII::send(PacketSender &sender) {
if(!_iface) if(!_iface)
throw std::runtime_error("Interface has not been set"); throw std::runtime_error("Interface has not been set");
struct sockaddr_ll addr; struct sockaddr_ll addr;
@@ -108,7 +108,7 @@ bool EthernetII::send(PacketSender* sender) {
addr.sll_ifindex = _iface.id(); addr.sll_ifindex = _iface.id();
memcpy(&(addr.sll_addr), _eth.dst_mac, address_type::address_size); 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) { 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)); memcpy(buffer, &_eth, sizeof(ethhdr));
} }
PDU *EthernetII::recv_response(PacketSender *sender) { PDU *EthernetII::recv_response(PacketSender &sender) {
struct sockaddr_ll addr; struct sockaddr_ll addr;
memset(&addr, 0, sizeof(struct sockaddr_ll)); memset(&addr, 0, sizeof(struct sockaddr_ll));
@@ -154,7 +154,7 @@ PDU *EthernetII::recv_response(PacketSender *sender) {
addr.sll_ifindex = _iface.id(); addr.sll_ifindex = _iface.id();
memcpy(&(addr.sll_addr), _eth.dst_mac, address_type::address_size); 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) { PDU *EthernetII::clone_packet(const uint8_t *ptr, uint32_t total_sz) {

8
src/ieee802_3.cpp
View File

@@ -80,7 +80,7 @@ uint32_t IEEE802_3::header_size() const {
return sizeof(ethhdr); return sizeof(ethhdr);
} }
bool IEEE802_3::send(PacketSender* sender) { bool IEEE802_3::send(PacketSender &sender) {
struct sockaddr_ll addr; struct sockaddr_ll addr;
memset(&addr, 0, sizeof(struct sockaddr_ll)); memset(&addr, 0, sizeof(struct sockaddr_ll));
@@ -91,7 +91,7 @@ bool IEEE802_3::send(PacketSender* sender) {
addr.sll_ifindex = _iface.id(); addr.sll_ifindex = _iface.id();
memcpy(&(addr.sll_addr), _eth.dst_mac, sizeof(_eth.dst_mac)); 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) { 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; _eth.length = 0;
} }
PDU *IEEE802_3::recv_response(PacketSender *sender) { PDU *IEEE802_3::recv_response(PacketSender &sender) {
struct sockaddr_ll addr; struct sockaddr_ll addr;
memset(&addr, 0, sizeof(struct sockaddr_ll)); memset(&addr, 0, sizeof(struct sockaddr_ll));
@@ -128,7 +128,7 @@ PDU *IEEE802_3::recv_response(PacketSender *sender) {
addr.sll_ifindex = _iface.id(); addr.sll_ifindex = _iface.id();
memcpy(&(addr.sll_addr), _eth.dst_mac, sizeof(_eth.dst_mac)); 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) { PDU *IEEE802_3::clone_packet(const uint8_t *ptr, uint32_t total_sz) {

8
src/ip.cpp
View File

@@ -320,7 +320,7 @@ uint32_t IP::header_size() const {
return sizeof(iphdr) + _padded_options_size; return sizeof(iphdr) + _padded_options_size;
} }
bool IP::send(PacketSender* sender) { bool IP::send(PacketSender& sender) {
struct sockaddr_in link_addr; struct sockaddr_in link_addr;
PacketSender::SocketType type = PacketSender::IP_SOCKET; PacketSender::SocketType type = PacketSender::IP_SOCKET;
link_addr.sin_family = AF_INET; link_addr.sin_family = AF_INET;
@@ -329,10 +329,10 @@ bool IP::send(PacketSender* sender) {
if(inner_pdu() && inner_pdu()->flag() == IPPROTO_ICMP) if(inner_pdu() && inner_pdu()->flag() == IPPROTO_ICMP)
type = PacketSender::ICMP_SOCKET; 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; struct sockaddr_in link_addr;
PacketSender::SocketType type = PacketSender::IP_SOCKET; PacketSender::SocketType type = PacketSender::IP_SOCKET;
link_addr.sin_family = AF_INET; link_addr.sin_family = AF_INET;
@@ -341,7 +341,7 @@ PDU *IP::recv_response(PacketSender *sender) {
if(inner_pdu() && inner_pdu()->flag() == IPPROTO_ICMP) if(inner_pdu() && inner_pdu()->flag() == IPPROTO_ICMP)
type = PacketSender::ICMP_SOCKET; 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) { void IP::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU* parent) {

28
src/packet_sender.cpp
View File

@@ -90,22 +90,22 @@ bool Tins::PacketSender::close_socket(uint32_t flag) {
return true; return true;
} }
bool Tins::PacketSender::send(PDU *pdu) { bool Tins::PacketSender::send(PDU &pdu) {
return pdu->send(this); return pdu.send(*this);
} }
Tins::PDU *Tins::PacketSender::send_recv(PDU *pdu) { Tins::PDU *Tins::PacketSender::send_recv(PDU &pdu) {
if(!pdu->send(this)) if(!pdu.send(*this))
return 0; 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()) if(!open_l2_socket())
return false; return false;
int sock = _sockets[ETHER_SOCKET]; int sock = _sockets[ETHER_SOCKET];
PDU::serialization_type buffer = pdu->serialize(); PDU::serialization_type buffer = pdu.serialize();
if(buffer.size() == 0) if(buffer.size() == 0)
return false; return false;
bool ret_val = (sendto(sock, &buffer[0], buffer.size(), 0, link_addr, len_addr) != -1); 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; 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()) if(!open_l2_socket())
return 0; return 0;
return recv_match_loop(_sockets[ETHER_SOCKET], pdu, link_addr, len_addr); 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)) if(!open_l3_socket(type))
return 0; return 0;
return recv_match_loop(_sockets[type], pdu, link_addr, len_addr); 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; bool ret_val = true;
if(!open_l3_socket(type)) if(!open_l3_socket(type))
ret_val = false; ret_val = false;
if (ret_val) { if (ret_val) {
int sock = _sockets[type]; 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); ret_val = (sendto(sock, &buffer[0], buffer.size(), 0, link_addr, len_addr) != -1);
} }
return ret_val; 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; fd_set readfds;
struct timeval timeout, end_time; struct timeval timeout, end_time;
int read; int read;
@@ -153,8 +153,8 @@ Tins::PDU *Tins::PacketSender::recv_match_loop(int sock, PDU *pdu, struct sockad
} }
if(FD_ISSET(sock, &readfds)) { if(FD_ISSET(sock, &readfds)) {
ssize_t size = recvfrom(sock, buffer, 2048, 0, link_addr, &addrlen); ssize_t size = recvfrom(sock, buffer, 2048, 0, link_addr, &addrlen);
if(pdu->matches_response(buffer, size)) { if(pdu.matches_response(buffer, size)) {
return pdu->clone_packet(buffer, size); return pdu.clone_packet(buffer, size);
} }
} }
struct timeval this_time, diff; struct timeval this_time, diff;

4
src/pdu.cpp
View File

@@ -60,11 +60,11 @@ uint32_t PDU::size() const {
return sz; return sz;
} }
bool PDU::send(PacketSender *) { bool PDU::send(PacketSender &) {
return false; return false;
} }
PDU *PDU::recv_response(PacketSender *) { PDU *PDU::recv_response(PacketSender &) {
return false; return false;
} }

4
src/radiotap.cpp
View File

@@ -196,7 +196,7 @@ uint32_t Tins::RadioTap::trailer_size() const {
return ((_flags & 0x10) != 0) ? sizeof(uint32_t) : 0; return ((_flags & 0x10) != 0) ? sizeof(uint32_t) : 0;
} }
bool Tins::RadioTap::send(PacketSender* sender) { bool Tins::RadioTap::send(PacketSender &sender) {
struct sockaddr_ll addr; struct sockaddr_ll addr;
memset(&addr, 0, sizeof(struct sockaddr_ll)); 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); 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) { void Tins::RadioTap::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent) {

18
src/utils.cpp
View File

@@ -102,27 +102,13 @@ IPv4Address Utils::resolve_ip(const string &to_resolve) {
return IPv4Address(((struct in_addr**)data->h_addr_list)[0]->s_addr); 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, bool Utils::resolve_hwaddr(const NetworkInterface &iface, IPv4Address ip,
HWAddress<6> *address, PacketSender *sender) HWAddress<6> *address, PacketSender &sender)
{ {
IPv4Address my_ip; IPv4Address my_ip;
NetworkInterface::Info info(iface.addresses()); 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> 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()) { if(response.get()) {
ARP *arp_resp = response->find_pdu<ARP>(); ARP *arp_resp = response->find_pdu<ARP>();
if(arp_resp) if(arp_resp)