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 class NetworkBufferError : public Error {

    15     public:

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

    17 };

    18 

    19 /*

    20  * Base buffer operations for uffered socket send/recv

    21  */

    22 class NetworkBufferBase {

    23     protected:

    24         // the socket that we use

    25         NetworkSocket socket;

    26 

    27         char *buf;

    28         size_t size, offset;

    29     

    30     public:

    31         NetworkBufferBase (NetworkSocket &socket, size_t size_hint);

    32         ~NetworkBufferBase (void);

    33     

    34     private:

    35         NetworkBufferBase (const NetworkBufferBase &copy);

    36         NetworkBufferBase& operator= (const NetworkBufferBase &copy);

    37     

    38     protected:

    39         void resize (size_t item_size);

    40         void trim (size_t prefix_size);

    41 };

    42 

    43 /*

    44  * Buffered prefix-len socket input

    45  */

    46 class NetworkBufferInput : public NetworkBufferBase {

    47     public:

    48         NetworkBufferInput (NetworkSocket &socket, size_t size_hint);

    49 

    50     private:

    51         /*

    52          * Attempts to recv the given number of bytes, returning true on success

    53          */

    54         bool try_read (size_t item_size);

    55 

    56         /*

    57          * Returns true if the buffer contains at least the given amount of data

    58          */

    59         bool have_data (size_t data_size);

    60     

    61     public:

    62         /*

    63          * Attempts to read the length prefix into val_ref, returning true on success

    64          */

    65         bool peek_prefix (uint16_t &val_ref);

    66         bool peek_prefix (uint32_t &val_ref);

    67         

    68         /*

    69          * This attempts to collect the prefix + data into our buffer, and then returns the length and a pointer to the

    70          * internal memory buffer. Use flush_data when done with the data

    71          */

    72 

    73         // XXX: template definition moved here from .cc

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

    75             size_t missing = 0;

    76             

    77             do {    

    78                 // do we have the prefix?

    79                 if (peek_prefix(prefix)) {

    80                     // do we already have the payload?

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

    82                         break;

    83 

    84                     } else {

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

    86                     }

    87 

    88                 } else {

    89                     missing = sizeof(PrefixType);

    90                 }

    91 

    92                 // sanity-check

    93                 // XXX: a zero-prefix will trigger this

    94                 assert(missing);

    95                 

    96                 // try and read the missing data

    97                 if (try_read(missing) == false) {

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

    99                     return false;

   100                 }

   101                 

   102                 // assess the situation again

   103             } while (true);

   104             

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

   106             buf_ref = buf + sizeof(PrefixType);

   107 

   108             // return

   109             return true;

   110         }

   111             

   112         template <typename PrefixType> void flush_data (void) {

   113             PrefixType prefix;

   114             

   115             // we *must* have a valid prefix

   116             assert(peek_prefix(prefix));

   117 

   118             // trim the bytes out

   119             trim(sizeof(PrefixType) + prefix);

   120         }

   121 };

   122 

   123 /*

   124  * Buffered prefix-len socket output

   125  */

   126 class NetworkBufferOutput : public NetworkBufferBase {

   127     public:

   128         NetworkBufferOutput (NetworkSocket &socket, size_t size_hint);

   129 

   130     private:

   131         /*

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

   133          * portion to our buffer for later use with flush_write

   134          */

   135         void push_write (char *buf_ptr, size_t buf_size);

   136    

   137     public:    

   138         /*

   139          * Try and send() stuff out of our buffer, or ignore if it's empty

   140          */

   141         void flush_write (void);

   142         

   143         /*

   144          * push_write, first the given prefix and then the buf (which contains <prefix> bytes of data)

   145          */

   146         void write_prefix (char *buf, uint16_t prefix);

   147         void write_prefix (char *buf, uint32_t prefix);

   148 };

   149 

   150 #endif