42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody#include "lib.h"

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody#include "ioloop.h"

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody#include "write-full.h"

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody#include "network.h"

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody#include "sendfile-util.h"

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody#include "istream.h"

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody#include "istream-internal.h"

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody#include "ostream-internal.h"

87b4215acbf020aa5b8dea686b23fc664140cda0Stephan Bosch

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody#include <unistd.h>

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody#include <sys/stat.h>

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody#ifdef HAVE_SYS_UIO_H

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody# include <sys/uio.h>

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody#endif

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody

87b4215acbf020aa5b8dea686b23fc664140cda0Stephan Bosch#ifndef UIO_MAXIOV

87b4215acbf020aa5b8dea686b23fc664140cda0Stephan Bosch# define UIO_MAXIOV 16

87b4215acbf020aa5b8dea686b23fc664140cda0Stephan Bosch#endif

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody#define DEFAULT_OPTIMAL_BLOCK_SIZE 4096

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody#define MAX_OPTIMAL_BLOCK_SIZE (128*1024)

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody#define IS_STREAM_EMPTY(fstream) \

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody ((fstream)->head == (fstream)->tail && !(fstream)->full)

d6bbf85809664a810726b5c711c7213874d8df57Phil Carmody

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody#define MAX_SSIZE_T(size) \

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody ((size) < SSIZE_T_MAX ? (size_t)(size) : SSIZE_T_MAX)

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmodystruct file_ostream {

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody struct _ostream ostream;

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody int fd;

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody struct io *io;

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody unsigned char *buffer; /* ring-buffer */

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody size_t buffer_size, max_buffer_size, optimal_block_size;

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody size_t head, tail; /* first unsent/unused byte */

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody unsigned int full:1; /* if head == tail, is buffer empty or full? */

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody unsigned int file:1;

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody unsigned int corked:1;

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody unsigned int flush_pending:1;

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody unsigned int no_socket_cork:1;

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody unsigned int no_sendfile:1;

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody unsigned int autoclose_fd:1;

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody};

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmodystatic void stream_send_io(void *context);

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmodystatic void stream_closed(struct file_ostream *fstream)

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody{

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody if (fstream->autoclose_fd && fstream->fd != -1) {

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody if (close(fstream->fd) < 0)

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody i_error("file_ostream.close() failed: %m");

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody fstream->fd = -1;

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody }

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody if (fstream->io != NULL) {

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody io_remove(fstream->io);

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody fstream->io = NULL;

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody }

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody fstream->ostream.ostream.closed = TRUE;

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody}

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmodystatic void _close(struct _iostream *stream)

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody{

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody struct file_ostream *fstream = (struct file_ostream *)stream;

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody

d6bbf85809664a810726b5c711c7213874d8df57Phil Carmody /* flush output before really closing it */

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody o_stream_flush(&fstream->ostream.ostream);

d6bbf85809664a810726b5c711c7213874d8df57Phil Carmody

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody stream_closed(fstream);

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody}

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmodystatic void _destroy(struct _iostream *stream)

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch{

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch struct file_ostream *fstream = (struct file_ostream *)stream;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch

87b4215acbf020aa5b8dea686b23fc664140cda0Stephan Bosch p_free(fstream->ostream.iostream.pool, fstream->buffer);

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch}

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Boschstatic void _set_max_buffer_size(struct _iostream *stream, size_t max_size)

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch{

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch struct file_ostream *fstream = (struct file_ostream *)stream;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch

87b4215acbf020aa5b8dea686b23fc664140cda0Stephan Bosch fstream->max_buffer_size = max_size;

87b4215acbf020aa5b8dea686b23fc664140cda0Stephan Bosch}

87b4215acbf020aa5b8dea686b23fc664140cda0Stephan Bosch

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Boschstatic void update_buffer(struct file_ostream *fstream, size_t size)

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch{

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch size_t used;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch if (IS_STREAM_EMPTY(fstream) || size == 0)

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch return;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch if (fstream->head < fstream->tail) {

d6bbf85809664a810726b5c711c7213874d8df57Phil Carmody /* ...HXXXT... */

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch used = fstream->tail - fstream->head;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch i_assert(size <= used);

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch fstream->head += size;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch } else {

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch /* XXXT...HXXX */

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch used = fstream->buffer_size - fstream->head;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch if (size > used) {

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch size -= used;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch i_assert(size <= fstream->tail);

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch fstream->head = size;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch } else {

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch fstream->head += size;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch }

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch fstream->full = FALSE;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch }

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch if (fstream->head == fstream->tail)

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch fstream->head = fstream->tail = 0;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch if (fstream->head == fstream->buffer_size)

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch fstream->head = 0;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch}

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Boschstatic ssize_t o_stream_writev(struct file_ostream *fstream,

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch const struct const_iovec *iov, int iov_size)

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch{

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch ssize_t ret;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch size_t size, sent;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch int i;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch if (iov_size == 1)

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch ret = write(fstream->fd, iov->iov_base, iov->iov_len);

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch else {

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch sent = 0;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch while (iov_size > UIO_MAXIOV) {

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch size = 0;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch for (i = 0; i < UIO_MAXIOV; i++)

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch size += iov[i].iov_len;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch ret = writev(fstream->fd, (const struct iovec *)iov,

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch UIO_MAXIOV);

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch if (ret != (ssize_t)size)

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch break;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch sent += ret;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch iov += UIO_MAXIOV;

d6bbf85809664a810726b5c711c7213874d8df57Phil Carmody iov_size -= UIO_MAXIOV;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch }

d6bbf85809664a810726b5c711c7213874d8df57Phil Carmody

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch if (iov_size <= UIO_MAXIOV) {

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch ret = writev(fstream->fd, (const struct iovec *)iov,

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch iov_size);

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch }

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch if (ret > 0)

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch ret += sent;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch }

87b4215acbf020aa5b8dea686b23fc664140cda0Stephan Bosch

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch if (ret < 0) {

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch if (errno == EAGAIN || errno == EINTR)

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch return 0;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch fstream->ostream.ostream.stream_errno = errno;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch stream_closed(fstream);

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch return -1;

87b4215acbf020aa5b8dea686b23fc664140cda0Stephan Bosch }

87b4215acbf020aa5b8dea686b23fc664140cda0Stephan Bosch

87b4215acbf020aa5b8dea686b23fc664140cda0Stephan Bosch return ret;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch}

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Boschstatic int o_stream_fill_iovec(struct file_ostream *fstream,

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch struct const_iovec iov[2])

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch{

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch if (IS_STREAM_EMPTY(fstream))

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch return 0;

d6bbf85809664a810726b5c711c7213874d8df57Phil Carmody

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch if (fstream->head < fstream->tail) {

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch iov[0].iov_base = fstream->buffer + fstream->head;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch iov[0].iov_len = fstream->tail - fstream->head;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch return 1;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch } else {

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch iov[0].iov_base = fstream->buffer + fstream->head;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch iov[0].iov_len = fstream->buffer_size - fstream->head;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch if (fstream->tail == 0)

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch return 1;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch else {

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch iov[1].iov_base = fstream->buffer;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch iov[1].iov_len = fstream->tail;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch return 2;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch }

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch }

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch}

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Boschstatic int buffer_flush(struct file_ostream *fstream)

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch{

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch struct const_iovec iov[2];

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch int iov_len;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch ssize_t ret;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch iov_len = o_stream_fill_iovec(fstream, iov);

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch if (iov_len > 0) {

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch ret = o_stream_writev(fstream, iov, iov_len);

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch if (ret < 0)

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch return -1;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch update_buffer(fstream, ret);

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch }

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch return IS_STREAM_EMPTY(fstream) ? 1 : 0;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch}

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Boschstatic void _cork(struct _ostream *stream, int set)

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch{

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch struct file_ostream *fstream = (struct file_ostream *)stream;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch int ret;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch if (fstream->corked != set && !stream->ostream.closed) {

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch if (set && fstream->io != NULL) {

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch io_remove(fstream->io);

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch fstream->io = NULL;

d6bbf85809664a810726b5c711c7213874d8df57Phil Carmody } else if (!set) {

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch ret = buffer_flush(fstream);

d6bbf85809664a810726b5c711c7213874d8df57Phil Carmody if (fstream->io == NULL &&

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch (ret == 0 || fstream->flush_pending)) {

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch fstream->io = io_add(fstream->fd, IO_WRITE,

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch stream_send_io, fstream);

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch }

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody }

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody if (!fstream->no_socket_cork) {

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody if (net_set_cork(fstream->fd, set) < 0)

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody fstream->no_socket_cork = TRUE;

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody }

bee4935fb14a078052e4524070910fd0b8135ef7Phil Carmody fstream->corked = set;

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody }

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody}

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmodystatic int _flush(struct _ostream *stream)

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody{

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody struct file_ostream *fstream = (struct file_ostream *) stream;

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody return buffer_flush(fstream);

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody}

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmodystatic void _flush_pending(struct _ostream *stream, int set)

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody{

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody struct file_ostream *fstream = (struct file_ostream *) stream;

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody

bee4935fb14a078052e4524070910fd0b8135ef7Phil Carmody fstream->flush_pending = set;

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody if (set && !fstream->corked && fstream->io == NULL) {

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody fstream->io = io_add(fstream->fd, IO_WRITE,

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody stream_send_io, fstream);

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody }

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody}

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody

47ca7a853a116b1be3d73b46301d97e572f2f806Phil Carmodystatic size_t get_unused_space(struct file_ostream *fstream)

47ca7a853a116b1be3d73b46301d97e572f2f806Phil Carmody{

47ca7a853a116b1be3d73b46301d97e572f2f806Phil Carmody if (fstream->head > fstream->tail) {

47ca7a853a116b1be3d73b46301d97e572f2f806Phil Carmody /* XXXT...HXXX */

bee4935fb14a078052e4524070910fd0b8135ef7Phil Carmody return fstream->head - fstream->tail;

47ca7a853a116b1be3d73b46301d97e572f2f806Phil Carmody } else if (fstream->head < fstream->tail) {

47ca7a853a116b1be3d73b46301d97e572f2f806Phil Carmody /* ...HXXXT... */

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody return (fstream->buffer_size - fstream->tail) + fstream->head;

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody } else {

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody /* either fully unused or fully used */

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody return fstream->full ? 0 : fstream->buffer_size;

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody }

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody}

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmodystatic size_t _get_used_size(struct _ostream *stream)

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody{

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody struct file_ostream *fstream = (struct file_ostream *)stream;

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody return fstream->buffer_size - get_unused_space(fstream);

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody}

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmodystatic int _seek(struct _ostream *stream, uoff_t offset)

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody{

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody struct file_ostream *fstream = (struct file_ostream *)stream;

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody off_t ret;

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody if (offset > OFF_T_MAX) {

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody stream->ostream.stream_errno = EINVAL;

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody return -1;

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody }

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody if (buffer_flush(fstream) < 0)

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody return -1;

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody ret = lseek(fstream->fd, (off_t)offset, SEEK_SET);

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody if (ret < 0) {

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody stream->ostream.stream_errno = errno;

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody return -1;

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody }

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody if (ret != (off_t)offset) {

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody stream->ostream.stream_errno = EINVAL;

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody return -1;

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody }

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody stream->ostream.stream_errno = 0;

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody stream->ostream.offset = offset;

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody return 1;

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody}

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmodystatic void o_stream_grow_buffer(struct file_ostream *fstream, size_t bytes)

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody{

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody size_t size, new_size, end_size;

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody size = pool_get_exp_grown_size(fstream->ostream.iostream.pool,

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody fstream->buffer_size,

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody fstream->buffer_size + bytes);

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody if (size > fstream->max_buffer_size) {

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody /* limit the size */

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody size = fstream->max_buffer_size;

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody } else if (fstream->corked) {

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody /* try to use optimal buffer size with corking */

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody new_size = I_MIN(fstream->optimal_block_size,

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody fstream->max_buffer_size);

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody if (new_size > size)

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody size = new_size;

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody }

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody if (size <= fstream->buffer_size)

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody return;

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody fstream->buffer = p_realloc(fstream->ostream.iostream.pool,

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody fstream->buffer,

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody fstream->buffer_size, size);

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody if (fstream->tail <= fstream->head && !IS_STREAM_EMPTY(fstream)) {

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody /* move head forward to end of buffer */

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody end_size = fstream->buffer_size - fstream->head;

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody memmove(fstream->buffer + size - end_size,

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody fstream->buffer + fstream->head, end_size);

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody fstream->head = size - end_size;

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody }

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody fstream->full = FALSE;

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody fstream->buffer_size = size;

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody}

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmodystatic void stream_send_io(void *context)

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody{

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody struct file_ostream *fstream = context;

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody int ret;

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody /* Set flush_pending = FALSE first before calling the flush callback,

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody fstream->flush_pending = FALSE;

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody o_stream_ref(&fstream->ostream.ostream);

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody if (fstream->ostream.callback != NULL)

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody ret = fstream->ostream.callback(fstream->ostream.context);

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody else

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody ret = _flush(&fstream->ostream);

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody

47ca7a853a116b1be3d73b46301d97e572f2f806Phil Carmody if (ret == 0)

629e96c5e2d4724b713ca7d62e59ed033107edcdPhil Carmody fstream->flush_pending = TRUE;

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch

4a272f5b8bacf2852c2e53f3aa8e899e0d5c604fStephan Bosch if (!fstream->flush_pending && IS_STREAM_EMPTY(fstream)) {

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody if (fstream->io != NULL) {

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody /* all sent */

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody io_remove(fstream->io);

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody fstream->io = NULL;

42826d96c8d0bba9eddc85b01bf70d7db571ae7fPhil Carmody }

} else {

if (fstream->io == NULL) {

fstream->io = io_add(fstream->fd, IO_WRITE,

stream_send_io, fstream);

}

}

o_stream_unref(&fstream->ostream.ostream);

}

static size_t o_stream_add(struct file_ostream *fstream,

const void *data, size_t size)

{

size_t unused, sent;

int i;

unused = get_unused_space(fstream);

if (unused < size)

o_stream_grow_buffer(fstream, size-unused);

sent = 0;

for (i = 0; i < 2 && sent < size && !fstream->full; i++) {

unused = fstream->tail >= fstream->head ?

fstream->buffer_size - fstream->tail :

fstream->head - fstream->tail;

if (unused > size-sent)

unused = size-sent;

memcpy(fstream->buffer + fstream->tail,

CONST_PTR_OFFSET(data, sent), unused);

sent += unused;

fstream->tail += unused;

if (fstream->tail == fstream->buffer_size)

fstream->tail = 0;

if (fstream->head == fstream->tail)

fstream->full = TRUE;

}

if (sent != 0 && fstream->io == NULL &&

!fstream->corked && !fstream->file) {

fstream->io = io_add(fstream->fd, IO_WRITE, stream_send_io,

fstream);

}

return sent;

}

static ssize_t _sendv(struct _ostream *stream, const struct const_iovec *iov,

unsigned int iov_count)

{

struct file_ostream *fstream = (struct file_ostream *)stream;

size_t size, added, optimal_size;

unsigned int i;

ssize_t ret = 0;

stream->ostream.stream_errno = 0;

for (i = 0, size = 0; i < iov_count; i++)

size += iov[i].iov_len;

if (size > get_unused_space(fstream) && !IS_STREAM_EMPTY(fstream)) {

if (_flush(stream) < 0)

return -1;

}

optimal_size = I_MIN(fstream->optimal_block_size,

fstream->max_buffer_size);

if (IS_STREAM_EMPTY(fstream) &&

(!fstream->corked || size >= optimal_size)) {

/* send immediately */

ret = o_stream_writev(fstream, iov, iov_count);

if (ret < 0)

return -1;

size = ret;

while (size > 0 && size >= iov[0].iov_len) {

size -= iov[0].iov_len;

iov++;

iov_count--;

}

if (iov_count > 0) {

added = o_stream_add(fstream,

CONST_PTR_OFFSET(iov[0].iov_base, size),

iov[0].iov_len - size);

ret += added;

if (added != iov[0].iov_len - size) {

/* buffer full */

stream->ostream.offset += ret;

return ret;

}

iov++;

iov_count--;

}

}

/* buffer it, at least partly */

for (i = 0; i < iov_count; i++) {

added = o_stream_add(fstream, iov[i].iov_base, iov[i].iov_len);

ret += added;

if (added != iov[i].iov_len)

break;

}

stream->ostream.offset += ret;

return ret;

}

static off_t io_stream_sendfile(struct _ostream *outstream,

struct istream *instream,

int in_fd, uoff_t in_size)

{

struct file_ostream *foutstream = (struct file_ostream *)outstream;

uoff_t start_offset;

uoff_t offset, send_size, v_offset;

ssize_t ret;

/* flush out any data in buffer */

if ((ret = buffer_flush(foutstream)) <= 0)

return ret;

start_offset = v_offset = instream->v_offset;

do {

offset = instream->real_stream->abs_start_offset + v_offset;

send_size = in_size - v_offset;

ret = safe_sendfile(foutstream->fd, in_fd, &offset,

MAX_SSIZE_T(send_size));

if (ret <= 0) {

if (ret == 0 || errno == EINTR || errno == EAGAIN) {

ret = 0;

break;

}

outstream->ostream.stream_errno = errno;

if (errno != EINVAL) {

/* close only if error wasn't because

stream_closed(foutstream);

}

break;

}

v_offset += ret;

outstream->ostream.offset += ret;

} while ((uoff_t)ret != send_size);

i_stream_seek(instream, v_offset);

return ret < 0 ? -1 : (off_t)(instream->v_offset - start_offset);

}

static off_t io_stream_copy(struct _ostream *outstream,

struct istream *instream, uoff_t in_size)

{

struct file_ostream *foutstream = (struct file_ostream *)outstream;

uoff_t start_offset;

struct const_iovec iov[3];

int iov_len;

const unsigned char *data;

size_t size, skip_size, block_size;

ssize_t ret;

int pos;

iov_len = o_stream_fill_iovec(foutstream, iov);

skip_size = 0;

for (pos = 0; pos < iov_len; pos++)

skip_size += iov[pos].iov_len;

start_offset = instream->v_offset;

in_size -= instream->v_offset;

while (in_size > 0) {

block_size = I_MIN(foutstream->optimal_block_size, in_size);

(void)i_stream_read_data(instream, &data, &size, block_size-1);

in_size -= size;

if (size == 0) {

/* all sent */

break;

}

pos = iov_len++;

iov[pos].iov_base = (void *) data;

iov[pos].iov_len = size;

ret = o_stream_writev(foutstream, iov, iov_len);

if (ret < 0)

return -1;

if (skip_size > 0) {

if ((size_t)ret < skip_size) {

update_buffer(foutstream, ret);

skip_size -= ret;

ret = 0;

} else {

update_buffer(foutstream, skip_size);

ret -= skip_size;

skip_size = 0;

}

}

outstream->ostream.offset += ret;

i_stream_skip(instream, ret);

if ((size_t)ret != iov[pos].iov_len)

break;

i_assert(skip_size == 0);

iov_len = 0;

}

return (off_t) (instream->v_offset - start_offset);

}

static off_t io_stream_copy_backwards(struct _ostream *outstream,

struct istream *instream, uoff_t in_size)

{

struct file_ostream *foutstream = (struct file_ostream *)outstream;

uoff_t in_start_offset, in_offset, in_limit, out_offset;

const unsigned char *data;

size_t buffer_size, size, read_size;

ssize_t ret;

i_assert(IS_STREAM_EMPTY(foutstream));

/* figure out optimal buffer size */

buffer_size = instream->real_stream->buffer_size;

if (buffer_size == 0 || buffer_size > foutstream->buffer_size) {

if (foutstream->optimal_block_size > foutstream->buffer_size) {

o_stream_grow_buffer(foutstream,

foutstream->optimal_block_size -

foutstream->buffer_size);

}

buffer_size = foutstream->buffer_size;

}

in_start_offset = instream->v_offset;

in_offset = in_limit = in_size;

out_offset = outstream->ostream.offset + (in_offset - in_start_offset);

while (in_offset > in_start_offset) {

if (in_offset - in_start_offset <= buffer_size)

read_size = in_offset - in_start_offset;

else

read_size = buffer_size;

in_offset -= read_size;

out_offset -= read_size;

for (;;) {

i_assert(in_offset <= in_limit);

i_stream_seek(instream, in_offset);

read_size = in_limit - in_offset;

(void)i_stream_read_data(instream, &data, &size,

read_size-1);

if (size >= read_size) {

size = read_size;

if (instream->mmaped) {

/* we'll have to write it through

i_assert(size <=

foutstream->buffer_size);

memcpy(foutstream->buffer, data, size);

data = foutstream->buffer;

}

break;

}

/* buffer too large probably, try with smaller */

read_size -= size;

in_offset += read_size;

out_offset += read_size;

buffer_size -= read_size;

}

in_limit -= size;

if (o_stream_seek(&outstream->ostream, out_offset) < 0)

return -1;

ret = write_full(foutstream->fd, data, size);

if (ret < 0) {

/* error */

outstream->ostream.stream_errno = errno;

return -1;

}

}

return (off_t) (in_size - in_start_offset);

}

static off_t _send_istream(struct _ostream *outstream, struct istream *instream)

{

struct file_ostream *foutstream = (struct file_ostream *)outstream;

const struct stat *st;

uoff_t in_size;

off_t ret;

int in_fd, overlapping;

st = i_stream_stat(instream);

if (st == NULL) {

outstream->ostream.stream_errno = instream->stream_errno;

return -1;

}

in_fd = i_stream_get_fd(instream);

in_size = st->st_size;

i_assert(instream->v_offset <= in_size);

outstream->ostream.stream_errno = 0;

if (in_fd != foutstream->fd)

overlapping = 0;

else {

/* copying data within same fd. we'll have to be careful with

if (in_size == (uoff_t)-1) {

outstream->ostream.stream_errno = EINVAL;

return -1;

}

ret = (off_t)outstream->ostream.offset -

(off_t)(instream->real_stream->abs_start_offset +

instream->v_offset);

if (ret == 0) {

/* copying data over itself. we don't really

return in_size - instream->v_offset;

}

overlapping = ret < 0 ? -1 : 1;

}

if (!foutstream->no_sendfile && in_fd != -1 && overlapping <= 0) {

ret = io_stream_sendfile(outstream, instream, in_fd, in_size);

if (ret >= 0 || outstream->ostream.stream_errno != EINVAL)

return ret;

/* sendfile() not supported (with this fd), fallback to

outstream->ostream.stream_errno = 0;

foutstream->no_sendfile = TRUE;

}

if (overlapping <= 0)

return io_stream_copy(outstream, instream, in_size);

else

return io_stream_copy_backwards(outstream, instream, in_size);

}

struct ostream *

o_stream_create_file(int fd, pool_t pool, size_t max_buffer_size,

int autoclose_fd)

{

struct file_ostream *fstream;

struct ostream *ostream;

struct stat st;

off_t offset;

fstream = p_new(pool, struct file_ostream, 1);

fstream->fd = fd;

fstream->max_buffer_size = max_buffer_size;

fstream->autoclose_fd = autoclose_fd;

fstream->optimal_block_size = DEFAULT_OPTIMAL_BLOCK_SIZE;

fstream->ostream.iostream.close = _close;

fstream->ostream.iostream.destroy = _destroy;

fstream->ostream.iostream.set_max_buffer_size = _set_max_buffer_size;

fstream->ostream.cork = _cork;

fstream->ostream.flush = _flush;

fstream->ostream.flush_pending = _flush_pending;

fstream->ostream.get_used_size = _get_used_size;

fstream->ostream.seek = _seek;

fstream->ostream.sendv = _sendv;

fstream->ostream.send_istream = _send_istream;

ostream = _o_stream_create(&fstream->ostream, pool);

offset = lseek(fd, 0, SEEK_CUR);

if (offset >= 0) {

ostream->offset = offset;

if (fstat(fd, &st) == 0) {

if ((uoff_t)st.st_blksize >

fstream->optimal_block_size) {

/* use the optimal block size, but with a

fstream->optimal_block_size =

I_MIN(st.st_blksize,

MAX_OPTIMAL_BLOCK_SIZE);

}

if (S_ISREG(st.st_mode)) {

fstream->no_socket_cork = TRUE;

fstream->file = TRUE;

}

}

fstream->no_sendfile = TRUE;

} else {

if (net_getsockname(fd, NULL, NULL) < 0) {

fstream->no_sendfile = TRUE;

fstream->no_socket_cork = TRUE;

}

}

if (max_buffer_size == 0)

fstream->max_buffer_size = fstream->optimal_block_size;

return ostream;

}