1

#ifndef NETWORK_PACKET_HH

     2

#define NETWORK_PACKET_HH

     3

    10

#include "Config.hh"

    11

#include "../Types.hh"

    12

#include "../Error.hh"

    13

    14

/**

    15

 * Base class of errors thrown by NetworkPacket* methods

    16

 */

    17

class NetworkPacketError : public Error {

    18

    public:

    19

        NetworkPacketError (const std::string &message) : Error(message) { }

    20

};

    21

    22

// forward-declare for write_packet

    23

class NetworkPacketBuffer;

    24

    25

/**

    26

 * Read-interface for network packets

    27

 */

    28

class NetworkPacketInput {

    29

    public:

    30

        /**

    31

         * Abstract method to get a pointer to \a len bytes of raw in-memory binary data, advancing the read offset

    32

         *

    33

         * @param len the number of bytes to consume

    34

         */

    35

        virtual const void* read_ptr (size_t len) = 0;

    36

    37

        /**

    38

         * Abstract method that copies len bytes from the packet to ptr, first testing that they exist

    39

         */

    40

        virtual void read (

    41

                void *ptr,      //<<< where to copy

    42

                size_t len      //<<< number of bytes to copy

    43

        ) = 0;

    44

    45

        /**

    46

         * Abstract method to get the number of input bytes remaining.

    47

         *

    48

         * @return number of input bytes still readable

    49

         */

    50

        virtual size_t tell_remaining (void) = 0;

    51

    52

        /**

    53

         * Convenience function to read() and return the value of the given type

    54

         *

    55

         * @return T The value

    56

         */

    57

        template <typename T> T read_val (void);

    58

    59

        // @{

    60

        /**

    61

         * Collection of methods to write out simple types, these convert from network-endianness and return the value

    62

         */

    63

    64

        /** 32-bit unsigned int */

    65

        uint32_t read_uint32 (void);

    66

    67

        /** 16-bit unsigned int */

    68

        uint16_t read_uint16 (void);

    69

    70

        /** 8-bit unsigned int */

    71

        uint8_t read_uint8 (void);

    72

    73

        /** 32-bit signed int */

    74

        int32_t read_int32 (void);

    75

    76

        /** 16-bit signed int */

    77

        int16_t read_int16 (void);

    78

    79

        /** 8-bit signed int */

    80

        int8_t read_int8 (void);

    81

    82

        /** 32-bit float */

    83

        float read_float32 (void);

    84

    85

        // @}

    86

    87

        /**

    88

         * Read a Vector from the packet:

    89

         *  float32     vec_x

    90

         *  float32     vec_y

    91

         *

    92

         * @return Vector (vec_x, vec_y)

    93

         */

    94

        Vector read_vector (void);

    95

    96

        /**

    97

         * Read compressed data written with write_compressed. The given buffer must be the same size as passed to

    98

         * write_compressed. Returns the number of bytes that were decompressed into buf.

    99

         */

   100

        size_t read_uncompressed (void *buf, size_t len);

   101

};

   102

   103

/**

   104

 * Write-interface for network packets

   105

 */

   106

class NetworkPacketOutput {

   107

    protected:

   108

        /**

   109

         * Adjust size of the most recent write_ptr area of buf_len bytes to data_len bytes.

   113

         */

   114

        virtual void write_ptr_adjust (size_t buf_len, size_t data_len) = 0;

   115

   116

    public:    

   117

        /**

   118

         * Abstract method to get a pointer to \a len bytes of raw in-memory binary data, advancing the write offset

   119

         *

   120

         * @param len number of bytes to commit

   121

         */

   122

        virtual void* write_ptr (size_t len) = 0;

   123

   124

        /**

   125

         * Abstract method that copies len bytes from ptr to the packet, first testing that they fit

   126

         */

   127

        virtual void write (

   128

                const void *ptr,    //<<< where to copy from

   129

                size_t len          //<<< number of bytes to copy

   130

        ) = 0;

   131

   132

        /**

   133

         * Convenience function to write() the value of the given type-value

   134

         *

   135

         * @param val The value

   136

         */

   137

        template <typename T> void write_val (const T &val);

   138

   139

        // @{        

   140

        /**

   141

         * Collection of methods to write out simple types, these convert the given value to network-byte-order

   142

         */

   143

        void write_uint32 (uint32_t val);

   144

        void write_uint16 (uint16_t val);

   145

        void write_uint8 (uint8_t val);

   146

        void write_int32 (int32_t val);

   147

        void write_int16 (int16_t val);

   148

        void write_int8 (int8_t val);

   149

        void write_float32 (float val);

   150

   151

        // @{ 

   152

   153

        /**

   154

         * Write a vector to the packet:

   155

         *  float32     vec_x

   156

         *  float32     vec_y

   157

         *

   158

         *  @param vec a Vector(vec_x, vec_y)

   159

         */

   160

        void write_vector (const Vector &vec);

   161

   162

        /**

   163

         * This write()s the contents of the given NetworkPacketBuffer to this packet.

   164

         *

   165

         * @param pkt the sub-packet to write()

   166

         */

   167

        void write_packet (const NetworkPacketBuffer &pkt);

   168

   169

        /**

   170

         * This will compress the given data buffer into this packet for reading with read_compressed. The compressed

   171

         * data will use at most write_compressed_size(len) bytes of data.

   172

         */

   173

        void write_compressed (const void *ptr, uint32_t len);

   174

   175

        /**

   176

         * Return upper bound on packet size of compressed data, including header.

   177

         */

   178

        static size_t write_compressed_size (uint32_t len);

   179

};

   180

   181

/**

   182

 * Implements an in-memory seekable buffer used by NetworkPackets

   183

 *

   184

 * @see NetworkPacketInput

   185

 * @see NetworkPacketOutput

   186

 */

   187

class NetworkPacketBuffer : public NetworkPacketInput, public NetworkPacketOutput {

   188

    protected:

   189

        /**

   190

         * Pointer to the packet data

   191

         */

   192

        char *buf_ptr;

   193

   194

        /**

   195

         * The size of the memory region pointed to by buf_ptr

   196

         */

   197

        size_t buf_size;

   198

   199

        /**

   200

         * The number of bytes of read()-able data stored at buf_ptr

   201

         */

   202

        size_t data_size;

   203

   204

        /**

   205

         * The current offset at which to run the next read/write

   206

         */

   207

        size_t offset;

   208

   209

        /**

   210

         * Assert that the given number of bytes fits into the buffer at offset. Throws NetworkPacketError if not.

   211

         *

   212

         * The default implementation just checks offset and buf_size

   213

         *

   214

         * @param item_size the size of the item that should to be written

   215

         */

   216

        virtual void check_write_size (size_t item_size);

   217

   218

        /**

   219

         * Assert that the given number of bytes is available from the buffer. Throws NetworkPacketError if not

   220

         *

   221

         * The default implementation just checks offset and data_size

   222

         *

   223

         * @param item_size the size of the item that should be read

   224

         */

   225

        virtual void check_read_size (size_t item_size);

   226

   227

    public:

   228

        /**

   229

         * Construct the NetworkPacketBuffer using the given buf_ptr, buf_size and data_size

   230

         */

   231

        NetworkPacketBuffer (char *buf_ptr, size_t buf_size, size_t data_size);

   232

   233

        /**

   234

         * Returns a read-only pointer to \a len bytes of internal buffer memory, calling check_read_size first and

   235

         * updating offset

   236

         *

   237

         * @param len number of bytes from the buffer to consume

   238

         */

   239

        virtual const void* read_ptr (size_t len);

   240

   241

        /**

   242

         * Returns a read-write pointer to \a len bytes of internal buffer memory, calling check_write_size first and

   243

         * updating offset+data_size

   244

         *

   245

         * @param len number of bytes in the buffer to commit

   246

         */

   247

        virtual void* write_ptr (size_t len);

   248

   249

        /**

   250

         * Copy bytes from the packet buffer to ptr using memcpy(), calling check_read_size first.

   251

         *

   252

         * @param ptr where to copy the data to

   253

         * @param len number of bytes to copy

   254

         */

   255

        virtual void read (void *ptr, size_t len);

   256

   257

        /**

   258

         * Copy bytes from ptr to the packet buffer using memcpy(), calling check_write_size first

   259

         *

   260

         * @param ptr where to copy the data from

   261

         * @param len number of bytes to copy

   262

         */

   263

        virtual void write (const void *ptr, size_t len);

   264

   265

        virtual void write_ptr_adjust (size_t buf_len, size_t data_len);

   266

   267

        /**

   268

         * Returns our data_size - read-offset

   269

         */

   270

        virtual size_t tell_remaining (void);

   271

   272

        /*

   273

         * Accessor functions, used by the actual socket code to read/write the buffer

   276

         */

   277

        char* get_buf (void) { return buf_ptr; }

   278

        const char* get_buf (void) const { return buf_ptr; }

   279

        size_t get_data_size (void) const { return data_size; }

   280

        size_t get_buf_size (void) const { return buf_size; }

   281

   282

        /**

   283

         * If the contents of buf_ptr is replaced with a new packet, call this to update offset/data_size

   284

         *

   285

         * @param size new amount of data in the buffer

   286

         */

   287

        void set_data_size (size_t size) { offset = 0; data_size = size; }

   288

};

   289

   290

/**

   291

 * The common case is a packet that fits in a single UDP packet, so this just uses a static buffer of a fixed size,

   292

 * NETWORK_PACKET_SIZE.

   293

 *

   294

 * @see NetworkPacketBuffer

   295

 * @see NETWORK_PACKET_SIZE

   296

 */

   297

class NetworkPacket : public NetworkPacketBuffer {

   298

    private:

   299

        /**

   300

         * The static buffer, NETWORK_PACKET_SIZE bytes

   301

         */

   302

        char _buf[NETWORK_PACKET_SIZE];

   303

   304

    public:

   305

        NetworkPacket (void);

   306

};

   307

   308

/**

   309

 * This is intended for sending bigger packets via TCP; a buffer of the given size is allocated on the heap.

   310

 *

   311

 * @see NetworkPacketBuffer

   312

 */

   313

class BigNetworkPacket : public NetworkPacketBuffer {

   314

    public:

   315

        /**

   316

         * Allocates a buffer of the given size on the heap and uses it for NetworkPacketBuffer

   317

         */

   318

        BigNetworkPacket (size_t size);

   319

   320

    private:

   321

        /**

   322

         * Object must not be copied

   323

         */

   324

        BigNetworkPacket (const BigNetworkPacket &pkt);

   325

        BigNetworkPacket& operator= (const BigNetworkPacket &pkt);

   326

   327

    public:

   328

        /**

   329

         * Frees the heap buffer

   330

         */

   331

        virtual ~BigNetworkPacket (void);

   332

};

   333

   334

#endif /* NETWORK_PACKET_HH */