1

     2

#include "Buffer.hh"

     4

     5

#include <ClanLib/core.h>

     6

#include <cstdlib>

     7

     8

/*

     9

 * NetworkBufferBase

    10

 */

    11

NetworkBufferBase::NetworkBufferBase (NetworkSocket *socket, size_t size_hint) :

    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 try and calculate that in an

    30

    // infinite loop :)

    31

    if (new_size == 0)

    32

        new_size = 1;

    33

    34

    // grow new_size until item_size fits

    35

    while (offset + item_size > new_size)

    36

        new_size *= 2;

    37

    38

    // grow if needed

    39

    if (new_size != size) {

    40

        char *temp = buf;

    41

    42

        // realloc buffer

    43

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

    44

            // restore temp, but the buffer may be corrupted now

    45

            buf = temp;

    46

    47

            // raise error

    48

            throw NetworkBufferError("realloc failed");

    49

        }

    50

    51

        // update size

    52

        size = new_size;

    53

    54

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

    55

        // XXX: shrink?

    56

    }

    57

}

    58

    59

void NetworkBufferBase::trim (size_t prefix_size) {

    60

    // update offset

    61

    offset -= prefix_size;

    62

    63

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

    64

    memmove(buf, buf + prefix_size, offset);

    65

}

    66

    67

/*

    68

 * NetworkBufferInput

    69

 */

    70

NetworkBufferInput::NetworkBufferInput (NetworkSocket *socket, size_t size_hint) :

    71

    NetworkBufferBase(socket, size_hint)

    72

{

    73

    74

}

    75

    76

bool NetworkBufferInput::try_read (size_t item_size) {

    77

    size_t ret, to_read = item_size;

    78

    79

    // keept reads at at least NETWORK_BUFFER_CHUNK_SIZE bytes

    80

    if (to_read < NETWORK_BUFFER_CHUNK_SIZE)

    81

        to_read = NETWORK_BUFFER_CHUNK_SIZE;

    82

    83

    // resize buffer if needed

    84

    resize(to_read);

    85

    86

    // read once

    87

    ret = socket->recv(buf + offset, to_read);

    88

    89

    // nothing left?

    90

    if (ret == 0)

    91

        return false;

    92

    93

    // update offset

    94

    offset += ret;

    95

    96

    // did we get enough?

    97

    if ((unsigned int) ret < item_size)

    98

        return false;

    99

    else

   100

        return true;

   101

} 

   102

   103

bool NetworkBufferInput::have_data (size_t data_size) {

   104

    return (offset >= data_size);

   105

}

   106

   107

bool NetworkBufferInput::peek_prefix (uint16_t &val_ref) {

   108

    if (!have_data(sizeof(uint16_t)))

   109

        return false;

   110

   111

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

   112

   113

    return true;

   114

}

   115

   116

bool NetworkBufferInput::peek_prefix (uint32_t &val_ref) {

   117

    if (!have_data(sizeof(uint32_t)))

   118

        return false;

   119

   120

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

   121

   122

    return true;

   123

}

   124

   125

/*

   126

 * NetworkBufferOutput

   127

 */

   128

NetworkBufferOutput::NetworkBufferOutput (NetworkSocket *socket, size_t size_hint) :

   129

    NetworkBufferBase(socket, size_hint)

   130

{

   131

   132

}

   133

   134

   135

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

   136

    size_t ret;

   137

   138

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

   139

    if (offset == 0) {

   140

        // attempt to send something

   141

        ret = socket->send(buf_ptr, buf_size);

   142

   143

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

   144

        if (ret > 0) {

   145

            // sanity-check

   146

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

   147

   148

            buf_ptr += ret;

   149

            buf_size -= ret;

   150

   151

            // if that was all, we're done

   152

            if (buf_size == 0)

   153

                return;

   154

        }

   155

    }

   156

   157

    // resize to fit buf_size more bytes

   158

    resize(buf_size);

   159

   160

    // copy into our internal buffer

   161

    memcpy(buf + offset, buf_ptr, buf_size);

   162

}

   163

   164

bool NetworkBufferOutput::flush_write (void) {

   165

    size_t ret;

   166

   167

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

   168

    if (offset == 0)

   169

        return false;

   170

   171

    // attempt to write as much as possible

   172

    ret = socket->send(buf, offset);

   173

   174

    // busy?

   175

    if (ret == 0)

   176

        return true;

   177

   178

    // trim the buffer

   179

    trim(ret);

   180

   181

    // anything left?

   182

    return (offset > 0);

   183

}

   184

   185

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

   186

    uint16_t nval = htons(prefix);

   187

   188

    // XXX: not exception-safe

   189

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

   190

    push_write(buf, prefix);

   191

   192

    // anything in the buffer?

   193

    return (offset > 0);

   194

}

   195

   196

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

   197

    uint32_t nval = htonl(prefix);

   198

   199

    // XXX: not exception-safe

   200

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

   201

    push_write(buf, prefix);

   202

   203

    // anything in the buffer?

   204

    return (offset > 0);

   205

}

   206