1

     2

#include "Buffer.hh"

     3

#include "Config.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

    // grow new_size until item_size fits

    30

    while (offset + item_size > new_size)

    31

        new_size *= 2;

    32

    33

    // grow if needed

    34

    if (new_size != size) {

    35

        // realloc buffer

    36

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

    37

            throw NetworkBufferError("realloc failed");

    38

    39

        // update size

    40

        size = new_size;

    41

    42

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

    43

        // XXX: shrink?

    44

    }

    45

}

    46

    47

void NetworkBufferBase::trim (size_t prefix_size) {

    48

    // update offset

    49

    offset -= prefix_size;

    50

    51

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

    52

    memmove(buf, buf + prefix_size, offset);

    53

}

    54

    55

/*

    56

 * NetworkBufferInput

    57

 */

    58

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

    59

    NetworkBufferBase(socket, size_hint)

    60

{

    61

    62

}

    63

    64

bool NetworkBufferInput::try_read (size_t item_size) {

    65

    int ret;

    66

    size_t to_read = item_size;

    67

    68

    // keept reads at at least NETWORK_BUFFER_CHUNK_SIZE bytes

    69

    if (to_read < NETWORK_BUFFER_CHUNK_SIZE)

    70

        to_read = NETWORK_BUFFER_CHUNK_SIZE;

    71

    72

    // resize buffer if needed

    73

    resize(to_read);

    74

    75

    // read once

    76

    try {

    77

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

    78

    79

    } catch (CL_Error &e) {

    80

        if (errno == EAGAIN)

    81

            return false;

    82

    83

        else

    84

            throw NetworkSocketOSError(socket, "recv");

    85

    }

    86

    87

    // handle EOF

    88

    if (ret == 0)

    89

        throw NetworkSocketEOFError(socket, "recv");

    90

    91

    assert(ret >= 0);

    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

    int ret;

   137

   138

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

   139

    if (offset == 0) {

   140

        try {

   141

            // attempt to send something

   142

            ret = socket.send(buf_ptr, buf_size);

   143

   144

        } catch (CL_Error &e) {

   145

            // ignore EAGAIN, detect this by setting ret to -1

   146

            if (errno != EAGAIN)

   147

                throw NetworkSocketOSError(socket, "send");

   148

   149

            ret = -1;

   150

        }

   151

   152

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

   153

        if (ret > 0) {

   154

            // sanity-check

   155

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

   156

   157

            buf_ptr += ret;

   158

            buf_size -= ret;

   159

   160

            // if that was all, we're done

   161

            if (buf_size == 0)

   162

                return;

   163

        }

   164

    }

   165

   166

    // resize to fit buf_size more bytes

   167

    resize(buf_size);

   168

   169

    // copy into our internal buffer

   170

    memcpy(buf + offset, buf_ptr, buf_size);

   171

}

   172

   173

void NetworkBufferOutput::flush_write (void) {

   174

    int ret;

   175

   176

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

   177

    if (offset == 0)

   178

        return;

   179

   180

    // attempt to write as much as possible

   181

    try {

   182

        ret = socket.send(buf, offset);

   183

   184

    } catch (CL_Error &e) {

   185

        // ignore EAGAIN and just return

   186

        if (errno == EAGAIN)

   187

            return;

   188

   189

        else

   190

            throw NetworkSocketOSError(socket, "send");

   191

    }

   192

   193

    // trim the buffer

   194

    trim(ret);

   195

}

   196

   197

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

   198

    uint16_t nval = htons(prefix);

   199

   200

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

   201

    push_write(buf, prefix);

   202

}

   203

   204

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

   205

    uint32_t nval = htonl(prefix);

   206

   207

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

   208

    push_write(buf, prefix);

   209

}

   210

   211