1

     2

#include "Buffer.hh"

     3

#include "Config.hh"

     4

     5

#include <ClanLib/core.h>

     6

#include <cstdlib>

     7

     8

/*

     9

 * NetworkBufferBase

    10

 */

    12

    socket(socket), buf(0), size(0), offset(0) {

    13

    14

    // allocate initial buffer

    15

    if ((buf = (char *) malloc(size_hint)) == NULL)

    16

       throw NetworkBufferError("malloc failed");

    17

    18

    // remember size

    19

    size = size_hint;

    20

}

    21

    22

NetworkBufferBase::~NetworkBufferBase (void) {

    23

    free(buf);

    24

}

    25

    26

void NetworkBufferBase::resize (size_t item_size) {

    27

    size_t new_size = size;

    28

    29

    // make sure that new_size isn't zero, because zero times two is zero, even if you do that in an infinite loop :)

    30

    if (new_size == 0)

    31

        new_size = 1;

    32

    33

    // grow new_size until item_size fits

    34

    while (offset + item_size > new_size)

    35

        new_size *= 2;

    36

    37

    // grow if needed

    38

    if (new_size != size) {

    39

        // realloc buffer

    40

        if ((buf = (char *) realloc((void *) buf, new_size)) == NULL)

    41

            throw NetworkBufferError("realloc failed");

    42

    43

        // update size

    44

        size = new_size;

    45

    46

    } else if (new_size > (offset + item_size) * 4) {

    47

        // XXX: shrink?

    48

    }

    49

}

    50

    51

void NetworkBufferBase::trim (size_t prefix_size) {

    52

    // update offset

    53

    offset -= prefix_size;

    54

    55

    // shift the buffer forwards from (buf + prefix) -> (buf), copying (old_offset - prefix) bytes

    56

    memmove(buf, buf + prefix_size, offset);

    57

}

    58

    59

/*

    60

 * NetworkBufferInput

    61

 */

    63

    NetworkBufferBase(socket, size_hint)

    64

{

    65

    66

}

    67

    68

bool NetworkBufferInput::try_read (size_t item_size) {

    70

    71

    // keept reads at at least NETWORK_BUFFER_CHUNK_SIZE bytes

    72

    if (to_read < NETWORK_BUFFER_CHUNK_SIZE)

    73

        to_read = NETWORK_BUFFER_CHUNK_SIZE;

    74

    75

    // resize buffer if needed

    76

    resize(to_read);

    77

    78

    // read once

    80

    82

    if (ret == 0)

    84

    85

    // update offset

    86

    offset += ret;

    87

    88

    // did we get enough?

    89

    if ((unsigned int) ret < item_size)

    90

        return false;

    91

    else

    92

        return true;

    93

} 

    94

    95

bool NetworkBufferInput::have_data (size_t data_size) {

    96

    return (offset >= data_size);

    97

}

    98

    99

bool NetworkBufferInput::peek_prefix (uint16_t &val_ref) {

   100

    if (!have_data(sizeof(uint16_t)))

   101

        return false;

   102

   103

    val_ref = ntohs(*((uint16_t *) (buf)));

   104

   105

    return true;

   106

}

   107

   108

bool NetworkBufferInput::peek_prefix (uint32_t &val_ref) {

   109

    if (!have_data(sizeof(uint32_t)))

   110

        return false;

   111

   112

    val_ref = ntohl(*((uint32_t *) (buf)));

   113

   114

    return true;

   115

}

   116

   117

/*

   118

 * NetworkBufferOutput

   119

 */

   121

    NetworkBufferBase(socket, size_hint)

   122

{

   123

   124

}

   125

   126

   127

void NetworkBufferOutput::push_write (char *buf_ptr, size_t buf_size) {

   129

   130

    // try and short-circuit writes unless we have already buffered data

   131

    if (offset == 0) {

   134

   135

        // if we managed to send something, adjust buf/size and buffer

   136

        if (ret > 0) {

   137

            // sanity-check

   138

            assert(buf_size >= (unsigned int) ret);

   139

   140

            buf_ptr += ret;

   141

            buf_size -= ret;

   142

   143

            // if that was all, we're done

   144

            if (buf_size == 0)

   145

                return;

   146

        }

   147

    }

   148

   149

    // resize to fit buf_size more bytes

   150

    resize(buf_size);

   151

   152

    // copy into our internal buffer

   153

    memcpy(buf + offset, buf_ptr, buf_size);

   154

}

   155

   156

void NetworkBufferOutput::flush_write (void) {

   158

   159

    // ignore if we don't have any data buffered

   160

    if (offset == 0)

   161

        return;

   162

   163

    // attempt to write as much as possible

   165

   169

   170

    // trim the buffer

   171

    trim(ret);

   172

}

   173

   174

void NetworkBufferOutput::write_prefix (char *buf, uint16_t prefix) {

   175

    uint16_t nval = htons(prefix);

   176

   177

    push_write((char*) &nval, sizeof(uint16_t)); 

   178

    push_write(buf, prefix);

   179

}

   180

   181

void NetworkBufferOutput::write_prefix (char *buf, uint32_t prefix) {

   182

    uint32_t nval = htonl(prefix);

   183

   184

    push_write((char*) &nval, sizeof(uint32_t)); 

   185

    push_write(buf, prefix);

   186

}

   187

   188