static int
mdbox_file_metadata_copy(struct dbox_file *file, struct ostream *output)
{
struct dbox_metadata_header meta_hdr;
const char *line;
size_t buf_size;
int ret;
if ((ret = mdbox_file_read_metadata_hdr(file, &meta_hdr)) <= 0)
return ret;
o_stream_nsend(output, &meta_hdr, sizeof(meta_hdr));
buf_size = i_stream_get_max_buffer_size(file->input);
/* use unlimited line length for metadata */
i_stream_set_max_buffer_size(file->input, (size_t)-1);
while ((line = i_stream_read_next_line(file->input)) != NULL) {
if (*line == '\0') {
/* end of metadata */
break;
}
o_stream_nsend_str(output, line);
o_stream_nsend(output, "\n", 1);
}
i_stream_set_max_buffer_size(file->input, buf_size);
if (line == NULL) {
dbox_file_set_corrupted(file, "missing end-of-metadata line");
return 0;
}
o_stream_nsend(output, "\n", 1);
return 1;
}
static void test_istream_dot_error(const char *input_str, bool test_bufsize)
{
struct istream *test_input, *input;
unsigned int i;
size_t outsize, input_len;
uoff_t offset;
int ret;
test_input = test_istream_create(input_str);
input = i_stream_create_dot(test_input, FALSE);
input_len = strlen(input_str);
if (!test_bufsize) {
outsize = 1; i = 0;
i_stream_set_max_buffer_size(input, outsize);
test_istream_set_size(test_input, 1);
while ((ret = i_stream_read(input)) != -1) {
switch (ret) {
case -2:
i_stream_set_max_buffer_size(input, ++outsize);
offset = test_input->v_offset;
/* seek one byte backwards so stream gets
reset */
i_stream_seek(test_input, offset - 1);
/* go back to original position */
test_istream_set_size(test_input, offset);
i_stream_skip(test_input, 1);
/* and finally allow reading one more byte */
test_istream_set_size(test_input, offset + 1);
break;
case 0:
test_istream_set_size(test_input, ++i);
break;
default:
test_assert(ret > 0);
}
}
test_istream_set_size(test_input, input_len);
(void)i_stream_read(test_input);
} else {
test_istream_set_size(test_input, input_len);
for (i = 1; i <= input_len; i++) {
i_stream_set_max_buffer_size(input, i);
(void)i_stream_read(input);
(void)i_stream_read(input);
}
i_stream_set_max_buffer_size(input, i+1);
(void)i_stream_read(input);
}
test_assert(input->stream_errno == EPIPE);
i_stream_unref(&test_input);
i_stream_unref(&input);
}
static void
i_stream_seekable_set_max_buffer_size(struct iostream_private *stream,
size_t max_size)
{
struct seekable_istream *sstream = (struct seekable_istream *)stream;
unsigned int i;
sstream->istream.max_buffer_size = max_size;
if (sstream->fd_input != NULL)
i_stream_set_max_buffer_size(sstream->fd_input, max_size);
for (i = 0; sstream->input[i] != NULL; i++)
i_stream_set_max_buffer_size(sstream->input[i], max_size);
}
static int copy_to_temp_file(struct seekable_istream *sstream)
{
struct istream_private *stream = &sstream->istream;
const char *path;
const unsigned char *buffer;
size_t size;
int fd;
fd = sstream->fd_callback(&path, sstream->context);
if (fd == -1)
return -1;
/* copy our currently read buffer to it */
i_assert(stream->pos <= sstream->buffer_peak);
if (write_full(fd, stream->buffer, sstream->buffer_peak) < 0) {
if (!ENOSPACE(errno))
i_error("istream-seekable: write_full(%s) failed: %m", path);
i_close_fd(&fd);
return -1;
}
sstream->temp_path = i_strdup(path);
sstream->write_peak = sstream->buffer_peak;
sstream->fd = fd;
sstream->fd_input = i_stream_create_fd_autoclose(&fd,
I_MAX(stream->pos, sstream->istream.max_buffer_size));
i_stream_set_name(sstream->fd_input, t_strdup_printf(
"(seekable temp-istream for: %s)", i_stream_get_name(&stream->istream)));
/* read back the data we just had in our buffer */
for (;;) {
buffer = i_stream_get_data(sstream->fd_input, &size);
if (size >= stream->pos)
break;
ssize_t ret;
if ((ret = i_stream_read_memarea(sstream->fd_input)) <= 0) {
i_assert(ret != 0);
i_assert(ret != -2);
i_error("istream-seekable: Couldn't read back "
"in-memory input %s: %s",
i_stream_get_name(&stream->istream),
i_stream_get_error(sstream->fd_input));
i_stream_destroy(&sstream->fd_input);
i_close_fd(&sstream->fd);
return -1;
}
}
/* Set the max buffer size only after we've already read everything
into memory. For example with istream-data it's possible that
more data exists in buffer than max_buffer_size. */
i_stream_set_max_buffer_size(sstream->fd_input,
sstream->istream.max_buffer_size);
stream->buffer = buffer;
i_stream_free_buffer(&sstream->istream);
return 0;
}
static void
i_stream_tee_set_max_buffer_size(struct iostream_private *stream,
size_t max_size)
{
struct tee_child_istream *tstream = (struct tee_child_istream *)stream;
tstream->istream.max_buffer_size = max_size;
i_stream_set_max_buffer_size(tstream->tee->input, max_size);
}
void index_mail_set_read_buffer_size(struct mail *_mail, struct istream *input)
{
struct index_mail *mail = (struct index_mail *)_mail;
unsigned int block_size;
i_stream_set_max_buffer_size(input, MAIL_READ_FULL_BLOCK_SIZE);
block_size = (index_mail_get_access_part(mail) & READ_BODY) != 0 ?
MAIL_READ_FULL_BLOCK_SIZE : MAIL_READ_HDR_BLOCK_SIZE;
i_stream_set_init_buffer_size(input, block_size);
}
static void
i_stream_default_set_max_buffer_size(struct iostream_private *stream,
size_t max_size)
{
struct istream_private *_stream = (struct istream_private *)stream;
_stream->max_buffer_size = max_size;
if (_stream->parent != NULL)
i_stream_set_max_buffer_size(_stream->parent, max_size);
}
static
void test_write_read_v2(void)
{
test_begin("test_write_read_v2");
unsigned char payload[IO_BLOCK_SIZE*10];
const unsigned char *ptr;
size_t pos = 0, siz;
random_fill_weak(payload, IO_BLOCK_SIZE*10);
buffer_t *buf = buffer_create_dynamic(default_pool, sizeof(payload));
struct ostream *os = o_stream_create_buffer(buf);
struct ostream *os_2 = o_stream_create_encrypt(os, "aes-256-gcm-sha256", test_v1_kp.pub, IO_STREAM_ENC_INTEGRITY_AEAD);
o_stream_nsend(os_2, payload, sizeof(payload));
test_assert(o_stream_nfinish(os_2) == 0);
if (os_2->stream_errno != 0)
i_debug("error: %s", o_stream_get_error(os_2));
o_stream_unref(&os);
o_stream_unref(&os_2);
struct istream *is = test_istream_create_data(buf->data, buf->used);
/* test regression where read fails due to incorrect behaviour
when buffer is full before going to decrypt code */
i_stream_set_max_buffer_size(is, 8192);
i_stream_read(is);
struct istream *is_2 = i_stream_create_decrypt(is, test_v1_kp.priv);
size_t offset = 0;
test_istream_set_size(is, 0);
test_istream_set_allow_eof(is, FALSE);
while(i_stream_read_data(is_2, &ptr, &siz, 0)>=0) {
if (offset == buf->used)
test_istream_set_allow_eof(is, TRUE);
else
test_istream_set_size(is, ++offset);
test_assert_idx(pos + siz <= sizeof(payload), pos);
if (pos + siz > sizeof(payload)) break;
test_assert_idx(siz == 0 || memcmp(ptr, payload + pos, siz) == 0, pos);
i_stream_skip(is_2, siz); pos += siz;
}
test_assert(is_2->stream_errno == 0);
if (is_2->stream_errno != 0)
i_debug("error: %s", i_stream_get_error(is_2));
i_stream_unref(&is);
i_stream_unref(&is_2);
buffer_free(&buf);
test_end();
}
static void test_istream_dot_one(const struct dot_test *test,
bool send_last_lf, bool test_bufsize)
{
struct istream *test_input, *input;
const unsigned char *data;
size_t size;
unsigned int i, outsize, input_len, output_len;
string_t *str;
uoff_t offset;
int ret;
test_input = test_istream_create(test->input);
input = i_stream_create_dot(test_input, send_last_lf);
input_len = strlen(test->input);
output_len = strlen(test->output);
if (!send_last_lf &&
(test->input[input_len-1] == '\n' ||
strstr(test->input, "\n.\n") != NULL ||
strstr(test->input, "\n.\r\n") != NULL)) {
if (test->output[output_len-1] == '\n') {
output_len--;
if (output_len > 0 &&
test->output[output_len-1] == '\r')
output_len--;
}
}
str = t_str_new(256);
if (!test_bufsize) {
outsize = 1; i = 0;
i_stream_set_max_buffer_size(input, outsize);
test_istream_set_size(test_input, 1);
while ((ret = i_stream_read(input)) != -1) {
switch (ret) {
case -2:
i_stream_set_max_buffer_size(input, ++outsize);
offset = test_input->v_offset;
/* seek one byte backwards so stream gets
reset */
i_stream_seek(test_input, offset - 1);
/* go back to original position */
test_istream_set_size(test_input, offset);
i_stream_skip(test_input, 1);
/* and finally allow reading one more byte */
test_istream_set_size(test_input, offset + 1);
break;
case 0:
test_istream_set_size(test_input, ++i);
break;
default:
test_assert(ret > 0);
data = i_stream_get_data(input, &size);
str_append_n(str, data, size);
i_stream_skip(input, size);
}
}
test_istream_set_size(test_input, input_len);
(void)i_stream_read(test_input);
} else {
test_istream_set_size(test_input, input_len);
size = 0;
for (i = 1; i < output_len; i++) {
i_stream_set_max_buffer_size(input, i);
test_assert(i_stream_read(input) == 1);
test_assert(i_stream_read(input) == -2);
data = i_stream_get_data(input, &size);
test_assert(memcmp(data, test->output, size) == 0);
}
i_stream_set_max_buffer_size(input, i+2);
if (size < output_len)
test_assert(i_stream_read(input) == 1);
test_assert(i_stream_read(input) == -1);
data = i_stream_get_data(input, &size);
str_append_n(str, data, size);
}
test_assert(str_len(str) == output_len);
test_assert(memcmp(str_data(str), test->output, output_len) == 0);
data = i_stream_get_data(test_input, &size);
test_assert(size == strlen(test->parent_input));
test_assert(memcmp(data, test->parent_input, size) == 0);
i_stream_unref(&test_input);
i_stream_unref(&input);
}
