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)); }