packet.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_H
#define TINS_PACKET_H

#include <tins/cxxstd.h>
#include <tins/pdu.h>
#include <tins/timestamp.h>

namespace Tins {

template<typename WrappedType, typename TimestampType>
class PacketWrapper;


typedef PacketWrapper<PDU&, const Timestamp&> RefPacket;

typedef PacketWrapper<PDU*, Timestamp> PtrPacket;

template<typename PDUType, typename TimestampType>
class PacketWrapper {
public:
    typedef PDUType pdu_type;
    typedef TimestampType timestamp_type;
    
    operator pdu_type() {
        return pdu_;
    }
    
    pdu_type pdu() {
        return pdu_;
    }
    
    const pdu_type pdu() const {
        return pdu_;
    }
    
    const Timestamp& timestamp() const {
        return ts_;
    }
private:
    friend class BaseSniffer;
    friend class SnifferIterator;
    
    PacketWrapper(pdu_type pdu, const Timestamp& ts) 
    : pdu_(pdu), ts_(ts) {}
    
    PacketWrapper(const PacketWrapper&);
    PacketWrapper& operator=(const PacketWrapper&);
    void* operator new (size_t size);
    void operator delete (void* p);

    pdu_type pdu_;
    timestamp_type ts_;
};

class Packet {
public:
    struct own_pdu {

    };

    Packet() 
    : pdu_(0) { }
    
    Packet(const PDU* apdu, const Timestamp& tstamp) 
    : pdu_(apdu->clone()), ts_(tstamp) { }

    Packet(const PDU& apdu, const Timestamp& tstamp) 
    : pdu_(apdu.clone()), ts_(tstamp) { }

    Packet(PDU* apdu, const Timestamp& tstamp, own_pdu) 
    : pdu_(apdu), ts_(tstamp) { }
    
    Packet(const PDU& rhs) 
    : pdu_(rhs.clone()), ts_(Timestamp::current_time()) { }
    
    Packet(const RefPacket& pck) 
    : pdu_(pck.pdu().clone()), ts_(pck.timestamp()) { }

    Packet(const PtrPacket& pck)
    : pdu_(pck.pdu()), ts_(pck.timestamp()) { }
    
    Packet(const Packet& rhs) : ts_(rhs.timestamp()) {
        pdu_ = rhs.pdu() ? rhs.pdu()->clone() : 0;
    }
    
    Packet& operator=(const Packet& rhs) {
        if (this != &rhs) {
            delete pdu_;
            ts_ = rhs.timestamp();
            pdu_ = rhs.pdu() ? rhs.pdu()->clone() : 0;
        }
        return* this;
    }
    
    #if TINS_IS_CXX11

    Packet(Packet &&rhs) TINS_NOEXCEPT : pdu_(rhs.pdu()), ts_(rhs.timestamp()) {
        rhs.pdu_ = nullptr;
    }
    
    Packet& operator=(Packet &&rhs) TINS_NOEXCEPT { 
        if (this != &rhs) {
            PDU* tmp = std::move(pdu_);
            pdu_ = std::move(rhs.pdu_);
            rhs.pdu_ = std::move(tmp);
            ts_ = rhs.timestamp();
        }
        return* this;
    }
    #endif
    
    ~Packet() {
        delete pdu_;
    }
    
    const Timestamp& timestamp() const {
        return ts_;
    }
    
    PDU* pdu() {
        return pdu_;
    }
    
    const PDU* pdu() const {
        return pdu_;
    }
    
    PDU* release_pdu() {
        PDU* some_pdu = pdu_;
        pdu_ = 0;
        return some_pdu;
    }
    
    operator bool() const {
        return pdu_ ? true : false;
    }
    
    Packet& operator/=(const PDU& rhs) {
        pdu_ /= rhs;
        return* this;
    }
private:
    PDU* pdu_;
    Timestamp ts_;
};
}

#endif // TINS_PACKET_H