4

/**

     5

 * @file

     6

 *

     7

 * Buffering of network streams

     8

 */

     9

    29

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

    30

 *

    31

 * This implements a simple linear in-memory buffer which can contain data that must be buffered for send/recv.

    32

 * New data can be written to the end of the buffer, and data can be read/discarded from the beginning.

    33

 *

    34

 * A buffer is associated with a NetworkSocket, and takes care of all send/recv activity.

    44

        /** Buffer size and current write offset */

    68

         * existing data at the beginning in-place.

    69

         *

    70

         * This is done by doubling the buffer size until item_size fits, and then reallocing (if needed).

    71

         * Currently, the buffer is never shrunk, although it probably should be to adapt better to peak load (e.g.

    72

         * when a player joins and the map data is transmitted...).

    81

         * Currently, this is implemented as a simple memmove() of all the remaining data in the buffer, which may be

    82

         * slow under some load patterns.

    83

         *

    91

 *

    92

 * This handles calling recv() on the socket, and is specialized to handle a stream of messages prefixed with a length

    93

 * header (uint16_t or uint32_t). Use the peek_data() method to receive these messages when NetworkSocket::sig_read() 

    94

 * indicates that more data is available.

   135

         * This attempts to locate a full message in the buffer (calling recv as nessecary), prefixed with a length

   136

         * prefix of the given type (using peek_prefix). If succesfull (we have a full message in the buffer), 

   137

         * \a prefix will be updated to the length of the message (not including the prefix), and \a buf_ref will be

   138

         * updated to point at the message of \a prefix bytes (not including the prefix) in our internal buffer memory.

   139

         * If a full message could not be received (recv would block), this will return false.

   141

         * Once you have processed the message, call flush_data() to remove the unused message from the buffer.

   143

         * @param prefix updated to the message length

   144

         * @param buf_ref updated to point at the message data

   145

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

   150

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

   153

         * This flushes the current message from the buffer, as returned when peek_data returns true. It is a bug to

   154

         * call flush_data when there is no full message present, the behaviour is unspecified (most likely an

   155

         * assert()).

   159

        template <typename PrefixType> void flush_data (void);

   163

 * Buffered prefix-len socket output.

   164

 *

   165

 * This handles calling send() on the socket, and is specialized to handle a stream of message prefixed with a length

   166

 * header (uint16_t or uint32_t). You can write messages using write_prefix(), and they will be buffered if needed.

   167

 * If write_prefix() returns true (socket buffer full), then you must register the socket for

   168

 * NetworkSocket::set_poll_write(), and call flush_write() once NetworkSocket::sig_write() is triggered. The socket's

   169

 * poll_write should be unregistered once flush_write returns false (no more buffered data remaining to be sent), or

   170

 * an many processor cycles will be wasted, for the socket will remain ready for write until its buffer fills up again.

   171

 *

   172

 * Data is not buffered needlessly; if the socket's buffer has room, write_prefix will not have to touch our internal

   173

 * buffer. In fact, write_prefix will rarely return false except under heavy network congestion with high levels of

   174

 * traffic on the socket.

   185

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

   197

         * If we have data in our buffer, flush it out using send(). This should be called once the socket indicates it

   198

         * is ready for write again after a call to write_prefix that returned false. Once this returns false, the

   199

         * NetworkSocket::set_poll_write() flag should be unset again to avoid needless calls to this.

   201

         * @return true if there's still buffered data left to write, false otherwise (buffer is empty)

   207

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

   208

         *

   209

         * Returns true if the data was passed on to the socket API directly, false if a portion of it had to be

   210

         * buffered (if there is already data buffered, all subsequent write_prefix's will buffer the full message

   211

         * until our buffer is empty again). If this method returns false, you must register the socket for

   212

         * poll_write and call flush_write later.

   223

   224

/*

   225

 * NetworkBufferInput template method implementation

   226

 */

   227

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

   228

    size_t missing = 0;

   229

   230

    do {    

   231

        // do we have the prefix?

   232

        if (peek_prefix(prefix)) {

   233

            // do we already have the payload?

   234

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

   235

                break;

   236

   237

            } else {

   238

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

   239

            }

   240

   241

        } else {

   242

            missing = sizeof(PrefixType);

   243

        }

   244

   245

        // sanity-check (above >= and - should never happen like this)

   246

        assert(missing);

   247

   248

        // try and read the missing data

   249

        if (try_read(missing) == false) {

   250

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

   251

            return false;

   252

        }

   253

   254

        // assess the situation again

   255

    } while (true);

   256

   257

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

   258

    buf_ref = buf + sizeof(PrefixType);

   259

   260

    // return message

   261

    return true;

   262

}

   263

   264

template <typename PrefixType> void NetworkBufferOutput::flush_data (void) {

   265

    PrefixType prefix;

   266

   267

    // we *must* have a valid prefix

   268

    if (!peek_prefix(prefix))

   269

        assert(false);

   270

   271

    // ensure that we have the data to trim...

   272

    assert(offset >= sizeof(PrefixType) + prefix);

   273

   274

    // trim the bytes out

   275

    trim(sizeof(PrefixType) + prefix);

   276

}

   277