struct ostream *iostream_temp_create_sized(const char *temp_path_prefix,
enum iostream_temp_flags flags,
const char *name,
size_t max_mem_size)
{
struct temp_ostream *tstream;
struct ostream *output;
tstream = i_new(struct temp_ostream, 1);
tstream->ostream.ostream.blocking = TRUE;
tstream->ostream.sendv = o_stream_temp_sendv;
tstream->ostream.send_istream = o_stream_temp_send_istream;
tstream->ostream.write_at = o_stream_temp_write_at;
tstream->ostream.seek = o_stream_temp_seek;
tstream->ostream.iostream.close = o_stream_temp_close;
tstream->temp_path_prefix = i_strdup(temp_path_prefix);
tstream->flags = flags;
tstream->max_mem_size = max_mem_size;
tstream->buf = buffer_create_dynamic(default_pool, 8192);
tstream->fd = -1;
output = o_stream_create(&tstream->ostream, NULL, -1);
tstream->name = i_strdup(name);
if (name[0] == '\0') {
o_stream_set_name(output, t_strdup_printf(
"(temp iostream in %s)", temp_path_prefix));
} else {
o_stream_set_name(output, t_strdup_printf(
"(temp iostream in %s for %s)", temp_path_prefix, name));
}
return output;
}
struct ostream *o_stream_create_lzma(struct ostream *output, int level)
{
struct lzma_ostream *zstream;
lzma_ret ret;
i_assert(level >= 1 && level <= 9);
zstream = i_new(struct lzma_ostream, 1);
zstream->ostream.sendv = o_stream_lzma_sendv;
zstream->ostream.flush = o_stream_lzma_flush;
zstream->ostream.iostream.close = o_stream_lzma_close;
ret = lzma_easy_encoder(&zstream->strm, level, LZMA_CHECK_CRC64);
switch (ret) {
case LZMA_OK:
break;
case LZMA_MEM_ERROR:
i_fatal_status(FATAL_OUTOFMEM, "lzma: Out of memory");
case LZMA_OPTIONS_ERROR:
i_fatal("lzma: Invalid level");
default:
i_fatal("lzma_easy_encoder() failed with %d", ret);
}
zstream->strm.next_out = zstream->outbuf;
zstream->strm.avail_out = sizeof(zstream->outbuf);
return o_stream_create(&zstream->ostream, output,
o_stream_get_fd(output));
}
struct ostream *openssl_o_stream_create_ssl(struct ssl_iostream *ssl_io)
{
struct ssl_ostream *sstream;
ssl_io->refcount++;
sstream = i_new(struct ssl_ostream, 1);
sstream->ssl_io = ssl_io;
sstream->ostream.max_buffer_size =
ssl_io->plain_output->real_stream->max_buffer_size;
sstream->ostream.iostream.close = o_stream_ssl_close;
sstream->ostream.iostream.destroy = o_stream_ssl_destroy;
sstream->ostream.sendv = o_stream_ssl_sendv;
sstream->ostream.flush = o_stream_ssl_flush;
sstream->ostream.switch_ioloop = o_stream_ssl_switch_ioloop;
sstream->ostream.flush_pending = o_stream_ssl_flush_pending;
sstream->ostream.iostream.set_max_buffer_size =
o_stream_ssl_set_max_buffer_size;
sstream->ostream.callback = ssl_io->plain_output->real_stream->callback;
sstream->ostream.context = ssl_io->plain_output->real_stream->context;
o_stream_set_flush_callback(ssl_io->plain_output,
plain_flush_callback, sstream);
return o_stream_create(&sstream->ostream, NULL,
o_stream_get_fd(ssl_io->plain_output));
}
struct ostream *o_stream_create_bz2(struct ostream *output, int level)
{
struct bzlib_ostream *zstream;
int ret;
i_assert(level >= 1 && level <= 9);
zstream = i_new(struct bzlib_ostream, 1);
zstream->ostream.sendv = o_stream_bzlib_sendv;
zstream->ostream.flush = o_stream_bzlib_flush;
zstream->ostream.iostream.close = o_stream_bzlib_close;
ret = BZ2_bzCompressInit(&zstream->zs, level, 0, 0);
switch (ret) {
case BZ_OK:
break;
case BZ_MEM_ERROR:
i_fatal_status(FATAL_OUTOFMEM,
"bzlib: Out of memory");
case BZ_CONFIG_ERROR:
i_fatal("Wrong bzlib library version (broken compilation)");
case BZ_PARAM_ERROR:
i_fatal("bzlib: Invalid parameters");
default:
i_fatal("BZ2_bzCompressInit() failed with %d", ret);
}
zstream->zs.next_out = zstream->outbuf;
zstream->zs.avail_out = sizeof(zstream->outbuf);
return o_stream_create(&zstream->ostream, output,
o_stream_get_fd(output));
}
struct ostream *o_stream_create_buffer(buffer_t *buf)
{
struct buffer_ostream *bstream;
bstream = i_new(struct buffer_ostream, 1);
bstream->ostream.max_buffer_size = (size_t)-1;
bstream->ostream.seek = o_stream_buffer_seek;
bstream->ostream.sendv = o_stream_buffer_sendv;
bstream->ostream.write_at = o_stream_buffer_write_at;
bstream->buf = buf;
return o_stream_create(&bstream->ostream);
}
struct ostream *
o_stream_create_failure_at_flush(struct ostream *output, const char *error_string)
{
struct failure_at_ostream *fstream;
fstream = i_new(struct failure_at_ostream, 1);
fstream->ostream.flush = o_stream_failure_at_flush;
fstream->ostream.iostream.destroy = o_stream_failure_at_destroy;
fstream->error_string = i_strdup(error_string);
fstream->failed = TRUE;
return o_stream_create(&fstream->ostream, output,
o_stream_get_fd(output));
}
struct ostream *o_stream_create_null(void)
{
struct ostream_private *stream;
struct ostream *output;
stream = i_new(struct ostream_private, 1);
stream->ostream.blocking = TRUE;
stream->sendv = o_stream_null_sendv;
output = o_stream_create(stream, NULL, -1);
o_stream_set_no_error_handling(output, TRUE);
o_stream_set_name(output, "(/dev/null)");
return output;
}
struct ostream *
o_stream_create_hash(struct ostream *output, const struct hash_method *method,
void *hash_context)
{
struct hash_ostream *hstream;
hstream = i_new(struct hash_ostream, 1);
hstream->ostream.sendv = o_stream_hash_sendv;
hstream->method = method;
hstream->hash_context = hash_context;
return o_stream_create(&hstream->ostream, output,
o_stream_get_fd(output));
}
struct ostream *
o_stream_create_cmp(struct ostream *output, struct istream *input)
{
struct cmp_ostream *cstream;
cstream = i_new(struct cmp_ostream, 1);
cstream->ostream.sendv = o_stream_cmp_sendv;
cstream->ostream.iostream.close = o_stream_cmp_close;
cstream->input = input;
cstream->equals = TRUE;
i_stream_ref(input);
return o_stream_create(&cstream->ostream, output,
o_stream_get_fd(output));
}
struct ostream *
o_stream_create_failure_at(struct ostream *output, uoff_t failure_offset,
const char *error_string)
{
struct failure_at_ostream *fstream;
fstream = i_new(struct failure_at_ostream, 1);
fstream->ostream.sendv = o_stream_failure_at_sendv;
fstream->ostream.flush = o_stream_failure_at_flush;
fstream->ostream.iostream.destroy = o_stream_failure_at_destroy;
fstream->failure_offset = failure_offset;
fstream->error_string = i_strdup(error_string);
return o_stream_create(&fstream->ostream, output,
o_stream_get_fd(output));
}
struct ostream *
o_stream_create_ext_filter(struct ostream *output, const char *socket_path,
const char *args)
{
struct mail_filter_ostream *mstream;
mstream = i_new(struct mail_filter_ostream, 1);
mstream->fd = -1;
mstream->ostream.iostream.close = o_stream_mail_filter_close;
mstream->ostream.sendv = o_stream_mail_filter_sendv;
mstream->ostream.flush = o_stream_mail_filter_flush;
(void)filter_connect(mstream, socket_path, args);
return o_stream_create(&mstream->ostream, output, mstream->fd);
}
struct ostream *o_stream_create_buffer(buffer_t *buf)
{
struct buffer_ostream *bstream;
struct ostream *output;
bstream = i_new(struct buffer_ostream, 1);
bstream->ostream.max_buffer_size = (size_t)-1;
bstream->ostream.seek = o_stream_buffer_seek;
bstream->ostream.sendv = o_stream_buffer_sendv;
bstream->ostream.write_at = o_stream_buffer_write_at;
bstream->buf = buf;
output = o_stream_create(&bstream->ostream, NULL, -1);
o_stream_set_name(output, "(buffer)");
return output;
}
struct ostream *
o_stream_create_escaped(struct ostream *output,
ostream_escaped_escape_formatter_t format)
{
struct escaped_ostream *estream;
estream = i_new(struct escaped_ostream, 1);
estream->ostream.sendv = o_stream_escaped_sendv;
estream->ostream.flush = o_stream_escaped_flush;
estream->ostream.max_buffer_size = o_stream_get_max_buffer_size(output);
estream->ostream.iostream.destroy = o_stream_escaped_destroy;
estream->buf = str_new(default_pool, 512);
estream->format = format;
estream->flushed = FALSE;
return o_stream_create(&estream->ostream, output, o_stream_get_fd(output));
}
struct ostream *
http_transfer_chunked_ostream_create(struct ostream *output)
{
struct http_transfer_chunked_ostream *tcstream;
size_t max_size;
tcstream = i_new(struct http_transfer_chunked_ostream, 1);
tcstream->ostream.sendv = http_transfer_chunked_ostream_sendv;
tcstream->ostream.iostream.close = http_transfer_chunked_ostream_close;
if (output->real_stream->max_buffer_size > 0)
max_size = output->real_stream->max_buffer_size;
else
max_size = DEFAULT_MAX_BUFFER_SIZE;
tcstream->ostream.max_buffer_size = _max_chunk_size(max_size);
return o_stream_create(&tcstream->ostream, output,
o_stream_get_fd(output));
}
struct ostream *iostream_temp_create(const char *temp_path_prefix,
enum iostream_temp_flags flags)
{
struct temp_ostream *tstream;
struct ostream *output;
tstream = i_new(struct temp_ostream, 1);
tstream->ostream.sendv = o_stream_temp_sendv;
tstream->ostream.send_istream = o_stream_temp_send_istream;
tstream->ostream.write_at = o_stream_temp_write_at;
tstream->ostream.iostream.close = o_stream_temp_close;
tstream->temp_path_prefix = i_strdup(temp_path_prefix);
tstream->flags = flags;
tstream->buf = buffer_create_dynamic(default_pool, 8192);
tstream->fd = -1;
output = o_stream_create(&tstream->ostream, NULL, -1);
o_stream_set_name(output, "(temp iostream)");
return output;
}
static struct ostream *
o_stream_create_zlib(struct ostream *output, int level, bool gz)
{
const int strategy = Z_DEFAULT_STRATEGY;
struct zlib_ostream *zstream;
int ret;
i_assert(level >= 1 && level <= 9);
zstream = i_new(struct zlib_ostream, 1);
zstream->ostream.sendv = o_stream_zlib_sendv;
zstream->ostream.cork = o_stream_zlib_cork;
zstream->ostream.flush = o_stream_zlib_flush;
zstream->ostream.iostream.close = o_stream_zlib_close;
zstream->output = output;
zstream->crc = 0;
zstream->gz = gz;
if (!gz)
zstream->header_sent = TRUE;
o_stream_ref(output);
o_stream_zlib_init_gz_header(zstream, level, strategy);
ret = deflateInit2(&zstream->zs, level, Z_DEFLATED, -15, 8, strategy);
switch (ret) {
case Z_OK:
break;
case Z_MEM_ERROR:
i_fatal_status(FATAL_OUTOFMEM, "deflateInit(): Out of memory");
case Z_VERSION_ERROR:
i_fatal("Wrong zlib library version (broken compilation)");
case Z_STREAM_ERROR:
i_fatal("Invalid compression level %d", level);
default:
i_fatal("deflateInit() failed with %d", ret);
}
zstream->zs.next_out = zstream->outbuf;
zstream->zs.avail_out = sizeof(zstream->outbuf);
return o_stream_create(&zstream->ostream);
}
