1

#ifndef NETWORK_PACKET_HH

     2

#define NETWORK_PACKET_HH

     3

     4

#include "Config.hh"

     5

#include "../Vector.hh"

     6

#include "../Error.hh"

     7

     8

class NetworkPacketError : public Error {

     9

    public:

    10

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

    11

};

    12

    13

// forward-declare for write_packet

    14

class NetworkPacketBuffer;

    15

    16

/*

    17

 * Read-interface for network packets

    18

 */

    19

class NetworkPacketInput {

    20

    public:

    21

        /*

    22

         * Copies len bytes from the packet to ptr, first testing that they exist

    23

         */

    24

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

    25

    26

        /*

    27

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

    28

         */

    29

        template <typename T> T read_val (void);

    30

    31

        // thse handle network-endianlness

    32

        uint32_t read_uint32 (void);

    33

        uint16_t read_uint16 (void);

    34

        uint8_t read_uint8 (void);

    35

    36

        int32_t read_int32 (void);

    37

        int16_t read_int16 (void);

    38

        int8_t read_int8 (void);

    39

    40

        float read_float32 (void);

    41

    42

        Vector read_vector (void);

    43

};

    44

    45

/*

    46

 * Write-interface for network packets

    47

 */

    48

class NetworkPacketOutput {

    49

    public:    

    50

        /*

    51

         * Copies len bytes from ptr to the packet, first testing that they fit

    52

         */

    53

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

    54

    55

        /*

    56

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

    57

         */

    58

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

    59

    60

        // thse handle network-endianlness

    61

        void write_uint32 (uint32_t val);

    62

        void write_uint16 (uint16_t val);

    63

        void write_uint8 (uint8_t val);

    64

    65

        void write_int32 (int32_t val);

    66

        void write_int16 (int16_t val);

    67

        void write_int8 (int8_t val);

    68

    69

        void write_float32 (float val);

    70

    71

        void write_vector (const Vector &vec);

    72

    73

        /*

    74

         * This copies the contents of the given packet into this packet

    75

         */

    76

        void write_packet (const NetworkPacketBuffer &pkt);

    77

};

    78

    79

/*

    80

 * Implements the in-memory seekable buffer used by NetworkPackets.

    81

 */

    82

class NetworkPacketBuffer : public NetworkPacketInput, public NetworkPacketOutput {

    83

    protected:

    84

        // the pointer to the buffer

    85

        char *buf_ptr;

    86

    87

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

    88

        size_t buf_size, data_size, offset;

    89

    90

        /*

    91

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

    92

         *

    93

         * The default implementation just checks offset and buf_size

    94

         */

    95

        virtual void check_write_size (size_t item_size);

    96

    97

        /*

    98

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

    99

         *

   100

         * The default implementation just checks offset and data_size

   101

         */

   102

        virtual void check_read_size (size_t item_size);

   103

   104

    public:

   105

        /*

   106

         * Construct the NetworkPacketBuffer using the given initial buf_ptr and buf_size

   107

         */

   108

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

   109

   110

        /*

   111

         * These memcpy() into/out of the buf_ptr, using ceck_read/write_size

   112

         */

   113

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

   114

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

   115

   116

        /*

   117

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

   118

         */

   119

        char* get_buf (void) { return buf_ptr; }

   120

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

   121

        size_t get_data_size (void) const { return data_size; }

   122

        size_t get_buf_size (void) const { return buf_size; }

   123

   124

        /*

   125

         * Used by the socket code after recv() to mark how many bytes of data the buffer has

   126

         */

   127

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

   128

};

   129

   130

/*

   131

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

   132

 * NETWORK_PACKET_SIZE.

   133

 */

   134

class NetworkPacket : public NetworkPacketBuffer {

   135

    private:

   136

        char _buf[NETWORK_PACKET_SIZE];

   137

   138

    public:

   139

        NetworkPacket (void);

   140

};

   141

   142

/*

   143

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

   144

 *

   145

 * XXX: let the buffer grow as well

   146

 */

   147

class BigNetworkPacket : public NetworkPacketBuffer {

   148

    public:

   149

        BigNetworkPacket (size_t size);

   150

   151

    private:

   152

        // no copies

   153

        BigNetworkPacket (const BigNetworkPacket &pkt);

   154

        BigNetworkPacket& operator= (const BigNetworkPacket &pkt);

   155

   156

    public:

   157

        virtual ~BigNetworkPacket (void);

   158

};

   159

   160

#endif /* NETWORK_PACKET_HH */