iobuffer.h revision d2f5aacd3d549c3d39dae41b6522d585244b016d
#ifndef __IOBUFFER_H
#define __IOBUFFER_H
#include "ioloop.h"
#define IO_BUFFER_MIN_SIZE 512
typedef void (*IOBufferFlushFunc) (void *context, IOBuffer *buf);
struct _IOBuffer {
int fd;
uoff_t start_offset;
uoff_t offset, size; /* virtual offset, 0 = start_offset */
int buf_errno; /* set when write() or read() failed. */
/* private: */
Pool pool;
IO io;
int priority;
int timeout_msecs;
TimeoutFunc timeout_func;
void *timeout_context;
IOBufferFlushFunc flush_func;
void *flush_context;
unsigned char *buffer;
size_t cr_lookup_pos; /* used only when reading a line */
off_t mmap_offset;
size_t pos, skip;
size_t buffer_size, max_buffer_size;
unsigned int file:1; /* reading/writing a file */
unsigned int mmaped:1; /* reading a file with mmap() */
unsigned int closed:1; /* all further read/writes will return 0 */
unsigned int transmit:1; /* this is a transmit buffer */
unsigned int receive:1; /* this is a receive buffer */
unsigned int last_cr:1; /* we're expecting a LF to be skipped in
next call to io_buffer_next_line() */
unsigned int blocking:1; /* writes block if buffer is full */
unsigned int corked:1; /* TCP_CORK set */
};
/* Create an I/O buffer. It can be used for either sending or receiving data,
NEVER BOTH AT SAME TIME. */
IOBuffer *io_buffer_create(int fd, Pool pool, int priority,
size_t max_buffer_size);
/* Same as io_buffer_create(), but specify that we're reading/writing file. */
IOBuffer *io_buffer_create_file(int fd, Pool pool, size_t max_buffer_size);
/* Read the file by mmap()ing it in blocks. stop_offset specifies where to
stop reading, or 0 to end of file. */
IOBuffer *io_buffer_create_mmap(int fd, Pool pool, size_t block_size,
uoff_t size);
/* Destroy a buffer. */
void io_buffer_destroy(IOBuffer *buf);
/* Mark the buffer closed. Any sends/reads after this will return -1.
The data already in buffer can be used, and the remaining output buffer
will be sent. */
void io_buffer_close(IOBuffer *buf);
/* Reset all pointers so that the buffer looks empty, the actual data is
not touched and can be used. */
void io_buffer_reset(IOBuffer *buf);
/* Change the memory pool used by the buffer. Data already in
buffer will be transferred to new buffer. */
IOBuffer *io_buffer_set_pool(IOBuffer *buf, Pool pool);
/* Change the maximum size for buffer to grow. */
void io_buffer_set_max_size(IOBuffer *buf, size_t max_size);
/* Change buffer's blocking state. The blocking state in fd itself isn't
changed, and it's not needed to be blocking. This affects two things:
When buffer reaches max_size, it will block until all the data has been
sent or timeout has been reached. Setting max_size to 0 disables this
(default). Setting timeout_msecs to 0 may block infinitely, or until
socket is closed.
Sets the timeout for io_buffer_read_blocking(). If max_size is non-zero,
it acts the same as io_buffer_set_max_size().
timeout_func is called with both cases when timeout occurs.
*/
void io_buffer_set_blocking(IOBuffer *buf, size_t max_size,
int timeout_msecs, TimeoutFunc timeout_func,
void *context);
/* Set TCP_CORK on if supported, ie. don't send out partial frames.
io_buffer_send_flush() removes the cork. */
void io_buffer_cork(IOBuffer *buf);
/* Returns 1 if all was ok, -1 if disconnected, -2 if buffer is full */
int io_buffer_send(IOBuffer *buf, const void *data, size_t size);
/* Send data from input buffer to output buffer using the fastest
possible method. Returns 1 if all sent or -1 if disconnected.
Note that this function may block. */
int io_buffer_send_iobuffer(IOBuffer *outbuf, IOBuffer *inbuf,
uoff_t long_size);
/* Flush the output buffer, blocks until all is sent. If
io_buffer_set_send_blocking() is called, it's timeout settings are used. */
void io_buffer_send_flush(IOBuffer *buf);
/* Call specified function when the whole transmit buffer has been sent.
If the buffer is empty already, the function will be called immediately.
The function will be called only once. */
void io_buffer_send_flush_callback(IOBuffer *buf, IOBufferFlushFunc func,
void *context);
/* Returns number of bytes read if read was ok,
-1 if disconnected / EOF, -2 if the buffer is full */
ssize_t io_buffer_read(IOBuffer *buf);
/* Like io_buffer_read(), but don't read more than specified size. */
ssize_t io_buffer_read_max(IOBuffer *buf, size_t size);
/* Blocking read, doesn't return until at least one byte is read, or until
socket is disconnected or timeout has occured. Note that the fd must be
nonblocking, or the timeout doesn't work. If you don't want limit size,
set it to (size_t)-1. Returns number of bytes read, or -1 if error. */
ssize_t io_buffer_read_blocking(IOBuffer *buf, size_t size);
/* Skip forward a number of bytes */
void io_buffer_skip(IOBuffer *buf, uoff_t size);
/* Seek to specified position from beginning of file. This works only for
files. Returns TRUE if successful. */
int io_buffer_seek(IOBuffer *buf, uoff_t offset);
/* Returns the next line from input buffer, or NULL if more data is needed
to make a full line. NOTE: call to io_buffer_read() invalidates the
returned data. */
char *io_buffer_next_line(IOBuffer *buf);
/* Returns pointer to beginning of data in buffer,
or NULL if there's no data. */
unsigned char *io_buffer_get_data(IOBuffer *buf, size_t *size);
/* Like io_buffer_get_data(), but read it when needed. There always must be
more than `threshold' bytes in buffer. Returns 1 if data was read, 0 if
read was interrupted or nonblocking, -1 if EOF / error */
int io_buffer_read_data(IOBuffer *buf, unsigned char **data,
size_t *size, size_t threshold);
/* Returns a pointer to buffer wanted amount of space,
or NULL if size is too big. */
unsigned char *io_buffer_get_space(IOBuffer *buf, size_t size);
/* Send data saved to buffer from io_buffer_get_space().
Returns -1 if disconnected. */
int io_buffer_send_buffer(IOBuffer *buf, size_t size);
/* Put data to buffer as if it was received.
Returns 1 if successful, -2 if buffer isn't big enough. */
int io_buffer_set_data(IOBuffer *buf, const void *data, size_t size);
/* Returns TRUE if there's nothing in buffer. */
int io_buffer_is_empty(IOBuffer *buf);
#endif