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

12
examples/portscan.cpp
View File

@@ -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) {

6
examples/traceroute.cpp
View File

@@ -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;

2
include/dot11.h
View File

@@ -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.

4
include/ethernetII.h
View File

@@ -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.

4
include/ieee802_3.h
View File

@@ -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.

4
include/ip.h
View File

@@ -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.

14
include/packet_sender.h
View File

@@ -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;

4
include/pdu.h
View File

@@ -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.
*

2
include/radiotap.h
View File

@@ -117,7 +117,7 @@ namespace Tins {
/**
* \sa PDU::send()
*/
bool send(PacketSender* sender);
bool send(PacketSender &sender);
/**
* \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
* 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:

10
include/tcp_stream.h
View File

@@ -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(),

19
include/utils.h
View File

@@ -80,23 +80,6 @@ namespace Tins {
*/
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.
*
* \param iface The interface in which the packet will be sent.
@@ -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.
*

4
src/dot11.cpp
View File

@@ -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) {

8
src/ethernetII.cpp
View File

@@ -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) {

8
src/ieee802_3.cpp
View File

@@ -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) {

8
src/ip.cpp
View File

@@ -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) {

28
src/packet_sender.cpp
View File

@@ -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;

4
src/pdu.cpp
View File

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

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

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