1

#ifndef NETWORK_PACKET_HH

     2

#define NETWORK_PACKET_HH

     3

     4

#include "Config.hh"

     5

#include "../Types.hh"

     6

#include "../Error.hh"

     7

     8

/**

     9

 * Base class of errors thrown by NetworkPacket* methods

    10

 */

    11

class NetworkPacketError : public Error {

    12

    public:

    13

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

    14

};

    15

    16

// forward-declare for write_packet

    17

class NetworkPacketBuffer;

    18

    19

/**

    20

 * Read-interface for network packets

    21

 */

    22

class NetworkPacketInput {

    23

    public:

    24

        /**

    25

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

    26

         *

    27

         * @param len the number of bytes to consume

    28

         */

    29

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

    30

    31

        /**

    32

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

    33

         */

    34

        virtual void read (

    35

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

    36

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

    37

        ) = 0;

    45

    46

        /**

    47

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

    48

         *

    49

         * @return T The value

    50

         */

    51

        template <typename T> T read_val (void);

    52

    53

        // @{

    54

        /**

    55

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

    56

         */

    57

    58

        /** 32-bit unsigned int */

    59

        uint32_t read_uint32 (void);

    60

    61

        /** 16-bit unsigned int */

    62

        uint16_t read_uint16 (void);

    63

    64

        /** 8-bit unsigned int */

    65

        uint8_t read_uint8 (void);

    66

    67

        /** 32-bit signed int */

    68

        int32_t read_int32 (void);

    69

    70

        /** 16-bit signed int */

    71

        int16_t read_int16 (void);

    72

    73

        /** 8-bit signed int */

    74

        int8_t read_int8 (void);

    75

    76

        /** 32-bit float */

    77

        float read_float32 (void);

    78

    79

        // @}

    80

    81

        /**

    82

         * Read a Vector from the packet:

    83

         *  float32     vec_x

    84

         *  float32     vec_y

    85

         *

    86

         * @return Vector (vec_x, vec_y)

    87

         */

    88

        Vector read_vector (void);

    89

    90

        /**

    93

         */

    95

};

    96

    97

/**

    98

 * Write-interface for network packets

    99

 */

   100

class NetworkPacketOutput {

   107

    public:    

   108

        /**

   109

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

   110

         *

   111

         * @param len number of bytes to commit

   112

         */

   113

        virtual void* write_ptr (size_t len) = 0;

   114

   115

        /**

   116

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

   117

         */

   118

        virtual void write (

   119

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

   120

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

   121

        ) = 0;

   122

   123

        /**

   124

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

   125

         *

   126

         * @param val The value

   127

         */

   128

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

   129

   130

        // @{        

   131

        /**

   132

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

   133

         */

   134

        void write_uint32 (uint32_t val);

   135

        void write_uint16 (uint16_t val);

   136

        void write_uint8 (uint8_t val);

   137

        void write_int32 (int32_t val);

   138

        void write_int16 (int16_t val);

   139

        void write_int8 (int8_t val);

   140

        void write_float32 (float val);

   141

   142

        // @{ 

   143

   144

        /**

   145

         * Write a vector to the packet:

   146

         *  float32     vec_x

   147

         *  float32     vec_y

   148

         *

   149

         *  @param vec a Vector(vec_x, vec_y)

   150

         */

   151

        void write_vector (const Vector &vec);

   152

   153

        /**

   154

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

   155

         *

   156

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

   157

         */

   158

        void write_packet (const NetworkPacketBuffer &pkt);

   170

};

   171

   172

/**

   173

 * Implements an in-memory seekable buffer used by NetworkPackets

   174

 *

   175

 * @see NetworkPacketInput

   176

 * @see NetworkPacketOutput

   177

 */

   178

class NetworkPacketBuffer : public NetworkPacketInput, public NetworkPacketOutput {

   179

    protected:

   180

        /**

   181

         * Pointer to the packet data

   182

         */

   183

        char *buf_ptr;

   184

   185

        // the buffer size, the amount of data in the buffer, and the current read/write offset

   186

        /**

   187

         * The size of the memory region pointed to by buf_ptr

   188

         */

   189

        size_t buf_size;

   190

   191

        /**

   192

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

   193

         */

   194

        size_t data_size;

   195

   196

        /**

   197

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

   198

         */

   199

        size_t offset;

   200

   201

        /**

   202

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

   203

         *

   204

         * The default implementation just checks offset and buf_size

   205

         *

   206

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

   207

         */

   208

        virtual void check_write_size (size_t item_size);

   209

   210

        /**

   211

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

   212

         *

   213

         * The default implementation just checks offset and data_size

   214

         *

   215

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

   216

         */

   217

        virtual void check_read_size (size_t item_size);

   218

   219

    public:

   220

        /**

   221

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

   222

         */

   223

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

   224

   225

        /**

   226

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

   227

         * updating offset

   228

         *

   229

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

   230

         */

   231

        virtual const void* read_ptr (size_t len);

   232

   233

        /**

   234

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

   235

         * updating offset+data_size

   236

         *

   237

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

   238

         */

   239

        virtual void* write_ptr (size_t len);

   240

   241

        /**

   242

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

   243

         *

   244

         * @param ptr where to copy the data to

   245

         * @param len number of bytes to copy

   246

         */

   247

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

   248

   249

        /**

   250

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

   251

         *

   252

         * @param ptr where to copy the data from

   253

         * @param len number of bytes to copy

   254

         */

   255

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

   256

   259

        /**

   260

         * Returns our data_size - read-offset

   261

         */

   262

        virtual size_t tell_remaining (void);

   263

   264

        /*

   265

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

   266

         */

   267

        char* get_buf (void) { return buf_ptr; }

   268

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

   269

        size_t get_data_size (void) const { return data_size; }

   270

        size_t get_buf_size (void) const { return buf_size; }

   271

   272

        /**

   273

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

   274

         *

   275

         * @param size new amount of data in the buffer

   276

         */

   277

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

   278

};

   279

   280

/**

   281

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

   282

 * NETWORK_PACKET_SIZE.

   283

 *

   284

 * @see NetworkPacketBuffer

   285

 * @see NETWORK_PACKET_SIZE

   286

 */

   287

class NetworkPacket : public NetworkPacketBuffer {

   288

    private:

   289

        /**

   290

         * The static buffer, NETWORK_PACKET_SIZE bytes

   291

         */

   292

        char _buf[NETWORK_PACKET_SIZE];

   293

   294

    public:

   295

        NetworkPacket (void);

   296

};

   297

   298

/**

   299

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

   300

 *

   301

 * @see NetworkPacketBuffer

   302

 */

   303

class BigNetworkPacket : public NetworkPacketBuffer {

   304

    public:

   305

        /**

   306

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

   307

         */

   308

        BigNetworkPacket (size_t size);

   309

   310

    private:

   311

        /**

   312

         * Object must not be copied

   313

         */

   314

        BigNetworkPacket (const BigNetworkPacket &pkt);

   315

        BigNetworkPacket& operator= (const BigNetworkPacket &pkt);

   316

   317

    public:

   318

        /**

   319

         * Frees the heap buffer

   320

         */

   321

        virtual ~BigNetworkPacket (void);

   322

};

   323

   324

#endif /* NETWORK_PACKET_HH */