1

#ifndef NETWORK_BUFFER_HH

     2

#define NETWORK_BUFFER_HH

     3

     4

#include "Socket.hh"

     5

#include "../Error.hh"

     6

     7

#include <cassert>

     8

     9

/**

    10

 * Minimum chunk size to avoid handling single bytes at a time (for resize, mainly)

    11

 */

    12

const size_t NETWORK_BUFFER_CHUNK_SIZE = 1024;

    13

    14

/**

    15

 * Base class of errors thrown by NetworkBuffer* methods

    16

 */

    17

class NetworkBufferError : public Error {

    18

    public:

    19

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

    20

};

    21

    22

/**

    23

 * Base buffer-manipulation operations for buffered socket send/recv

    24

 */

    25

class NetworkBufferBase {

    26

    protected:

    27

        /** The socket that we use */

    28

        NetworkSocket socket;

    29

    30

        /** The buffer itself */

    31

        char *buf;

    32

    33

        /** Buffer size and current read/write offset */

    34

        size_t size, offset;

    35

    36

    public:

    37

        /**

    38

         * Allocate buf using the given initial size, and set offset to zero

    39

         */

    40

        NetworkBufferBase (NetworkSocket &socket, size_t size_hint);

    41

    42

        /**

    43

         * Free()'s the buf

    44

         */

    45

        ~NetworkBufferBase (void);

    46

    47

    private:

    48

        /**

    49

         * No copying, these are undefined

    50

         */

    51

        NetworkBufferBase (const NetworkBufferBase &copy);

    52

        NetworkBufferBase& operator= (const NetworkBufferBase &copy);

    53

    54

    protected:

    55

        /**

    56

         * Resize the buffer, allocating enough new space to hold <item_size> bytes at the end, and leaving any

    57

         * existing data at the beginning in-place

    58

         *

    59

         * @param item_size the number of bytes that must fit at the end of the buffer

    60

         */

    61

        void resize (size_t item_size);

    62

    63

        /**

    64

         * Trim the buffer, discarding <prefix_size> bytes at the beginning. Updates offset to match.

    65

         *

    66

         * @param prefix_size the number of bytes to discard

    67

         */

    68

        void trim (size_t prefix_size);

    69

};

    70

    71

/**

    72

 * Buffered prefix-len socket input

    73

 */

    74

class NetworkBufferInput : public NetworkBufferBase {

    75

    public:

    76

        /**

    77

         * @see NetworkBufferBase

    78

         */

    79

        NetworkBufferInput (NetworkSocket &socket, size_t size_hint);

    80

    81

    private:

    82

        /**

    83

         * Attempts to recv the given number of bytes into our buf, returning true on success

    84

         *

    85

         * @param item_size minimum number of bytes of data that we need in the buffer

    86

         * @return bool true if the buffer now contains at least item_size bytes

    87

         */

    88

        bool try_read (size_t item_size);

    89

    90

        /**

    91

         * Tests if the buffer contains at least the given amount of data, but doesn't recv or anything

    92

         *

    93

         * @param data_size number of bytes that we are expecting

    94

         * @return bool true if the buffer contains at least data_size bytes

    95

         */

    96

        bool have_data (size_t data_size);

    97

    98

    public:

    99

        // @{

   100

        /**

   101

         *

   102

         * Attempts to read the length prefix into val_ref, returning true on success, false if there's not enough data

   103

         * in the buffer

   104

         *

   105

         * @param val_ref stores the value read here if we have it

   106

         * @return bool was val_ref set

   107

         */

   108

        bool peek_prefix (uint16_t &val_ref);

   109

        bool peek_prefix (uint32_t &val_ref);

   110

        // @} 

   111

   112

        /**

   113

         * This attempts to read a length-prefix of the given type (using peek_prefix), and then the associated data.

   114

         * If succesful, this sets prefix to the length of the data, and buf_ref to point at the data inside our buffer

   115

         * and returns true, else false.

   116

         *

   117

         * This will try and consume data from the buffer, or recv if needed.

   118

         *

   119

         * @param prefix stores the data length here

   120

         * @param buf_ref stores a pointer to the data here

   121

         * @return bool true if we have the full data, false if we need to wait for more data on the socket

   122

         *

   123

         * @see peek_prefix

   124

         * @see flush_data

   125

         */

   126

        template <typename PrefixType> bool peek_data (PrefixType &prefix, char *&buf_ref) {

   127

            size_t missing = 0;

   128

   129

            do {    

   130

                // do we have the prefix?

   131

                if (peek_prefix(prefix)) {

   132

                    // do we already have the payload?

   133

                    if (offset >= sizeof(PrefixType) + prefix) {

   134

                        break;

   135

   136

                    } else {

   137

                        missing = (sizeof(PrefixType) + prefix) - offset;

   138

                    }

   139

   140

                } else {

   141

                    missing = sizeof(PrefixType);

   142

                }

   143

   144

                // sanity-check

   145

                // XXX: a zero-prefix will trigger this

   146

                assert(missing);

   147

   148

                // try and read the missing data

   149

                if (try_read(missing) == false) {

   150

                    // if unable to read what we need, return zero.

   151

                    return false;

   152

                }

   153

   154

                // assess the situation again

   155

            } while (true);

   156

   157

            // update the buf_ref to point past the prefix-length

   158

            buf_ref = buf + sizeof(PrefixType);

   159

   160

            // return

   161

            return true;

   162

        }

   163

   164

        /**

   165

         * This flushes a prefix-length worth of data from the buffer, i.e. it first reads the prefix, and then trims

   166

         * the prefix and the data away. Don't call this unless you *know* that the buffer contains enough data.

   167

         *

   168

         * @see peek_data

   169

         */

   170

        template <typename PrefixType> void flush_data (void) {

   171

            PrefixType prefix;

   172

   173

            // we *must* have a valid prefix

   176

   177

            // trim the bytes out

   178

            trim(sizeof(PrefixType) + prefix);

   179

        }

   180

};

   181

   182

/**

   183

 * Buffered prefix-len socket output

   184

 */

   185

class NetworkBufferOutput : public NetworkBufferBase {

   186

    public:

   187

        /**

   188

         * @see NetworkBufferBase

   189

         */

   190

        NetworkBufferOutput (NetworkSocket &socket, size_t size_hint);

   191

   192

    private:

   193

        /**

   194

         * Write the given data to the socket, either now of later. 

   195

         *

   196

         * If our buffer is empty, fast-path the given buf_ptr directly to send(), then copy the remaining portion to

   197

         * our buffer for later use with flush_write.

   198

         *

   199

         * @param buf_ptr the data that we need to send

   200

         * @param buf_size number of bytes in buf_ptr

   201

         */

   202

        void push_write (char *buf_ptr, size_t buf_size);

   203

   204

    public:    

   205

        /**

   206

         * If we have data in our buffer, flush it out using send().

   207

         */

   208

        void flush_write (void);

   209

   210

        // @{

   211

        /**

   212

         * Write out the given data, writing first the prefix, and then the data itself, using push_write.

   213

         *

   214

         * @param buf the data to write

   215

         * @param prefix the amount of data

   216

         */

   217

        void write_prefix (char *buf, uint16_t prefix);

   218

        void write_prefix (char *buf, uint32_t prefix);

   219

        // @}

   220

};

   221

   222

#endif