sniffer.h

/*
 * Copyright (c) 2017, Matias Fontanini
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 * * Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * * Redistributions in binary form must reproduce the above
 *   copyright notice, this list of conditions and the following disclaimer
 *   in the documentation and/or other materials provided with the
 *   distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */


#ifndef TINS_SNIFFER_H
#define TINS_SNIFFER_H

#include <string>
#include <memory>
#include <iterator>
#include <tins/pdu.h>
#include <tins/packet.h>
#include <tins/cxxstd.h>
#include <tins/macros.h>
#include <tins/exceptions.h>
#include <tins/detail/type_traits.h>

#ifdef TINS_HAVE_PCAP

#include <pcap.h>


namespace Tins {
class SnifferIterator;
class SnifferConfiguration;

class TINS_API BaseSniffer {
public:
    typedef SnifferIterator iterator;

    #if TINS_IS_CXX11

        BaseSniffer(BaseSniffer &&rhs) TINS_NOEXCEPT
        : handle_(0), mask_(), extract_raw_(false),
          pcap_sniffing_method_(pcap_loop) {
            *this = std::move(rhs);
        }

        BaseSniffer& operator=(BaseSniffer &&rhs) TINS_NOEXCEPT {
            using std::swap;
            swap(handle_, rhs.handle_);
            swap(mask_, rhs.mask_);
            swap(extract_raw_, rhs.extract_raw_);
            swap(pcap_sniffing_method_, rhs.pcap_sniffing_method_);
            return* this;
        }
    #endif

    virtual ~BaseSniffer();

    PtrPacket next_packet();

    template <typename Functor>
    void sniff_loop(Functor function, uint32_t max_packets = 0);

    bool set_filter(const std::string& filter);

    void stop_sniff();

    int get_fd();

    bool set_direction(pcap_direction_t d);

    void set_timeout(int ms);

    void set_extract_raw_pdus(bool value);

    typedef int(*PcapSniffingMethod)(pcap_t*, int, pcap_handler, u_char*);

    void set_pcap_sniffing_method(PcapSniffingMethod method);

    int link_type() const;

    iterator begin();

    iterator end();

    pcap_t* get_pcap_handle();

    const pcap_t* get_pcap_handle() const;
protected:
    BaseSniffer();

    void set_pcap_handle(pcap_t* pcap_handle);

    void set_if_mask(bpf_u_int32 if_mask);

    bpf_u_int32 get_if_mask() const;
private:
    BaseSniffer(const BaseSniffer&);
    BaseSniffer& operator=(const BaseSniffer&);

    pcap_t* handle_;
    bpf_u_int32 mask_;
    bool extract_raw_;
    PcapSniffingMethod pcap_sniffing_method_;
};

class TINS_API Sniffer : public BaseSniffer {
public:
    enum promisc_type {
        NON_PROMISC,
        PROMISC
    };

    Sniffer(const std::string& device);

    Sniffer(const std::string& device, const SnifferConfiguration& configuration);

    TINS_DEPRECATED(Sniffer(const std::string& device, unsigned max_packet_size,
                    bool promisc = false, const std::string& filter = "", bool rfmon = false));

    TINS_DEPRECATED(Sniffer(const std::string& device, promisc_type promisc,
                    const std::string& filter = "", bool rfmon = false));

private:
    friend class SnifferConfiguration;

    void init(const std::string& device, const SnifferConfiguration& configuration);
    void set_snap_len(unsigned snap_len);
    void set_buffer_size(unsigned buffer_size);
    void set_promisc_mode(bool promisc_enabled);
    void set_rfmon(bool rfmon_enabled);
    void set_immediate_mode(bool enabled);
    void set_timestamp_precision(int value);
};

class TINS_API FileSniffer : public BaseSniffer {
public:
    FileSniffer(const std::string& file_name, const SnifferConfiguration& configuration);

    FileSniffer(const std::string& file_name, const std::string& filter = "");
};

template <typename T>
class HandlerProxy {
public:
    typedef T* ptr_type;
    typedef bool (T::*fun_type)(PDU&) ;

    HandlerProxy(ptr_type ptr, fun_type function)
    : object_(ptr), fun_(function) {}

    bool operator()(PDU& pdu) {
        return (object_->*fun_)(pdu);
    }
private:
    ptr_type object_;
    fun_type fun_;
};

template <typename T>
HandlerProxy<T> make_sniffer_handler(T* ptr, 
                                     typename HandlerProxy<T>::fun_type function) {
    return HandlerProxy<T>(ptr, function);
}

class SnifferIterator : public std::iterator<std::forward_iterator_tag, Packet> {
public:
    SnifferIterator(BaseSniffer* sniffer = 0)
    : sniffer_(sniffer) {
        if (sniffer_) {
            advance();
        }
    }

    SnifferIterator& operator++() {
        advance();
        return* this;
    }

    SnifferIterator operator++(int) {
        SnifferIterator other(*this);
        advance();
        return other;
    }

    Packet& operator*() {
        return pkt_;
    }

    Packet* operator->() {
        return &(**this);
    }

    bool operator==(const SnifferIterator& rhs) const {
        return sniffer_ == rhs.sniffer_;
    }

    bool operator!=(const SnifferIterator& rhs) const {
        return !(*this == rhs);
    }
private:
    void advance() {
        pkt_ = sniffer_->next_packet();
        if (!pkt_) {
            sniffer_ = 0;
        }
    }

    BaseSniffer* sniffer_;
    Packet pkt_;
};

class TINS_API SnifferConfiguration {
public:
    static const unsigned DEFAULT_SNAP_LEN;

    static const unsigned DEFAULT_TIMEOUT;

    SnifferConfiguration();

    void set_snap_len(unsigned snap_len);

    void set_buffer_size(unsigned buffer_size);

    void set_promisc_mode(bool enabled);

    void set_filter(const std::string& filter);

    void set_pcap_sniffing_method(BaseSniffer::PcapSniffingMethod method);

    void set_rfmon(bool enabled);

    void set_timeout(unsigned timeout);

    void set_direction(pcap_direction_t direction);

    void set_immediate_mode(bool enabled);

    void set_timestamp_precision(int value);
protected:
    friend class Sniffer;
    friend class FileSniffer;

    enum Flags {
        BUFFER_SIZE = 1,
        PROMISCUOUS = 2,
        RFMON = 4,
        PACKET_FILTER = 8,
        IMMEDIATE_MODE = 16,
        DIRECTION = 32,
        TIMESTAMP_PRECISION = 64,
        PCAP_SNIFFING_METHOD = 128,
    };

    void configure_sniffer_pre_activation(Sniffer& sniffer) const;
    void configure_sniffer_pre_activation(FileSniffer& sniffer) const;

    void configure_sniffer_post_activation(Sniffer& sniffer) const;

    uint32_t flags_;
    unsigned snap_len_;
    unsigned buffer_size_;
    std::string filter_;
    BaseSniffer::PcapSniffingMethod pcap_sniffing_method_;
    unsigned timeout_;
    bool promisc_;
    bool rfmon_;
    bool immediate_mode_;
    pcap_direction_t direction_;
    int timestamp_precision_;
};

template <typename Functor>
void Tins::BaseSniffer::sniff_loop(Functor function, uint32_t max_packets) {
    for(iterator it = begin(); it != end(); ++it) {
        try {
            // If the functor returns false, we're done
            #if TINS_IS_CXX11 && !defined(_MSC_VER)
            if (!Tins::Internals::invoke_loop_cb(function, *it)) {
                return;
            }
            #else
            if (!function(*it->pdu())) {
                return;
            }
            #endif
        }
        catch(malformed_packet&) { }
        catch(pdu_not_found&) { }
        if (max_packets && --max_packets == 0) {
            return;
        }
    }
}

} // Tins

#endif // TINS_HAVE_PCAP

#endif // TINS_SNIFFER_H