struct istream *i_stream_create_raw_mbox(struct istream *input)
{
struct raw_mbox_istream *rstream;
i_assert(input->v_offset == 0);
rstream = i_new(struct raw_mbox_istream, 1);
rstream->body_offset = (uoff_t)-1;
rstream->mail_size = (uoff_t)-1;
rstream->received_time = (time_t)-1;
rstream->next_received_time = (time_t)-1;
rstream->istream.iostream.destroy = i_stream_raw_mbox_destroy;
rstream->istream.max_buffer_size = input->real_stream->max_buffer_size;
rstream->istream.read = i_stream_raw_mbox_read;
rstream->istream.seek = i_stream_raw_mbox_seek;
rstream->istream.sync = i_stream_raw_mbox_sync;
rstream->istream.stat = i_stream_raw_mbox_stat;
rstream->istream.istream.readable_fd = input->readable_fd;
rstream->istream.istream.blocking = input->blocking;
rstream->istream.istream.seekable = input->seekable;
return i_stream_create(&rstream->istream, input, -1);
}
struct istream *tee_i_stream_create_child(struct tee_istream *tee)
{
struct tee_child_istream *tstream;
struct istream *ret, *input = tee->input;
tstream = i_new(struct tee_child_istream, 1);
tstream->tee = tee;
tstream->istream.max_buffer_size = input->real_stream->max_buffer_size;
tstream->istream.iostream.close = i_stream_tee_close;
tstream->istream.iostream.destroy = i_stream_tee_destroy;
tstream->istream.iostream.set_max_buffer_size =
i_stream_tee_set_max_buffer_size;
tstream->istream.read = i_stream_tee_read;
tstream->istream.stat = i_stream_tee_stat;
tstream->istream.sync = i_stream_tee_sync;
tstream->next = tee->children;
tee->children = tstream;
ret = i_stream_create(&tstream->istream, input, i_stream_get_fd(input));
i_stream_set_name(&tstream->istream.istream, i_stream_get_name(input));
/* we keep the reference in tee stream, no need for extra references */
i_stream_unref(&input);
return ret;
}
struct istream *i_stream_create_lzma(struct istream *input, bool log_errors)
{
struct lzma_istream *zstream;
zstream = i_new(struct lzma_istream, 1);
zstream->eof_offset = (uoff_t)-1;
zstream->stream_size = (uoff_t)-1;
zstream->log_errors = log_errors;
i_stream_lzma_init(zstream);
zstream->istream.iostream.close = i_stream_lzma_close;
zstream->istream.max_buffer_size = input->real_stream->max_buffer_size;
zstream->istream.read = i_stream_lzma_read;
zstream->istream.seek = i_stream_lzma_seek;
zstream->istream.stat = i_stream_lzma_stat;
zstream->istream.sync = i_stream_lzma_sync;
zstream->istream.istream.readable_fd = FALSE;
zstream->istream.istream.blocking = input->blocking;
zstream->istream.istream.seekable = input->seekable;
return i_stream_create(&zstream->istream, input,
i_stream_get_fd(input));
}
struct istream *
i_stream_create_rawlog(struct istream *input, const char *rawlog_path,
int rawlog_fd, enum iostream_rawlog_flags flags)
{
struct rawlog_istream *rstream;
i_assert(rawlog_path != NULL);
i_assert(rawlog_fd != -1);
rstream = i_new(struct rawlog_istream, 1);
rstream->istream.max_buffer_size = input->real_stream->max_buffer_size;
rstream->istream.stream_size_passthrough = TRUE;
rstream->riostream.rawlog_path = i_strdup(rawlog_path);
rstream->riostream.rawlog_fd = rawlog_fd;
iostream_rawlog_init(&rstream->riostream, flags, TRUE);
rstream->istream.read = i_stream_rawlog_read;
rstream->istream.iostream.close = i_stream_rawlog_close;
rstream->istream.iostream.destroy = i_stream_rawlog_destroy;
rstream->istream.istream.readable_fd = input->readable_fd;
rstream->istream.istream.blocking = input->blocking;
rstream->istream.istream.seekable = input->seekable;
return i_stream_create(&rstream->istream, input,
i_stream_get_fd(input));
}
struct istream *
http_server_request_get_payload_input(struct http_server_request *req,
bool blocking)
{
struct http_server_istream *hsristream;
struct istream *payload = req->req.payload;
i_assert(req->payload_input == NULL);
hsristream = i_new(struct http_server_istream, 1);
hsristream->req = req;
hsristream->istream.max_buffer_size =
payload->real_stream->max_buffer_size;
hsristream->istream.stream_size_passthrough = TRUE;
hsristream->istream.read = http_server_istream_read;
hsristream->istream.switch_ioloop = http_server_istream_switch_ioloop;
hsristream->istream.iostream.destroy = http_server_istream_destroy;
hsristream->istream.istream.readable_fd = FALSE;
hsristream->istream.istream.blocking = blocking;
hsristream->istream.istream.seekable = FALSE;
req->payload_input = i_stream_create
(&hsristream->istream, payload, i_stream_get_fd(payload));
i_stream_unref(&req->req.payload);
return req->payload_input;
}
struct istream *i_stream_create_error(int stream_errno)
{
struct istream_private *stream;
stream = i_new(struct istream_private, 1);
stream->istream.closed = TRUE;
stream->istream.readable_fd = FALSE;
stream->istream.blocking = TRUE;
stream->istream.seekable = TRUE;
stream->istream.eof = TRUE;
stream->istream.stream_errno = stream_errno;
i_stream_create(stream, NULL, -1);
i_stream_set_name(&stream->istream, "(error)");
return &stream->istream;
}
static struct istream *
i_stream_create_file_common(int fd, const char *path,
size_t max_buffer_size, bool autoclose_fd)
{
struct file_istream *fstream;
struct istream *input;
struct stat st;
bool is_file;
fstream = i_new(struct file_istream, 1);
fstream->autoclose_fd = autoclose_fd;
fstream->istream.iostream.close = i_stream_file_close;
fstream->istream.max_buffer_size = max_buffer_size;
fstream->istream.read = i_stream_file_read;
fstream->istream.seek = i_stream_file_seek;
fstream->istream.sync = i_stream_file_sync;
fstream->istream.stat = i_stream_file_stat;
/* if it's a file, set the flags properly */
if (fd == -1)
is_file = TRUE;
else if (fstat(fd, &st) < 0)
is_file = FALSE;
else if (S_ISREG(st.st_mode))
is_file = TRUE;
else if (!S_ISDIR(st.st_mode))
is_file = FALSE;
else {
/* we're trying to open a directory.
we're not designed for it. */
io_stream_set_error(&fstream->istream.iostream,
"%s is a directory, can't read it as file",
path != NULL ? path : t_strdup_printf("<fd %d>", fd));
fstream->istream.istream.stream_errno = EISDIR;
is_file = FALSE;
}
if (is_file) {
fstream->file = TRUE;
fstream->istream.istream.blocking = TRUE;
fstream->istream.istream.seekable = TRUE;
}
fstream->istream.istream.readable_fd = TRUE;
input = i_stream_create(&fstream->istream, NULL, fd);
i_stream_set_name(input, is_file ? "(file)" : "(fd)");
return input;
}
struct istream *i_stream_create_qp_decoder(struct istream *input)
{
struct qp_decoder_istream *bstream;
bstream = i_new(struct qp_decoder_istream, 1);
bstream->istream.max_buffer_size = input->real_stream->max_buffer_size;
bstream->istream.read = i_stream_qp_decoder_read;
bstream->istream.seek = i_stream_qp_decoder_seek;
bstream->istream.istream.readable_fd = FALSE;
bstream->istream.istream.blocking = input->blocking;
bstream->istream.istream.seekable = input->seekable;
return i_stream_create(&bstream->istream, input,
i_stream_get_fd(input));
}
struct istream *i_stream_create_nonuls(struct istream *input, char replace_chr)
{
struct nonuls_istream *nstream;
nstream = i_new(struct nonuls_istream, 1);
nstream->istream.max_buffer_size = input->real_stream->max_buffer_size;
nstream->istream.stream_size_passthrough = TRUE;
nstream->istream.read = i_stream_nonuls_read;
nstream->istream.istream.readable_fd = FALSE;
nstream->istream.istream.blocking = input->blocking;
nstream->istream.istream.seekable = FALSE;
nstream->replace_chr = replace_chr;
return i_stream_create(&nstream->istream, input,
i_stream_get_fd(input));
}
struct istream *test_istream_create_data(const void *data, size_t size)
{
struct test_istream *tstream;
tstream = i_new(struct test_istream, 1);
tstream->istream.buffer = data;
tstream->istream.read = test_read;
tstream->istream.seek = test_seek;
tstream->istream.istream.blocking = FALSE;
tstream->istream.istream.seekable = TRUE;
i_stream_create(&tstream->istream, NULL, -1);
tstream->istream.statbuf.st_size = tstream->max_pos = size;
tstream->allow_eof = TRUE;
tstream->istream.max_buffer_size = (size_t)-1;
return &tstream->istream.istream;
}
struct istream *
http_transfer_chunked_istream_create(struct istream *input)
{
struct http_transfer_chunked_istream *tcstream;
tcstream = i_new(struct http_transfer_chunked_istream, 1);
tcstream->istream.max_buffer_size =
input->real_stream->max_buffer_size;
tcstream->istream.iostream.destroy = http_transfer_chunked_istream_destroy;
tcstream->istream.read = http_transfer_chunked_istream_read;
tcstream->istream.istream.readable_fd = FALSE;
tcstream->istream.istream.blocking = input->blocking;
tcstream->istream.istream.seekable = FALSE;
return i_stream_create(&tcstream->istream, input, i_stream_get_fd(input));
}
struct istream *openssl_i_stream_create_ssl(struct ssl_iostream *ssl_io)
{
struct ssl_istream *sstream;
ssl_io->refcount++;
sstream = i_new(struct ssl_istream, 1);
sstream->ssl_io = ssl_io;
sstream->istream.iostream.close = i_stream_ssl_close;
sstream->istream.iostream.destroy = i_stream_ssl_destroy;
sstream->istream.max_buffer_size =
ssl_io->plain_input->real_stream->max_buffer_size;
sstream->istream.read = i_stream_ssl_read;
sstream->istream.istream.readable_fd = FALSE;
return i_stream_create(&sstream->istream, NULL,
i_stream_get_fd(ssl_io->plain_input));
}
struct istream *i_stream_create_dot(struct istream *input, bool send_last_lf)
{
struct dot_istream *dstream;
dstream = i_new(struct dot_istream, 1);
dstream->istream.max_buffer_size = input->real_stream->max_buffer_size;
dstream->istream.read = i_stream_dot_read;
dstream->istream.istream.readable_fd = FALSE;
dstream->istream.istream.blocking = input->blocking;
dstream->istream.istream.seekable = FALSE;
dstream->send_last_lf = send_last_lf;
dstream->state = 2;
dstream->state_no_cr = TRUE;
dstream->state_no_lf = TRUE;
return i_stream_create(&dstream->istream, input,
i_stream_get_fd(input));
}
struct istream *i_stream_create_mail_stats_counter(struct mail_private *mail,
struct istream *input)
{
struct mail_stats_istream *mstream;
mstream = i_new(struct mail_stats_istream, 1);
mstream->mail = mail;
mstream->istream.max_buffer_size = input->real_stream->max_buffer_size;
mstream->istream.parent = input;
mstream->istream.read = i_stream_mail_stats_read_mail_stats;
mstream->istream.seek = i_stream_mail_stats_seek;
mstream->istream.stat = i_stream_mail_stats_stat;
mstream->istream.istream.blocking = input->blocking;
mstream->istream.istream.seekable = input->seekable;
return i_stream_create(&mstream->istream, input,
i_stream_get_fd(input));
}
struct istream *i_stream_create_mmap(int fd, size_t block_size,
uoff_t start_offset, uoff_t v_size,
bool autoclose_fd)
{
struct mmap_istream *mstream;
struct istream *istream;
struct stat st;
if (mmap_pagemask == 0)
mmap_pagemask = mmap_get_page_size()-1;
if (v_size == 0) {
if (fstat(fd, &st) < 0)
i_error("i_stream_create_mmap(): fstat() failed: %m");
else {
v_size = st.st_size;
if (start_offset > v_size)
start_offset = v_size;
v_size -= start_offset;
}
}
mstream = i_new(struct mmap_istream, 1);
mstream->autoclose_fd = autoclose_fd;
mstream->v_size = v_size;
mstream->istream.iostream.close = i_stream_mmap_close;
mstream->istream.iostream.destroy = i_stream_mmap_destroy;
mstream->istream.max_buffer_size = block_size;
mstream->istream.read = i_stream_mmap_read;
mstream->istream.seek = i_stream_mmap_seek;
mstream->istream.sync = i_stream_mmap_sync;
mstream->istream.stat = i_stream_mmap_stat;
mstream->istream.istream.readable_fd = TRUE;
mstream->istream.abs_start_offset = start_offset;
istream = i_stream_create(&mstream->istream, NULL, fd);
istream->mmaped = TRUE;
istream->blocking = TRUE;
istream->seekable = TRUE;
return istream;
}
struct istream *i_stream_create_limit(struct istream *input, uoff_t v_size)
{
struct limit_istream *lstream;
lstream = i_new(struct limit_istream, 1);
lstream->v_size = v_size;
lstream->istream.max_buffer_size = input->real_stream->max_buffer_size;
lstream->istream.iostream.destroy = i_stream_limit_destroy;
lstream->istream.read = i_stream_limit_read;
lstream->istream.stat = i_stream_limit_stat;
lstream->istream.get_size = i_stream_limit_get_size;
lstream->istream.istream.readable_fd = input->readable_fd;
lstream->istream.istream.blocking = input->blocking;
lstream->istream.istream.seekable = input->seekable;
return i_stream_create(&lstream->istream, input,
i_stream_get_fd(input));
}
struct istream *i_stream_create_mail(struct mail *mail, struct istream *input,
bool input_has_body)
{
struct mail_istream *mstream;
mstream = i_new(struct mail_istream, 1);
mstream->mail = mail;
mstream->input_has_body = input_has_body;
mstream->expected_size = (uoff_t)-1;
(void)i_stream_mail_try_get_cached_size(mstream);
mstream->istream.max_buffer_size = input->real_stream->max_buffer_size;
mstream->istream.stream_size_passthrough = TRUE;
mstream->istream.read = i_stream_mail_read;
mstream->istream.istream.blocking = input->blocking;
mstream->istream.istream.seekable = input->seekable;
return i_stream_create(&mstream->istream, input,
i_stream_get_fd(input));
}
struct istream *
i_stream_create_callback(istream_callback_read_t *callback, void *context)
{
struct callback_istream *cstream;
struct istream *istream;
i_assert(callback != NULL);
cstream = i_new(struct callback_istream, 1);
cstream->callback = callback;
cstream->context = context;
cstream->buf = buffer_create_dynamic(default_pool, 1024);
cstream->istream.iostream.destroy = i_stream_callback_destroy;
cstream->istream.read = i_stream_callback_read;
istream = i_stream_create(&cstream->istream, NULL, -1);
istream->blocking = TRUE;
return istream;
}
static struct istream *quoted_string_istream_create
(struct managesieve_parser *parser)
{
struct quoted_string_istream *qsstream;
qsstream = i_new(struct quoted_string_istream, 1);
qsstream->parser = parser;
qsstream->istream.max_buffer_size =
parser->input->real_stream->max_buffer_size;
qsstream->istream.read = quoted_string_istream_read;
qsstream->istream.stat = quoted_string_istream_stat;
qsstream->istream.istream.readable_fd = FALSE;
qsstream->istream.istream.blocking = parser->input->blocking;
qsstream->istream.istream.seekable = FALSE;
return i_stream_create(&qsstream->istream, parser->input,
i_stream_get_fd(parser->input));
}
struct istream *
i_stream_create_ext_filter(struct istream *input, const char *socket_path,
const char *args)
{
struct mail_filter_istream *mstream;
mstream = i_new(struct mail_filter_istream, 1);
mstream->istream.iostream.close = i_stream_mail_filter_close;
mstream->istream.max_buffer_size = input->real_stream->max_buffer_size;
mstream->istream.read = i_stream_mail_filter_read;
mstream->istream.stat = i_stream_mail_filter_stat;
mstream->istream.istream.readable_fd = FALSE;
mstream->istream.istream.blocking = input->blocking;
mstream->istream.istream.seekable = FALSE;
mstream->fd = -1;
(void)filter_connect(mstream, socket_path, args);
return i_stream_create(&mstream->istream, input, mstream->fd);
}
struct istream *
i_stream_create_hash(struct istream *input, const struct hash_method *method,
void *hash_context)
{
struct hash_istream *hstream;
hstream = i_new(struct hash_istream, 1);
hstream->istream.max_buffer_size = input->real_stream->max_buffer_size;
hstream->istream.stream_size_passthrough = TRUE;
hstream->istream.read = i_stream_hash_read;
hstream->istream.seek = i_stream_hash_seek;
hstream->istream.istream.blocking = input->blocking;
hstream->istream.istream.seekable = input->seekable;
hstream->method = method;
hstream->hash_context = hash_context;
return i_stream_create(&hstream->istream, input,
i_stream_get_fd(input));
}
static
struct decrypt_istream *i_stream_create_decrypt_common(struct istream *input)
{
struct decrypt_istream *dstream;
dstream = i_new(struct decrypt_istream, 1);
dstream->istream.max_buffer_size = input->real_stream->max_buffer_size;
dstream->istream.read = i_stream_decrypt_read;
dstream->istream.iostream.close = i_stream_decrypt_close;
dstream->istream.iostream.destroy = i_stream_decrypt_destroy;
dstream->istream.istream.readable_fd = FALSE;
dstream->istream.istream.blocking = input->blocking;
dstream->istream.istream.seekable = FALSE;
dstream->buf = buffer_create_dynamic(default_pool, 512);
(void)i_stream_create(&dstream->istream, input,
i_stream_get_fd(input));
return dstream;
}
struct istream *
i_stream_create_metawrap(struct istream *input,
metawrap_callback_t *callback, void *context)
{
struct metawrap_istream *mstream;
mstream = i_new(struct metawrap_istream, 1);
mstream->istream.max_buffer_size = input->real_stream->max_buffer_size;
mstream->istream.read = i_stream_metawrap_read;
mstream->istream.seek = i_stream_metawrap_seek;
mstream->istream.stat = input->seekable ? i_stream_metawrap_stat : NULL;
mstream->istream.istream.readable_fd = input->readable_fd;
mstream->istream.istream.blocking = input->blocking;
mstream->istream.istream.seekable = input->seekable;
mstream->in_metadata = TRUE;
mstream->callback = callback;
mstream->context = context;
return i_stream_create(&mstream->istream, input,
i_stream_get_fd(input));
}
struct istream *
i_stream_create_base64_encoder(struct istream *input,
unsigned int chars_per_line, bool crlf)
{
struct base64_encoder_istream *bstream;
i_assert(chars_per_line % 4 == 0);
bstream = i_new(struct base64_encoder_istream, 1);
bstream->chars_per_line = chars_per_line;
bstream->crlf = crlf;
bstream->istream.max_buffer_size = input->real_stream->max_buffer_size;
bstream->istream.read = i_stream_base64_encoder_read;
bstream->istream.seek = i_stream_base64_encoder_seek;
bstream->istream.istream.readable_fd = FALSE;
bstream->istream.istream.blocking = input->blocking;
bstream->istream.istream.seekable = input->seekable;
return i_stream_create(&bstream->istream, input,
i_stream_get_fd(input));
}
struct istream *
i_stream_create_failure_at(struct istream *input, uoff_t failure_offset,
const char *error_string)
{
struct failure_at_istream *fstream;
fstream = i_new(struct failure_at_istream, 1);
fstream->istream.max_buffer_size = input->real_stream->max_buffer_size;
fstream->istream.stream_size_passthrough = TRUE;
fstream->istream.read = i_stream_failure_at_read;
fstream->istream.iostream.destroy = i_stream_failure_at_destroy;
fstream->istream.istream.readable_fd = input->readable_fd;
fstream->istream.istream.blocking = input->blocking;
fstream->istream.istream.seekable = input->seekable;
fstream->error_string = i_strdup(error_string);
fstream->failure_offset = failure_offset;
return i_stream_create(&fstream->istream, input,
i_stream_get_fd(input));
}
struct istream *
i_stream_create_fs_file(struct fs_file **file, size_t max_buffer_size)
{
struct fs_file_istream *fstream;
struct istream *input;
fstream = i_new(struct fs_file_istream, 1);
fstream->file = *file;
fstream->istream.iostream.close = i_stream_fs_file_close;
fstream->istream.max_buffer_size = max_buffer_size;
fstream->istream.read = i_stream_fs_file_read;
fstream->istream.stream_size_passthrough = TRUE;
fstream->istream.istream.blocking =
((*file)->flags & FS_OPEN_FLAG_ASYNC) == 0;
fstream->istream.istream.seekable =
((*file)->flags & FS_OPEN_FLAG_SEEKABLE) != 0;
input = i_stream_create(&fstream->istream, NULL, -1);
i_stream_set_name(input, fs_file_path(*file));
*file = NULL;
return input;
}
struct istream *i_stream_create_lz4(struct istream *input, bool log_errors)
{
struct lz4_istream *zstream;
zstream = i_new(struct lz4_istream, 1);
zstream->stream_size = (uoff_t)-1;
zstream->log_errors = log_errors;
zstream->istream.iostream.close = i_stream_lz4_close;
zstream->istream.max_buffer_size = input->real_stream->max_buffer_size;
zstream->istream.read = i_stream_lz4_read;
zstream->istream.seek = i_stream_lz4_seek;
zstream->istream.stat = i_stream_lz4_stat;
zstream->istream.sync = i_stream_lz4_sync;
zstream->istream.istream.readable_fd = FALSE;
zstream->istream.istream.blocking = input->blocking;
zstream->istream.istream.seekable = input->seekable;
zstream->chunk_buf = buffer_create_dynamic(default_pool, 1024);
return i_stream_create(&zstream->istream, input,
i_stream_get_fd(input));
}
struct istream *
i_stream_create_attachment_extractor(struct istream *input,
struct istream_attachment_settings *set,
void *context)
{
struct attachment_istream *astream;
i_assert(set->min_size > 0);
i_assert(set->hash_format != NULL);
i_assert(set->open_attachment_ostream != NULL);
i_assert(set->close_attachment_ostream != NULL);
astream = i_new(struct attachment_istream, 1);
astream->part.temp_fd = -1;
astream->set = *set;
astream->context = context;
astream->retry_read = TRUE;
/* make sure the caller doesn't try to double-free this */
set->hash_format = NULL;
astream->istream.max_buffer_size = input->real_stream->max_buffer_size;
astream->istream.read = i_stream_attachment_extractor_read;
astream->istream.iostream.close = i_stream_attachment_extractor_close;
astream->istream.istream.readable_fd = FALSE;
astream->istream.istream.blocking = input->blocking;
astream->istream.istream.seekable = FALSE;
astream->pool = pool_alloconly_create("istream attachment", 1024);
astream->parser = message_parser_init(astream->pool, input, 0,
MESSAGE_PARSER_FLAG_INCLUDE_MULTIPART_BLOCKS |
MESSAGE_PARSER_FLAG_INCLUDE_BOUNDARIES);
return i_stream_create(&astream->istream, input,
i_stream_get_fd(input));
}
struct istream *
i_stream_create_rawlog_from_stream(struct istream *input,
struct ostream *rawlog_output,
enum iostream_rawlog_flags flags)
{
struct rawlog_istream *rstream;
rstream = i_new(struct rawlog_istream, 1);
rstream->istream.max_buffer_size = input->real_stream->max_buffer_size;
rstream->istream.stream_size_passthrough = TRUE;
rstream->riostream.rawlog_output = rawlog_output;
iostream_rawlog_init(&rstream->riostream, flags, TRUE);
rstream->istream.read = i_stream_rawlog_read;
rstream->istream.iostream.close = i_stream_rawlog_close;
rstream->istream.iostream.destroy = i_stream_rawlog_destroy;
rstream->istream.istream.readable_fd = input->readable_fd;
rstream->istream.istream.blocking = input->blocking;
rstream->istream.istream.seekable = input->seekable;
return i_stream_create(&rstream->istream, input,
i_stream_get_fd(input));
}
