stream.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_TCP_IP_STREAM_H
#define TINS_TCP_IP_STREAM_H

#include <tins/config.h>

#ifdef TINS_HAVE_TCPIP

#include <vector>
#include <array>
#include <map>
#include <functional>
#include <chrono>
#include <stdint.h>
#include <tins/macros.h>
#include <tins/hw_address.h>
#include <tins/config.h>
#include <tins/tcp_ip/flow.h>
#ifdef TINS_HAVE_TCP_STREAM_CUSTOM_DATA
    #include <boost/any.hpp>
#endif

namespace Tins {

class PDU;
class TCP;
class IPv4Address;
class IPv6Address;

namespace TCPIP {

class TINS_API Stream {
public:
    typedef Flow::payload_type payload_type;

    typedef std::chrono::microseconds timestamp_type;
    
    typedef std::function<void(Stream&)> stream_callback_type;

    typedef std::function<void(Stream&,
                               uint32_t,
                               const payload_type&)> stream_packet_callback_type;

    typedef HWAddress<6> hwaddress_type;


    Stream(PDU& initial_packet, const timestamp_type& ts = timestamp_type());

    void process_packet(PDU& packet, const timestamp_type& ts);

    void process_packet(PDU& packet);

    Flow& client_flow();

    const Flow& client_flow() const;

    Flow& server_flow();

    const Flow& server_flow() const;

    bool is_finished() const;

    bool is_v6() const;

    IPv4Address client_addr_v4() const;

    IPv6Address client_addr_v6() const;

    const hwaddress_type& client_hw_addr() const;

    const hwaddress_type& server_hw_addr() const;

    IPv4Address server_addr_v4() const;

    IPv6Address server_addr_v6() const;

    uint16_t client_port() const;

    uint16_t server_port() const;

    const payload_type& client_payload() const;

    payload_type& client_payload();

    const payload_type& server_payload() const;

    payload_type& server_payload();

    const timestamp_type& create_time() const;

    const timestamp_type& last_seen() const;

    void stream_closed_callback(const stream_callback_type& callback);

    void client_data_callback(const stream_callback_type& callback);

    void server_data_callback(const stream_callback_type& callback);

    void client_out_of_order_callback(const stream_packet_callback_type& callback);

    void server_out_of_order_callback(const stream_packet_callback_type& callback);

    void ignore_client_data();

    void ignore_server_data();

    void setup_flows_callbacks();

    void auto_cleanup_payloads(bool value);

    void auto_cleanup_client_data(bool value);

    void auto_cleanup_server_data(bool value);

    void enable_ack_tracking();

    bool ack_tracking_enabled() const;

    #ifdef TINS_HAVE_TCP_STREAM_CUSTOM_DATA

    template<typename T>
    T& user_data() {
        if (user_data_.empty()) {
            user_data_ = T();
        };
        return boost::any_cast<T&>(user_data_);
    }
    #endif // TINS_HAVE_TCP_STREAM_CUSTOM_DATA

    bool is_partial_stream() const;

    void enable_recovery_mode(uint32_t recovery_window);

    bool is_recovery_mode_enabled() const;
private:
    static Flow extract_client_flow(const PDU& packet);
    static Flow extract_server_flow(const PDU& packet);

    void on_client_flow_data(const Flow& flow);
    void on_server_flow_data(const Flow& flow);
    void on_client_out_of_order(const Flow& flow,
                                uint32_t seq,
                                const payload_type& payload);
    void on_server_out_of_order(const Flow& flow,
                                uint32_t seq,
                                const payload_type& payload);
    static void client_recovery_mode_handler(Stream& stream, uint32_t sequence_number,
                                             const payload_type& payload,
                                             uint32_t recovery_sequence_number_end,
                                             const stream_packet_callback_type& original_callback);
    static void server_recovery_mode_handler(Stream& stream, uint32_t sequence_number,
                                             const payload_type& payload,
                                             uint32_t recovery_sequence_number_end,
                                             const stream_packet_callback_type& original_callback);
    static bool recovery_mode_handler(Flow& flow, uint32_t sequence_number,
                                      uint32_t recovery_sequence_number_end);

    Flow client_flow_;
    Flow server_flow_;
    stream_callback_type on_stream_closed_;
    stream_callback_type on_client_data_callback_;
    stream_callback_type on_server_data_callback_;
    stream_packet_callback_type on_client_out_of_order_callback_;
    stream_packet_callback_type on_server_out_of_order_callback_;
    hwaddress_type client_hw_addr_;
    hwaddress_type server_hw_addr_;
    timestamp_type create_time_;
    timestamp_type last_seen_;
    bool auto_cleanup_client_;
    bool auto_cleanup_server_;
    bool is_partial_stream_;
    unsigned directions_recovery_mode_enabled_;

    #ifdef TINS_HAVE_TCP_STREAM_CUSTOM_DATA
    boost::any user_data_;
    #endif // TINS_HAVE_TCP_STREAM_CUSTOM_DATA
};

} // TCPIP
} // Tins

#endif // TINS_HAVE_TCPIP 

#endif // TINS_TCP_IP_STREAM_H