UDPPacket.h

/*
 * Copyright (c) 2015 Pavel Vainerman.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation, version 2.1.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Lesser Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
// -----------------------------------------------------------------------------
#ifndef UDPPacket_H_
#define UDPPacket_H_
// -----------------------------------------------------------------------------
#include <list>
#include <limits>
#include <ostream>
#include "UniSetTypes.h"
// --------------------------------------------------------------------------
namespace uniset
{
// -----------------------------------------------------------------------------
namespace UniSetUDP
{
const uint32_t UNETUDP_MAGICNUM = 0x1337A1D; // идентификатор протокола

struct UDPHeader
{
    UDPHeader() noexcept: magic(UNETUDP_MAGICNUM), num(0), nodeID(0), procID(0), dcount(0), acount(0) {}
    uint32_t magic;
    size_t num;
    long nodeID;
    long procID;

    size_t dcount; 
    size_t acount; 
    friend std::ostream& operator<<( std::ostream& os, UDPHeader& p );
    friend std::ostream& operator<<( std::ostream& os, UDPHeader* p );
} __attribute__((packed));

const size_t MaxPacketNum = std::numeric_limits<size_t>::max();

struct UDPAData
{
    UDPAData() noexcept: id(uniset::DefaultObjectId), val(0) {}
    UDPAData(long id, long val) noexcept: id(id), val(val) {}

    long id;
    long val;

    friend std::ostream& operator<<( std::ostream& os, UDPAData& p );
} __attribute__((packed));


// Теоретический размер данных в UDP пакете (исключая заголовки) 65507
// Фактически желательно не вылезать за размер MTU (обычно 1500) - заголовки = 1432 байта
// т.е. надо чтобы sizeof(UDPPacket) < 1432

// При текущих настройках sizeof(UDPPacket) = 32654 (!)
static const size_t MaxACount = 1500;
static const size_t MaxDCount = 5000;
static const size_t MaxDDataCount = 1 + MaxDCount / 8 * sizeof(unsigned char);

struct UDPPacket
{
    UDPPacket() noexcept: len(0) {}

    size_t len;
    uint8_t data[ sizeof(UDPHeader) + MaxDCount * sizeof(long) + MaxDDataCount + MaxACount * sizeof(UDPAData) ];
} __attribute__((packed));

static const size_t MaxDataLen = sizeof(UDPPacket);

struct UDPMessage:
    public UDPHeader
{
    UDPMessage() noexcept;

    UDPMessage(UDPMessage&& m) noexcept = default;
    UDPMessage& operator=(UDPMessage&&) noexcept = default;

    UDPMessage( const UDPMessage& m ) noexcept = default;
    UDPMessage& operator=(const UDPMessage&) noexcept = default;

    explicit UDPMessage( UDPPacket& p ) noexcept;
    size_t transport_msg( UDPPacket& p ) const noexcept;

    static size_t getMessage( UDPMessage& m, UDPPacket& p ) noexcept;

    // \warning в случае переполнения возвращается MaxDCount
    size_t addDData( long id, bool val ) noexcept;

    bool setDData( size_t index, bool val ) noexcept;

    long dID( size_t index ) const noexcept;

    bool dValue( size_t index ) const noexcept;

    // функции addAData возвращают индекс, по которому потом можно напрямую писать при помощи setAData(index)
    // \warning в случае переполнения возвращается MaxACount
    size_t addAData( const UDPAData& dat ) noexcept;
    size_t addAData( long id, long val ) noexcept;

    bool setAData( size_t index, long val ) noexcept;

    long getDataID( ) const noexcept; 
    inline bool isAFull() const noexcept
    {
        return (acount >= MaxACount);
    }
    inline bool isDFull() const noexcept
    {
        return (dcount >= MaxDCount);
    }

    inline bool isFull() const noexcept
    {
        return !((dcount < MaxDCount) && (acount < MaxACount));
    }

    inline size_t dsize() const noexcept
    {
        return dcount;
    }

    inline size_t asize() const noexcept
    {
        return acount;
    }

    // размер итогового пакета в байтах
    size_t sizeOf() const noexcept;

    uint16_t getDataCRC() const noexcept;

    // количество байт в пакете с булевыми переменными...
    size_t d_byte() const noexcept
    {
        return dcount * sizeof(long) + dcount;
    }

    UDPAData a_dat[MaxACount]; 
    long d_id[MaxDCount];      
    uint8_t d_dat[MaxDDataCount];  
    friend std::ostream& operator<<( std::ostream& os, UDPMessage& p );
};

uint16_t makeCRC( unsigned char* buf, size_t len ) noexcept;
}
// --------------------------------------------------------------------------
} // end of namespace uniset
// -----------------------------------------------------------------------------
#endif // UDPPacket_H_
// -----------------------------------------------------------------------------