packet_sender.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_PACKET_SENDER_H
#define TINS_PACKET_SENDER_H


#include <string>
#include <vector>
#include <stdint.h>
#include <map>
#include <tins/config.h>
#ifdef TINS_HAVE_PACKET_SENDER_PCAP_SENDPACKET
    #include <pcap.h>
#endif // TINS_HAVE_PACKET_SENDER_PCAP_SENDPACKET
#include <tins/network_interface.h>
#include <tins/macros.h>
#include <tins/cxxstd.h>

struct timeval;
struct sockaddr;

namespace Tins {

class PDU;

class TINS_API PacketSender {
public:
    static const uint32_t DEFAULT_TIMEOUT;

    enum SocketType {
        ETHER_SOCKET,
        IP_TCP_SOCKET,
        IP_UDP_SOCKET,
        IP_RAW_SOCKET,
        ARP_SOCKET,
        ICMP_SOCKET,
        IPV6_SOCKET,
        ICMPV6_SOCKET,
        SOCKETS_END
    };

    PacketSender(const NetworkInterface& iface = NetworkInterface(),
                 uint32_t recv_timeout = DEFAULT_TIMEOUT,
                 uint32_t usec = 0);
    
    #if TINS_IS_CXX11

        PacketSender(PacketSender &&rhs) TINS_NOEXCEPT {
            *this = std::move(rhs);
        }
        
        PacketSender& operator=(PacketSender &&rhs) TINS_NOEXCEPT {
            sockets_ = std::move(rhs.sockets_);
            rhs.sockets_ = std::vector<int>(SOCKETS_END, INVALID_RAW_SOCKET);
            #ifndef _WIN32
                #if defined(BSD) || defined(__FreeBSD_kernel__)
                ether_socket_ = std::move(rhs.ether_socket_);
                #else
                ether_socket_ = rhs.ether_socket_;
                rhs.ether_socket_ = INVALID_RAW_SOCKET;
                #endif
            #endif
            types_ = rhs.types_; // no move
            _timeout = rhs._timeout;
            timeout_usec_ = rhs.timeout_usec_;
            default_iface_ = rhs.default_iface_;
            return* this;
        }
    #endif
    
    ~PacketSender();

    #if !defined(_WIN32) || defined(TINS_HAVE_PACKET_SENDER_PCAP_SENDPACKET)

    void open_l2_socket(const NetworkInterface& iface = NetworkInterface());
    #endif // !_WIN32 || defined(TINS_HAVE_PACKET_SENDER_PCAP_SENDPACKET)

    void open_l3_socket(SocketType type);

    void close_socket(SocketType type, const NetworkInterface& iface = NetworkInterface());

    void default_interface(const NetworkInterface& iface);
    
    const NetworkInterface& default_interface() const;

    void send(PDU& pdu);
    
    void send(PDU& pdu, const NetworkInterface& iface);

    PDU* send_recv(PDU& pdu);
    
    PDU* send_recv(PDU& pdu, const NetworkInterface& iface);

    #ifndef _WIN32

    PDU* recv_l2(PDU& pdu, struct sockaddr* link_addr, uint32_t len_addr,
      const NetworkInterface& iface = NetworkInterface());

    #endif // _WIN32

    #if !defined(_WIN32) || defined(TINS_HAVE_PACKET_SENDER_PCAP_SENDPACKET)

    void send_l2(PDU& pdu, struct sockaddr* link_addr, uint32_t len_addr, 
      const NetworkInterface& iface = NetworkInterface());
    #endif // !_WIN32 || TINS_HAVE_PACKET_SENDER_PCAP_SENDPACKET

    PDU* recv_l3(PDU& pdu, struct sockaddr* link_addr, uint32_t len_addr, SocketType type);

    void send_l3(PDU& pdu, struct sockaddr* link_addr, uint32_t len_addr, SocketType type);
private:
    static const int INVALID_RAW_SOCKET;

    typedef std::map<SocketType, int> SocketTypeMap;

    PacketSender(const PacketSender&);
    PacketSender& operator=(const PacketSender&);
    int find_type(SocketType type);
    #ifndef _WIN32
        bool ether_socket_initialized(const NetworkInterface& iface = NetworkInterface()) const;
        int get_ether_socket(const NetworkInterface& iface = NetworkInterface());
    #endif
    template<typename T>
    void send(PDU& pdu, const NetworkInterface& iface) {
        static_cast<T&>(pdu).send(*this, iface);
    }
    #ifdef TINS_HAVE_PACKET_SENDER_PCAP_SENDPACKET
        pcap_t* make_pcap_handle(const NetworkInterface& iface) const;
    #endif // TINS_HAVE_PACKET_SENDER_PCAP_SENDPACKET
    
    PDU* recv_match_loop(const std::vector<int>& sockets, 
                         PDU& pdu,
                         struct sockaddr* link_addr, 
                         uint32_t addrlen,
                         bool is_layer_3);

    std::vector<int> sockets_;
    #ifndef _WIN32
        #if defined(BSD) || defined(__FreeBSD_kernel__)
        typedef std::map<uint32_t, int> BSDEtherSockets;
        BSDEtherSockets ether_socket_;
        #else
        int ether_socket_;
        #endif
    #endif
    SocketTypeMap types_;
    uint32_t _timeout, timeout_usec_;
    NetworkInterface default_iface_;
    // In BSD we need to store the buffer size, retrieved using BIOCGBLEN
    #if defined(BSD) || defined(__FreeBSD_kernel__)
    int buffer_size_;
    #endif // BSD
    #ifdef TINS_HAVE_PACKET_SENDER_PCAP_SENDPACKET
        typedef std::map<NetworkInterface, pcap_t*> PcapHandleMap; 
        PcapHandleMap pcap_handles_;
    #endif // TINS_HAVE_PACKET_SENDER_PCAP_SENDPACKET
};

} // Tins

#endif // TINS_PACKET_SENDER_H