static void test_istream_children(void)
{
struct istream *parent, *child1, *child2;
const unsigned char *data;
size_t size;
test_begin("istream children");
parent = test_istream_create_data("123456789", 9);
test_istream_set_max_buffer_size(parent, 3);
child1 = i_stream_create_limit(parent, (uoff_t)-1);
child2 = i_stream_create_limit(parent, (uoff_t)-1);
/* child1 read beginning */
test_assert(i_stream_read(child1) == 3);
data = i_stream_get_data(child1, &size);
test_assert(size == 3 && memcmp(data, "123", 3) == 0);
i_stream_skip(child1, 3);
/* child1 read middle.. */
test_assert(i_stream_read(child1) == 3);
data = i_stream_get_data(child1, &size);
test_assert(size == 3 && memcmp(data, "456", 3) == 0);
/* child2 read beginning.. */
test_assert(i_stream_read(child2) == 3);
data = i_stream_get_data(child2, &size);
test_assert(size == 3 && memcmp(data, "123", 3) == 0);
/* child1 check middle again.. the parent has been modified,
so it can't return the original data (without some code changes). */
data = i_stream_get_data(child1, &size);
test_assert(size == 0);
i_stream_skip(child1, 3);
/* child1 read end */
test_assert(i_stream_read(child1) == 3);
data = i_stream_get_data(child1, &size);
test_assert(size == 3 && memcmp(data, "789", 3) == 0);
i_stream_skip(child1, 3);
test_assert(i_stream_read(child1) == -1);
/* child2 check beginning again.. */
data = i_stream_get_data(child2, &size);
test_assert(size == 0);
i_stream_skip(child2, 3);
/* child2 read middle */
test_assert(i_stream_read(child2) == 3);
data = i_stream_get_data(child2, &size);
test_assert(size == 3 && memcmp(data, "456", 3) == 0);
i_stream_skip(child2, 3);
i_stream_destroy(&child1);
i_stream_destroy(&child2);
i_stream_destroy(&parent);
test_end();
}
static void cmd_append_catenate_text(struct client_command_context *cmd)
{
struct cmd_append_context *ctx = cmd->context;
if (ctx->literal_size > (uoff_t)-1 - ctx->cat_msg_size &&
!ctx->failed) {
client_send_tagline(cmd,
"NO [TOOBIG] Composed message grows too big.");
ctx->failed = TRUE;
}
/* save the mail */
ctx->cat_msg_size += ctx->literal_size;
if (ctx->literal_size == 0) {
/* zero length literal. RFC doesn't explicitly specify
what should be done with this, so we'll simply
handle it by skipping the empty text part. */
ctx->litinput = i_stream_create_from_data("", 0);
ctx->litinput->eof = TRUE;
} else {
ctx->litinput = i_stream_create_limit(cmd->client->input,
ctx->literal_size);
i_stream_chain_append(ctx->catchain, ctx->litinput);
}
}
static int
mail_crypt_istream_opened(struct mail *_mail, struct istream **stream)
{
struct mail_private *mail = (struct mail_private *)_mail;
struct mail_user *user = _mail->box->storage->user;
struct mail_crypt_user *muser = MAIL_CRYPT_USER_CONTEXT(user);
struct mail_crypt_cache *cache = &muser->cache;
union mail_module_context *mmail = MAIL_CRYPT_MAIL_CONTEXT(mail);
struct istream *input;
if (_mail->uid > 0 && cache->uid == _mail->uid && cache->box == _mail->box) {
/* use the cached stream. when doing partial reads it should
already be seeked into the wanted offset. */
i_stream_unref(stream);
i_stream_seek(cache->input, 0);
*stream = i_stream_create_limit(cache->input, (uoff_t)-1);
return mmail->super.istream_opened(_mail, stream);
}
/* decryption is the outmost stream, so add it before others
(e.g. zlib) */
if (!mail_crypt_is_stream_encrypted(*stream))
return mmail->super.istream_opened(_mail, stream);
input = *stream;
*stream = i_stream_create_decrypt_callback(input,
mail_crypt_istream_get_private_key, _mail);
i_stream_unref(&input);
*stream = mail_crypt_cache_open(muser, _mail, *stream);
return mmail->super.istream_opened(_mail, stream);
}
static struct istream *
mail_crypt_cache_open(struct mail_crypt_user *muser, struct mail *mail,
struct istream *input)
{
struct mail_crypt_cache *cache = &muser->cache;
struct istream *inputs[2];
string_t *temp_prefix = t_str_new(128);
mail_crypt_cache_close(muser);
input->seekable = FALSE;
inputs[0] = input;
inputs[1] = NULL;
mail_user_set_get_temp_prefix(temp_prefix, mail->box->storage->user->set);
input = i_stream_create_seekable_path(inputs,
i_stream_get_max_buffer_size(inputs[0]),
str_c(temp_prefix));
i_stream_unref(&inputs[0]);
if (mail->uid > 0) {
cache->to = timeout_add(MAIL_CRYPT_MAIL_CACHE_EXPIRE_MSECS,
mail_crypt_cache_close, muser);
cache->box = mail->box;
cache->uid = mail->uid;
cache->input = input;
/* index-mail wants the stream to be destroyed at close, so create
a new stream instead of just increasing reference. */
return i_stream_create_limit(cache->input, (uoff_t)-1);
}
return input;
}
static int
stream_copy(struct dbox_file *file, struct ostream *output,
const char *path, uoff_t count)
{
struct istream *input;
off_t bytes;
input = i_stream_create_limit(file->input, count);
bytes = o_stream_send_istream(output, input);
i_stream_unref(&input);
if (bytes < 0) {
mail_storage_set_critical(&file->storage->storage,
"o_stream_send_istream(%s, %s) failed: %m",
file->cur_path, path);
return -1;
}
if ((uoff_t)bytes != count) {
mail_storage_set_critical(&file->storage->storage,
"o_stream_send_istream(%s) copied only %"
PRIuUOFF_T" of %"PRIuUOFF_T" bytes",
path, bytes, count);
return -1;
}
return 0;
}
static int managesieve_parser_read_literal_data(struct managesieve_parser *parser,
const unsigned char *data,
size_t data_size)
{
if (parser->literal_skip_crlf) {
/* skip \r\n or \n, anything else gives an error */
if (data_size == 0)
return FALSE;
if (*data == '\r') {
parser->line_size++;
data++; data_size--;
i_stream_skip(parser->input, 1);
if (data_size == 0)
return FALSE;
}
if (*data != '\n') {
parser->error = "Missing LF after literal size";
return FALSE;
}
parser->line_size++;
data++; data_size--;
i_stream_skip(parser->input, 1);
parser->literal_skip_crlf = FALSE;
i_assert(parser->cur_pos == 0);
}
if ((parser->flags & MANAGESIEVE_PARSE_FLAG_STRING_STREAM) == 0) {
/* now we just wait until we've read enough data */
if (data_size < parser->literal_size) {
return FALSE;
} else {
if ( !uni_utf8_data_is_valid
(data, (size_t)parser->literal_size) ) {
parser->error = "Invalid UTF-8 character in literal string.";
return FALSE;
}
managesieve_parser_save_arg(parser, data,
(size_t)parser->literal_size);
parser->cur_pos = (size_t)parser->literal_size;
return TRUE;
}
} else {
/* we don't read the data; we just create a stream for the literal */
parser->eol = TRUE;
parser->str_stream = i_stream_create_limit
(parser->input, parser->literal_size);
managesieve_parser_save_arg(parser, NULL, 0);
return TRUE;
}
}
struct istream *iostream_temp_finish(struct ostream **output,
size_t max_buffer_size)
{
struct temp_ostream *tstream =
(struct temp_ostream *)(*output)->real_stream;
struct istream *input, *input2;
uoff_t abs_offset, size;
const char *for_path;
int fd;
if (tstream->name[0] == '\0')
for_path = "";
else
for_path = t_strdup_printf(" for %s", tstream->name);
if (tstream->dupstream != NULL && !tstream->dupstream->closed) {
abs_offset = i_stream_get_absolute_offset(tstream->dupstream) -
tstream->dupstream->v_offset +
tstream->dupstream_start_offset;
size = tstream->dupstream_offset -
tstream->dupstream_start_offset;
fd = dup(i_stream_get_fd(tstream->dupstream));
if (fd == -1)
input = i_stream_create_error_str(errno, "dup() failed: %m");
else {
input2 = i_stream_create_fd_autoclose(&fd, max_buffer_size);
i_stream_seek(input2, abs_offset);
input = i_stream_create_limit(input2, size);
i_stream_unref(&input2);
}
i_stream_set_name(input, t_strdup_printf(
"(Temp file in %s%s, from %s)", tstream->temp_path_prefix,
for_path, i_stream_get_name(tstream->dupstream)));
i_stream_unref(&tstream->dupstream);
} else if (tstream->dupstream != NULL) {
/* return the original failed stream. */
input = tstream->dupstream;
} else if (tstream->fd != -1) {
int fd = tstream->fd;
input = i_stream_create_fd_autoclose(&tstream->fd, max_buffer_size);
i_stream_set_name(input, t_strdup_printf(
"(Temp file fd %d in %s%s, %"PRIuUOFF_T" bytes)",
fd, tstream->temp_path_prefix, for_path, tstream->fd_size));
} else {
input = i_stream_create_from_data(tstream->buf->data,
tstream->buf->used);
i_stream_set_name(input, t_strdup_printf(
"(Temp buffer in %s%s, %"PRIuSIZE_T" bytes)",
tstream->temp_path_prefix, for_path, tstream->buf->used));
i_stream_add_destroy_callback(input, iostream_temp_buf_destroyed,
tstream->buf);
tstream->buf = NULL;
}
o_stream_destroy(output);
return input;
}
static int
cmd_setmetadata_entry(struct imap_setmetadata_context *ctx,
const char *entry_name,
const struct imap_arg *entry_value)
{
struct istream *inputs[2];
struct mail_attribute_value value;
string_t *path;
int ret;
switch (entry_value->type) {
case IMAP_ARG_NIL:
case IMAP_ARG_ATOM:
case IMAP_ARG_STRING:
/* we have the value already */
if (ctx->failed)
return 1;
memset(&value, 0, sizeof(value));
value.value = imap_arg_as_nstring(entry_value);
ret = imap_metadata_set(ctx->trans, entry_name, &value);
if (ret < 0) {
/* delay reporting the failure so we'll finish
reading the command input */
ctx->storage_failure = TRUE;
ctx->failed = TRUE;
}
return 1;
case IMAP_ARG_LITERAL_SIZE:
o_stream_nsend(ctx->cmd->client->output, "+ OK\r\n", 6);
o_stream_nflush(ctx->cmd->client->output);
o_stream_uncork(ctx->cmd->client->output);
o_stream_cork(ctx->cmd->client->output);
/* fall through */
case IMAP_ARG_LITERAL_SIZE_NONSYNC:
i_free(ctx->entry_name);
ctx->entry_name = i_strdup(entry_name);
ctx->entry_value_len = imap_arg_as_literal_size(entry_value);
inputs[0] = i_stream_create_limit(ctx->cmd->client->input,
ctx->entry_value_len);
inputs[1] = NULL;
path = t_str_new(128);
mail_user_set_get_temp_prefix(path, ctx->cmd->client->user->set);
ctx->input = i_stream_create_seekable_path(inputs,
METADATA_MAX_INMEM_SIZE, str_c(path));
i_stream_set_name(ctx->input, i_stream_get_name(inputs[0]));
i_stream_unref(&inputs[0]);
return cmd_setmetadata_entry_read_stream(ctx);
case IMAP_ARG_LITERAL:
case IMAP_ARG_LIST:
case IMAP_ARG_EOL:
break;
}
i_unreached();
}
struct istream *i_stream_create_range(struct istream *input,
uoff_t v_offset, uoff_t v_size)
{
uoff_t orig_offset = input->v_offset;
struct istream *ret;
input->v_offset = v_offset;
ret = i_stream_create_limit(input, v_size);
input->v_offset = orig_offset;
return ret;
}
static struct istream *mail_raw_create_stream
(struct mail_user *ruser, int fd, time_t *mtime_r, const char **sender)
{
struct istream *input, *input2, *input_list[2];
const unsigned char *data;
size_t i, size;
int ret, tz;
char *env_sender = NULL;
*mtime_r = (time_t)-1;
fd_set_nonblock(fd, FALSE);
input = i_stream_create_fd(fd, 4096, FALSE);
input->blocking = TRUE;
/* If input begins with a From-line, drop it */
ret = i_stream_read_data(input, &data, &size, 5);
if (ret > 0 && size >= 5 && memcmp(data, "From ", 5) == 0) {
/* skip until the first LF */
i_stream_skip(input, 5);
while ( i_stream_read_data(input, &data, &size, 0) > 0 ) {
for (i = 0; i < size; i++) {
if (data[i] == '\n')
break;
}
if (i != size) {
(void)mbox_from_parse(data, i, mtime_r, &tz, &env_sender);
i_stream_skip(input, i + 1);
break;
}
i_stream_skip(input, size);
}
}
if (env_sender != NULL && sender != NULL) {
*sender = t_strdup(env_sender);
}
i_free(env_sender);
if (input->v_offset == 0) {
input2 = input;
i_stream_ref(input2);
} else {
input2 = i_stream_create_limit(input, (uoff_t)-1);
}
i_stream_unref(&input);
input_list[0] = input2; input_list[1] = NULL;
input = i_stream_create_seekable(input_list, MAIL_MAX_MEMORY_BUFFER,
seekable_fd_callback, (void*)ruser);
i_stream_unref(&input2);
return input;
}
struct tee_istream *tee_i_stream_create(struct istream *input)
{
struct tee_istream *tee;
tee = i_new(struct tee_istream, 1);
if (input->v_offset == 0) {
i_stream_ref(input);
tee->input = input;
} else {
tee->input = i_stream_create_limit(input, (uoff_t)-1);
}
return tee;
}
static int
raw_mail_get_stream(struct mail *_mail, struct message_size *hdr_size,
struct message_size *body_size, struct istream **stream_r)
{
struct index_mail *mail = (struct index_mail *)_mail;
if (mail->data.stream == NULL) {
/* we can't just reference mbox->input, because
index_mail_close() expects to be able to free the stream */
mail->data.stream =
i_stream_create_limit(_mail->box->input, (uoff_t)-1);
}
return index_mail_init_stream(mail, hdr_size, body_size, stream_r);
}
int mbox_move(struct mbox_sync_context *sync_ctx,
uoff_t dest, uoff_t source, uoff_t size)
{
struct istream *input;
struct ostream *output;
off_t ret;
i_assert(size < OFF_T_MAX);
if (size == 0 || source == dest)
return 0;
i_stream_sync(sync_ctx->input);
output = o_stream_create_fd_file(sync_ctx->write_fd, (uoff_t)-1, FALSE);
i_stream_seek(sync_ctx->file_input, source);
if (o_stream_seek(output, dest) < 0) {
mbox_set_syscall_error(sync_ctx->mbox,
"o_stream_seek()");
o_stream_unref(&output);
return -1;
}
input = i_stream_create_limit(sync_ctx->file_input, size);
ret = o_stream_send_istream(output, input);
i_stream_unref(&input);
if (ret == (off_t)size)
ret = 0;
else if (ret >= 0) {
mbox_sync_set_critical(sync_ctx,
"mbox_move(%"PRIuUOFF_T", %"PRIuUOFF_T", %"PRIuUOFF_T
") moved only %"PRIuUOFF_T" bytes",
dest, source, size, (uoff_t)ret);
ret = -1;
} else if (ret < 0) {
errno = output->stream_errno;
mbox_set_syscall_error(sync_ctx->mbox,
"o_stream_send_istream()");
}
mbox_sync_file_updated(sync_ctx, FALSE);
o_stream_destroy(&output);
return (int)ret;
}
static int fetch_stream(struct imap_fetch_context *ctx,
const struct message_size *size)
{
struct istream *input;
if (size->physical_size == size->virtual_size &&
ctx->cur_mail->has_no_nuls) {
/* no need to kludge with CRs, we can use sendfile() */
input = i_stream_create_limit(ctx->cur_input, ctx->cur_size);
i_stream_unref(&ctx->cur_input);
ctx->cur_input = input;
ctx->cont_handler = fetch_stream_send_direct;
} else {
ctx->cont_handler = fetch_stream_send;
}
return ctx->cont_handler(ctx);
}
static int zlib_istream_opened(struct mail *_mail, struct istream **stream)
{
struct zlib_user *zuser = ZLIB_USER_CONTEXT(_mail->box->storage->user);
struct zlib_mail_cache *cache = &zuser->cache;
struct mail_private *mail = (struct mail_private *)_mail;
union mail_module_context *zmail = ZLIB_MAIL_CONTEXT(mail);
struct istream *input;
const struct compression_handler *handler;
/* don't uncompress input when we are reading a mail that we're just
in the middle of saving, and we didn't do the compression ourself.
in such situation we're probably checking if the user-given input
looks compressed */
if (_mail->saving && zuser->save_handler == NULL)
return zmail->super.istream_opened(_mail, stream);
if (cache->uid == _mail->uid && cache->box == _mail->box) {
/* use the cached stream. when doing partial reads it should
already be seeked into the wanted offset. */
i_stream_unref(stream);
i_stream_seek(cache->input, 0);
*stream = i_stream_create_limit(cache->input, (uoff_t)-1);
return zmail->super.istream_opened(_mail, stream);
}
handler = compression_detect_handler(*stream);
if (handler != NULL) {
if (handler->create_istream == NULL) {
mail_storage_set_critical(_mail->box->storage,
"zlib plugin: Detected %s compression "
"but support not compiled in", handler->ext);
return -1;
}
input = *stream;
*stream = handler->create_istream(input, TRUE);
i_stream_unref(&input);
*stream = zlib_mail_cache_open(zuser, _mail, *stream);
}
return zmail->super.istream_opened(_mail, stream);
}
static int o_stream_temp_dup_cancel(struct temp_ostream *tstream)
{
struct istream *input;
uoff_t size = tstream->dupstream_offset -
tstream->dupstream_start_offset;
off_t ret;
i_stream_seek(tstream->dupstream, tstream->dupstream_start_offset);
input = i_stream_create_limit(tstream->dupstream, size);
do {
ret = io_stream_copy(&tstream->ostream.ostream, input);
} while (input->v_offset < tstream->dupstream_offset && ret > 0);
if (ret < 0 && tstream->ostream.ostream.stream_errno == 0) {
i_assert(input->stream_errno != 0);
tstream->ostream.ostream.stream_errno = input->stream_errno;
}
i_stream_destroy(&input);
i_stream_unref(&tstream->dupstream);
return ret < 0 ? -1 : 0;
}
static int
get_mail_stream(struct dbox_mail *mail, uoff_t offset,
struct istream **stream_r)
{
struct mail_private *pmail = &mail->imail.mail;
struct dbox_file *file = mail->open_file;
int ret;
if ((ret = dbox_file_seek(file, offset)) <= 0) {
*stream_r = NULL;
return ret;
}
*stream_r = i_stream_create_limit(file->input, file->cur_physical_size);
if (pmail->v.istream_opened != NULL) {
if (pmail->v.istream_opened(&pmail->mail, stream_r) < 0)
return -1;
}
if (file->storage->attachment_dir == NULL)
return 1;
else
return dbox_attachment_file_get_stream(file, stream_r);
}
static void test_ostream_file_send_istream_sendfile(void)
{
struct istream *input, *input2;
struct ostream *output;
char buf[10];
int fd, sock_fd[2];
test_begin("ostream file send istream sendfile()");
/* temp file istream */
fd = open(".temp.istream", O_RDWR | O_CREAT | O_TRUNC, 0600);
if (fd == -1)
i_fatal("creat(.temp.istream) failed: %m");
test_assert(write(fd, "abcdefghij", 10) == 10);
test_assert(lseek(fd, 0, SEEK_SET) == 0);
input = i_stream_create_fd_autoclose(&fd, 1024);
/* temp socket ostream */
i_assert(socketpair(AF_UNIX, SOCK_STREAM, 0, sock_fd) == 0);
output = o_stream_create_fd_autoclose(sock_fd, 0);
/* test that sendfile() works */
i_stream_seek(input, 3);
input2 = i_stream_create_limit(input, 4);
test_assert(o_stream_send_istream(output, input2) == OSTREAM_SEND_ISTREAM_RESULT_FINISHED);
test_assert(output->offset == 4);
test_assert(read(sock_fd[1], buf, sizeof(buf)) == 4 &&
memcmp(buf, "defg", 4) == 0);
i_stream_unref(&input2);
i_stream_unref(&input);
o_stream_destroy(&output);
i_close_fd(&sock_fd[1]);
i_unlink(".temp.istream");
test_end();
}
static int get_hdr_sha1(struct mail *mail, unsigned char sha1[SHA1_RESULTLEN])
{
struct message_size hdr_size;
struct istream *input, *input2;
const unsigned char *data;
size_t size;
struct sha1_ctxt sha1_ctx;
if (mail_get_hdr_stream(mail, &hdr_size, &input) < 0) {
i_error("pop3_migration: Failed to get header for msg %u: %s",
mail->seq, mailbox_get_last_error(mail->box, NULL));
return -1;
}
input2 = i_stream_create_limit(input, hdr_size.physical_size);
/* hide headers that might change or be different in IMAP vs. POP3 */
input = i_stream_create_header_filter(input2,
HEADER_FILTER_EXCLUDE | HEADER_FILTER_NO_CR,
hdr_hash_skip_headers,
N_ELEMENTS(hdr_hash_skip_headers),
*null_header_filter_callback, (void *)NULL);
i_stream_unref(&input2);
sha1_init(&sha1_ctx);
while (i_stream_read_data(input, &data, &size, 0) > 0) {
sha1_loop(&sha1_ctx, data, size);
i_stream_skip(input, size);
}
if (input->stream_errno != 0) {
i_error("pop3_migration: Failed to read header for msg %u: %m",
mail->seq);
i_stream_unref(&input);
return -1;
}
sha1_result(&sha1_ctx, sha1);
i_stream_unref(&input);
return 0;
}
static struct istream *
zlib_mail_cache_open(struct zlib_user *zuser, struct mail *mail,
struct istream *input)
{
struct zlib_mail_cache *cache = &zuser->cache;
struct istream *inputs[2];
string_t *temp_prefix = t_str_new(128);
zlib_mail_cache_close(zuser);
/* zlib istream is seekable, but very slow. create a seekable istream
which we can use to quickly seek around in the stream that's been
read so far. usually the partial IMAP FETCHes continue from where
the previous left off, so this isn't strictly necessary, but with
the way lib-imap-storage's CRLF-cache works it has to seek backwards
somewhat, which causes a zlib stream reset. And the CRLF-cache isn't
easy to fix.. */
input->seekable = FALSE;
inputs[0] = input;
inputs[1] = NULL;
mail_user_set_get_temp_prefix(temp_prefix, mail->box->storage->user->set);
input = i_stream_create_seekable_path(inputs,
i_stream_get_max_buffer_size(inputs[0]),
str_c(temp_prefix));
i_stream_unref(&inputs[0]);
cache->to = timeout_add(ZLIB_MAIL_CACHE_EXPIRE_MSECS,
zlib_mail_cache_close, zuser);
cache->box = mail->box;
cache->uid = mail->uid;
cache->input = input;
/* index-mail wants the stream to be destroyed at close, so create
a new stream instead of just increasing reference. */
return i_stream_create_limit(cache->input, (uoff_t)-1);
}
static bool o_stream_temp_dup_cancel(struct temp_ostream *tstream,
enum ostream_send_istream_result *res_r)
{
struct istream *input;
uoff_t size = tstream->dupstream_offset -
tstream->dupstream_start_offset;
bool ret = TRUE; /* use res_r to return error */
i_stream_seek(tstream->dupstream, tstream->dupstream_start_offset);
tstream->ostream.ostream.offset = 0;
input = i_stream_create_limit(tstream->dupstream, size);
i_stream_unref(&tstream->dupstream);
*res_r = io_stream_copy(&tstream->ostream.ostream, input);
switch (*res_r) {
case OSTREAM_SEND_ISTREAM_RESULT_FINISHED:
/* everything copied */
ret = FALSE;
break;
case OSTREAM_SEND_ISTREAM_RESULT_WAIT_INPUT:
case OSTREAM_SEND_ISTREAM_RESULT_WAIT_OUTPUT:
i_unreached();
case OSTREAM_SEND_ISTREAM_RESULT_ERROR_INPUT:
tstream->ostream.ostream.stream_errno = input->stream_errno;
io_stream_set_error(&tstream->ostream.iostream,
"iostream-temp: read(%s) failed: %s",
i_stream_get_name(input),
i_stream_get_error(input));
break;
case OSTREAM_SEND_ISTREAM_RESULT_ERROR_OUTPUT:
break;
}
i_stream_destroy(&input);
return ret;
}
static int
dbox_file_fix_write_stream(struct dbox_file *file, uoff_t start_offset,
const char *temp_path, struct ostream *output)
{
struct dbox_message_header msg_hdr;
uoff_t offset, msg_size, hdr_offset, body_offset;
bool pre, write_header, have_guid;
struct message_size body;
struct istream *body_input;
uint8_t guid_128[MAIL_GUID_128_SIZE];
int ret;
i_stream_seek(file->input, 0);
if (start_offset > 0) {
/* copy the valid data */
if (stream_copy(file, output, temp_path, start_offset) < 0)
return -1;
} else {
/* the file header is broken. recreate it */
if (dbox_file_header_write(file, output) < 0) {
dbox_file_set_syscall_error(file, "write()");
return -1;
}
}
while ((ret = dbox_file_find_next_magic(file, &offset, &pre)) > 0) {
msg_size = offset - file->input->v_offset;
if (msg_size < 256 && pre) {
/* probably some garbage or some broken headers.
we most likely don't miss anything by skipping
over this data. */
i_stream_skip(file->input, msg_size);
hdr_offset = file->input->v_offset;
ret = dbox_file_read_mail_header(file, &msg_size);
if (ret <= 0) {
if (ret < 0)
return -1;
dbox_file_skip_broken_header(file);
body_offset = file->input->v_offset;
msg_size = (uoff_t)-1;
} else {
i_stream_skip(file->input,
file->msg_header_size);
body_offset = file->input->v_offset;
i_stream_skip(file->input, msg_size);
}
ret = dbox_file_find_next_magic(file, &offset, &pre);
if (ret <= 0)
break;
if (!pre && msg_size == offset - body_offset) {
/* msg header ok, copy it */
i_stream_seek(file->input, hdr_offset);
if (stream_copy(file, output, temp_path,
file->msg_header_size) < 0)
return -1;
write_header = FALSE;
} else {
/* msg header is broken. write our own. */
i_stream_seek(file->input, body_offset);
if (msg_size != (uoff_t)-1) {
/* previous magic find might have
skipped too much. seek back and
make sure */
ret = dbox_file_find_next_magic(file, &offset, &pre);
if (ret <= 0)
break;
}
write_header = TRUE;
msg_size = offset - body_offset;
}
} else {
/* treat this data as a separate message. */
write_header = TRUE;
body_offset = file->input->v_offset;
}
/* write msg header */
if (write_header) {
dbox_msg_header_fill(&msg_hdr, msg_size);
(void)o_stream_send(output, &msg_hdr, sizeof(msg_hdr));
}
/* write msg body */
i_assert(file->input->v_offset == body_offset);
if (stream_copy(file, output, temp_path, msg_size) < 0)
return -1;
i_assert(file->input->v_offset == offset);
/* get message body size */
i_stream_seek(file->input, body_offset);
body_input = i_stream_create_limit(file->input, msg_size);
ret = message_get_body_size(body_input, &body, NULL);
i_stream_unref(&body_input);
if (ret < 0) {
errno = output->stream_errno;
mail_storage_set_critical(&file->storage->storage,
"read(%s) failed: %m", file->cur_path);
return -1;
}
/* write msg metadata. */
i_assert(file->input->v_offset == offset);
ret = dbox_file_metadata_skip_header(file);
if (ret < 0)
return -1;
o_stream_send_str(output, DBOX_MAGIC_POST);
if (ret == 0)
have_guid = FALSE;
else
dbox_file_copy_metadata(file, output, &have_guid);
if (!have_guid) {
mail_generate_guid_128(guid_128);
o_stream_send_str(output,
t_strdup_printf("%c%s\n", DBOX_METADATA_GUID,
binary_to_hex(guid_128, sizeof(guid_128))));
}
o_stream_send_str(output,
t_strdup_printf("%c%llx\n", DBOX_METADATA_VIRTUAL_SIZE,
(unsigned long long)body.virtual_size));
o_stream_send_str(output, "\n");
if (output->stream_errno != 0) {
errno = output->stream_errno;
mail_storage_set_critical(&file->storage->storage,
"write(%s) failed: %m", temp_path);
return -1;
}
}
return ret;
}
static int astream_decode_base64(struct attachment_istream *astream)
{
struct attachment_istream_part *part = &astream->part;
buffer_t *extra_buf = NULL;
struct istream *input, *base64_input;
struct ostream *output;
const unsigned char *data;
size_t size;
ssize_t ret;
buffer_t *buf;
int outfd;
bool failed = FALSE;
if (part->base64_bytes < astream->set.min_size ||
part->temp_output->offset > part->base64_bytes +
BASE64_ATTACHMENT_MAX_EXTRA_BYTES) {
/* only a small part of the MIME part is base64-encoded. */
return -1;
}
if (part->base64_line_blocks == 0) {
/* only one line of base64 */
part->base64_line_blocks = part->cur_base64_blocks;
i_assert(part->base64_line_blocks > 0);
}
/* decode base64 data and write it to another temp file */
outfd = astream->set.open_temp_fd(astream->context);
if (outfd == -1)
return -1;
buf = buffer_create_dynamic(default_pool, 1024);
input = i_stream_create_fd(part->temp_fd, IO_BLOCK_SIZE);
base64_input = i_stream_create_limit(input, part->base64_bytes);
output = o_stream_create_fd_file(outfd, 0, FALSE);
o_stream_cork(output);
hash_format_reset(astream->set.hash_format);
size_t bytes_needed = 1;
while ((ret = i_stream_read_bytes(base64_input, &data, &size,
bytes_needed)) > 0) {
buffer_set_used_size(buf, 0);
if (base64_decode(data, size, &size, buf) < 0) {
i_error("istream-attachment: BUG: "
"Attachment base64 data unexpectedly broke");
failed = TRUE;
break;
}
i_stream_skip(base64_input, size);
o_stream_nsend(output, buf->data, buf->used);
hash_format_loop(astream->set.hash_format,
buf->data, buf->used);
bytes_needed = i_stream_get_data_size(base64_input) + 1;
}
if (ret != -1) {
i_assert(failed);
} else if (base64_input->stream_errno != 0) {
i_error("istream-attachment: read(%s) failed: %s",
i_stream_get_name(base64_input),
i_stream_get_error(base64_input));
failed = TRUE;
}
if (o_stream_nfinish(output) < 0) {
i_error("istream-attachment: write(%s) failed: %s",
o_stream_get_name(output), o_stream_get_error(output));
failed = TRUE;
}
buffer_free(&buf);
i_stream_unref(&base64_input);
o_stream_unref(&output);
if (input->v_offset != part->temp_output->offset && !failed) {
/* write the rest of the data to the message stream */
extra_buf = buffer_create_dynamic(default_pool, 1024);
while ((ret = i_stream_read_more(input, &data, &size)) > 0) {
buffer_append(extra_buf, data, size);
i_stream_skip(input, size);
}
i_assert(ret == -1);
if (input->stream_errno != 0) {
i_error("istream-attachment: read(%s) failed: %s",
i_stream_get_name(input),
i_stream_get_error(input));
failed = TRUE;
}
}
i_stream_unref(&input);
if (failed) {
i_close_fd(&outfd);
return -1;
}
/* successfully wrote it. switch to using it. */
o_stream_destroy(&part->temp_output);
i_close_fd(&part->temp_fd);
part->temp_fd = outfd;
if (extra_buf != NULL) {
stream_add_data(astream, extra_buf->data, extra_buf->used);
buffer_free(&extra_buf);
}
return 0;
}
static int mbox_mail_seek(struct index_mail *mail)
{
struct mbox_transaction_context *t =
(struct mbox_transaction_context *)mail->mail.mail.transaction;
struct mail *_mail = &mail->mail.mail;
struct mbox_mailbox *mbox = (struct mbox_mailbox *)_mail->box;
enum mbox_sync_flags sync_flags = 0;
int ret, try;
bool deleted;
if (_mail->expunged || mbox->syncing)
return -1;
if (_mail->lookup_abort != MAIL_LOOKUP_ABORT_NEVER) {
mail_set_aborted(_mail);
return -1;
}
if (mbox->mbox_stream != NULL &&
istream_raw_mbox_is_corrupted(mbox->mbox_stream)) {
/* clear the corruption by forcing a full resync */
sync_flags |= MBOX_SYNC_UNDIRTY | MBOX_SYNC_FORCE_SYNC;
}
for (try = 0; try < 2; try++) {
if ((sync_flags & MBOX_SYNC_FORCE_SYNC) != 0) {
/* dirty offsets are broken. make sure we can sync. */
mbox_prepare_resync(_mail);
}
if (mbox->mbox_lock_type == F_UNLCK) {
i_assert(t->read_lock_id == 0);
sync_flags |= MBOX_SYNC_LOCK_READING;
if (mbox_sync(mbox, sync_flags) < 0)
return -1;
t->read_lock_id = mbox_get_cur_lock_id(mbox);
i_assert(t->read_lock_id != 0);
/* refresh index file after mbox has been locked to
make sure we get only up-to-date mbox offsets. */
if (mail_index_refresh(mbox->box.index) < 0) {
mailbox_set_index_error(&mbox->box);
return -1;
}
i_assert(mbox->mbox_lock_type != F_UNLCK);
} else if (t->read_lock_id == 0) {
/* file is already locked by another transaction, but
we must keep it locked for the entire transaction,
so increase the lock counter. */
if (mbox_lock(mbox, mbox->mbox_lock_type,
&t->read_lock_id) < 0)
i_unreached();
}
if (mbox_file_open_stream(mbox) < 0)
return -1;
ret = mbox_file_seek(mbox, _mail->transaction->view,
_mail->seq, &deleted);
if (ret > 0) {
/* success */
break;
}
if (ret < 0) {
if (deleted)
mail_set_expunged(_mail);
return -1;
}
/* we'll need to re-sync it completely */
sync_flags |= MBOX_SYNC_UNDIRTY | MBOX_SYNC_FORCE_SYNC;
}
if (ret == 0) {
mail_storage_set_critical(&mbox->storage->storage,
"Losing sync for mail uid=%u in mbox file %s",
_mail->uid, mailbox_get_path(&mbox->box));
}
return 0;
}
static int mbox_mail_get_received_date(struct mail *_mail, time_t *date_r)
{
struct index_mail *mail = (struct index_mail *)_mail;
struct index_mail_data *data = &mail->data;
struct mbox_mailbox *mbox = (struct mbox_mailbox *)_mail->box;
if (index_mail_get_received_date(_mail, date_r) == 0)
return 0;
if (mbox_mail_seek(mail) < 0)
return -1;
data->received_date =
istream_raw_mbox_get_received_time(mbox->mbox_stream);
if (data->received_date == (time_t)-1) {
/* it's broken and conflicts with our "not found"
return value. change it. */
data->received_date = 0;
}
*date_r = data->received_date;
return 0;
}
static int mbox_mail_get_save_date(struct mail *_mail, time_t *date_r)
{
struct index_mail *mail = (struct index_mail *)_mail;
struct index_mail_data *data = &mail->data;
if (index_mail_get_save_date(_mail, date_r) == 0)
return 0;
/* no way to know this. save the current time into cache and use
that from now on. this works only as long as the index files
are permanent */
data->save_date = ioloop_time;
*date_r = data->save_date;
return 0;
}
static int
mbox_mail_get_md5_header(struct index_mail *mail, const char **value_r)
{
struct mail *_mail = &mail->mail.mail;
static uint8_t empty_md5[16] =
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
struct mbox_mailbox *mbox = (struct mbox_mailbox *)_mail->box;
const void *ext_data;
if (mail->data.guid != NULL) {
*value_r = mail->data.guid;
return 1;
}
mail_index_lookup_ext(_mail->transaction->view, _mail->seq,
mbox->md5hdr_ext_idx, &ext_data, NULL);
if (ext_data != NULL && memcmp(ext_data, empty_md5, 16) != 0) {
mail->data.guid = p_strdup(mail->mail.data_pool,
binary_to_hex(ext_data, 16));
*value_r = mail->data.guid;
return 1;
} else if (mail_index_is_expunged(_mail->transaction->view, _mail->seq)) {
mail_set_expunged(_mail);
return -1;
} else {
return 0;
}
}
static int
mbox_mail_get_special(struct mail *_mail, enum mail_fetch_field field,
const char **value_r)
{
struct index_mail *mail = (struct index_mail *)_mail;
struct mbox_mailbox *mbox = (struct mbox_mailbox *)_mail->box;
uoff_t offset;
bool move_offset;
int ret;
switch (field) {
case MAIL_FETCH_FROM_ENVELOPE:
if (mbox_mail_seek(mail) < 0)
return -1;
*value_r = istream_raw_mbox_get_sender(mbox->mbox_stream);
return 0;
case MAIL_FETCH_GUID:
case MAIL_FETCH_HEADER_MD5:
if ((ret = mbox_mail_get_md5_header(mail, value_r)) != 0)
return ret < 0 ? -1 : 0;
/* i guess in theory the empty_md5 is valid and can happen,
but it's almost guaranteed that it means the MD5 sum is
missing. recalculate it. */
if (mbox->mbox_lock_type == F_UNLCK ||
mbox->mbox_stream == NULL) {
offset = 0;
move_offset = FALSE;
} else {
offset = istream_raw_mbox_get_start_offset(mbox->mbox_stream);
move_offset = TRUE;
}
mbox->mbox_save_md5 = TRUE;
if (mbox_sync(mbox, MBOX_SYNC_FORCE_SYNC |
MBOX_SYNC_READONLY) < 0)
return -1;
if (move_offset) {
if (istream_raw_mbox_seek(mbox->mbox_stream,
offset) < 0) {
i_error("mbox %s sync lost during MD5 syncing",
_mail->box->name);
return -1;
}
}
if ((ret = mbox_mail_get_md5_header(mail, value_r)) == 0) {
i_error("mbox %s resyncing didn't save header MD5 values",
_mail->box->name);
return -1;
}
return ret < 0 ? -1 : 0;
default:
break;
}
return index_mail_get_special(_mail, field, value_r);
}
static int
mbox_mail_get_next_offset(struct index_mail *mail, uoff_t *next_offset_r)
{
struct mbox_mailbox *mbox = (struct mbox_mailbox *)mail->mail.mail.box;
struct mail_index_view *view;
const struct mail_index_header *hdr;
uint32_t seq;
int trailer_size;
int ret = 1;
*next_offset_r = (uoff_t)-1;
hdr = mail_index_get_header(mail->mail.mail.transaction->view);
if (mail->mail.mail.seq > hdr->messages_count) {
/* we're appending a new message */
return 0;
}
/* We can't really trust trans_view. The next message may already be
expunged from it. Also hdr.messages_count may be incorrect there.
So refresh the index to get the latest changes and get the next
message's offset using a new view. */
i_assert(mbox->mbox_lock_type != F_UNLCK);
if (mbox_sync_header_refresh(mbox) < 0)
return -1;
view = mail_index_view_open(mail->mail.mail.box->index);
hdr = mail_index_get_header(view);
if (!mail_index_lookup_seq(view, mail->mail.mail.uid, &seq))
i_panic("Message unexpectedly expunged from index");
if (seq < hdr->messages_count) {
if (mbox_file_lookup_offset(mbox, view, seq + 1,
next_offset_r) <= 0)
ret = -1;
} else if (mail->mail.mail.box->input != NULL) {
/* opened the mailbox as input stream. we can't trust the
sync_size, since it's wrong with compressed mailboxes */
ret = 0;
} else {
/* last message, use the synced mbox size */
trailer_size =
mbox->storage->storage.set->mail_save_crlf ? 2 : 1;
*next_offset_r = mbox->mbox_hdr.sync_size - trailer_size;
}
mail_index_view_close(&view);
return ret;
}
static int mbox_mail_get_physical_size(struct mail *_mail, uoff_t *size_r)
{
struct index_mail *mail = (struct index_mail *)_mail;
struct index_mail_data *data = &mail->data;
struct mbox_mailbox *mbox = (struct mbox_mailbox *)_mail->box;
struct istream *input;
struct message_size hdr_size;
uoff_t old_offset, body_offset, body_size, next_offset;
if (index_mail_get_physical_size(_mail, size_r) == 0)
return 0;
/* we want to return the header size as seen by mail_get_stream(). */
old_offset = data->stream == NULL ? 0 : data->stream->v_offset;
if (mail_get_stream(_mail, &hdr_size, NULL, &input) < 0)
return -1;
/* our header size varies, so don't do any caching */
if (istream_raw_mbox_get_body_offset(mbox->mbox_stream, &body_offset) < 0) {
mail_storage_set_critical(_mail->box->storage,
"mbox %s: Couldn't get body offset for uid=%u",
mailbox_get_path(&mbox->box), mail->mail.mail.uid);
return -1;
}
/* use the next message's offset to avoid reading through the entire
message body to find out its size */
if (mbox_mail_get_next_offset(mail, &next_offset) > 0)
body_size = next_offset - body_offset;
else
body_size = (uoff_t)-1;
/* verify that the calculated body size is correct */
if (istream_raw_mbox_get_body_size(mbox->mbox_stream,
body_size, &body_size) < 0) {
mail_storage_set_critical(_mail->box->storage,
"mbox %s: Couldn't get body size for uid=%u",
mailbox_get_path(&mbox->box), mail->mail.mail.uid);
return -1;
}
data->physical_size = hdr_size.physical_size + body_size;
*size_r = data->physical_size;
i_stream_seek(input, old_offset);
return 0;
}
static int mbox_mail_init_stream(struct index_mail *mail)
{
struct mbox_mailbox *mbox = (struct mbox_mailbox *)mail->mail.mail.box;
struct istream *raw_stream;
uoff_t hdr_offset, next_offset;
int ret;
if (mbox_mail_seek(mail) < 0)
return -1;
ret = mbox_mail_get_next_offset(mail, &next_offset);
if (ret < 0) {
if (mbox_mail_seek(mail) < 0)
return -1;
ret = mbox_mail_get_next_offset(mail, &next_offset);
if (ret < 0) {
i_warning("mbox %s: Can't find next message offset "
"for uid=%u", mailbox_get_path(&mbox->box),
mail->mail.mail.uid);
}
}
raw_stream = mbox->mbox_stream;
if (istream_raw_mbox_get_header_offset(raw_stream, &hdr_offset) < 0) {
mail_storage_set_critical(mbox->box.storage,
"mbox %s: Couldn't get header offset for uid=%u",
mailbox_get_path(&mbox->box), mail->mail.mail.uid);
return -1;
}
i_stream_seek(raw_stream, hdr_offset);
if (next_offset != (uoff_t)-1)
istream_raw_mbox_set_next_offset(raw_stream, next_offset);
raw_stream = i_stream_create_limit(raw_stream, (uoff_t)-1);
mail->data.stream =
i_stream_create_header_filter(raw_stream,
HEADER_FILTER_EXCLUDE | HEADER_FILTER_NO_CR,
mbox_hide_headers, mbox_hide_headers_count,
*null_header_filter_callback, (void *)NULL);
i_stream_unref(&raw_stream);
return 0;
}
static int mbox_mail_get_stream(struct mail *_mail, bool get_body ATTR_UNUSED,
struct message_size *hdr_size,
struct message_size *body_size,
struct istream **stream_r)
{
struct index_mail *mail = (struct index_mail *)_mail;
if (mail->data.stream == NULL) {
if (mbox_mail_init_stream(mail) < 0)
return -1;
}
return index_mail_init_stream(mail, hdr_size, body_size, stream_r);
}
static void mbox_mail_set_seq(struct mail *_mail, uint32_t seq, bool saving)
{
struct index_mail *mail = (struct index_mail *)_mail;
index_mail_set_seq(_mail, seq, saving);
mail->data.dont_cache_fetch_fields |= MAIL_FETCH_PHYSICAL_SIZE;
}
static bool mbox_mail_set_uid(struct mail *_mail, uint32_t uid)
{
struct index_mail *mail = (struct index_mail *)_mail;
bool ret;
ret = index_mail_set_uid(_mail, uid);
mail->data.dont_cache_fetch_fields |= MAIL_FETCH_PHYSICAL_SIZE;
return ret;
}
struct mail_vfuncs mbox_mail_vfuncs = {
index_mail_close,
index_mail_free,
mbox_mail_set_seq,
mbox_mail_set_uid,
index_mail_set_uid_cache_updates,
index_mail_prefetch,
index_mail_precache,
index_mail_add_temp_wanted_fields,
index_mail_get_flags,
index_mail_get_keywords,
index_mail_get_keyword_indexes,
index_mail_get_modseq,
index_mail_get_pvt_modseq,
index_mail_get_parts,
index_mail_get_date,
mbox_mail_get_received_date,
mbox_mail_get_save_date,
index_mail_get_virtual_size,
mbox_mail_get_physical_size,
index_mail_get_first_header,
index_mail_get_headers,
index_mail_get_header_stream,
mbox_mail_get_stream,
index_mail_get_binary_stream,
mbox_mail_get_special,
index_mail_get_real_mail,
index_mail_update_flags,
index_mail_update_keywords,
index_mail_update_modseq,
index_mail_update_pvt_modseq,
NULL,
index_mail_expunge,
index_mail_set_cache_corrupted,
index_mail_opened
};
static void test_ostream_file_send_istream_file(void)
{
struct istream *input, *input2;
struct ostream *output;
char buf[10];
int fd;
test_begin("ostream file send istream file");
/* temp file istream */
fd = open(".temp.istream", O_RDWR | O_CREAT | O_TRUNC, 0600);
if (fd == -1)
i_fatal("creat(.temp.istream) failed: %m");
test_assert(write(fd, "1234567890", 10) == 10);
test_assert(lseek(fd, 0, SEEK_SET) == 0);
input = i_stream_create_fd_autoclose(&fd, 1024);
/* temp file ostream */
fd = open(".temp.ostream", O_RDWR | O_CREAT | O_TRUNC, 0600);
if (fd == -1)
i_fatal("creat(.temp.ostream) failed: %m");
output = o_stream_create_fd(fd, 0);
/* test that writing works between two files */
i_stream_seek(input, 3);
input2 = i_stream_create_limit(input, 4);
test_assert(o_stream_send_istream(output, input2) == OSTREAM_SEND_ISTREAM_RESULT_FINISHED);
test_assert(output->offset == 4);
test_assert(pread(fd, buf, sizeof(buf), 0) == 4 &&
memcmp(buf, "4567", 4) == 0);
i_stream_unref(&input2);
/* test that writing works within the same file */
i_stream_destroy(&input);
input = i_stream_create_fd(fd, 1024);
/* forwards: 4567 -> 4677 */
o_stream_seek(output, 1);
i_stream_seek(input, 2);
input2 = i_stream_create_limit(input, 2);
test_assert(o_stream_send_istream(output, input2) == OSTREAM_SEND_ISTREAM_RESULT_FINISHED);
test_assert(output->offset == 3);
test_assert(pread(fd, buf, sizeof(buf), 0) == 4 &&
memcmp(buf, "4677", 4) == 0);
i_stream_destroy(&input2);
i_stream_destroy(&input);
/* backwards: 1234 -> 11234 */
memcpy(buf, "1234", 4);
test_assert(pwrite(fd, buf, 4, 0) == 4);
input = i_stream_create_fd(fd, 1024);
o_stream_seek(output, 1);
test_assert(o_stream_send_istream(output, input) == OSTREAM_SEND_ISTREAM_RESULT_FINISHED);
test_assert(output->offset == 5);
test_assert(pread(fd, buf, sizeof(buf), 0) == 5 &&
memcmp(buf, "11234", 5) == 0);
i_stream_destroy(&input);
o_stream_destroy(&output);
i_close_fd(&fd);
i_unlink(".temp.istream");
i_unlink(".temp.ostream");
test_end();
}
static int
cmd_append_handle_args(struct client_command_context *cmd,
const struct imap_arg *args, bool *nonsync_r)
{
struct client *client = cmd->client;
struct cmd_append_context *ctx = cmd->context;
const struct imap_arg *flags_list;
const struct imap_arg *cat_list = NULL;
enum mail_flags flags;
const char *const *keywords_list;
struct mail_keywords *keywords;
struct istream *input;
const char *internal_date_str;
time_t internal_date;
int ret, timezone_offset;
bool valid;
/* [<flags>] */
if (!imap_arg_get_list(args, &flags_list))
flags_list = NULL;
else
args++;
/* [<internal date>] */
if (args->type != IMAP_ARG_STRING)
internal_date_str = NULL;
else {
internal_date_str = imap_arg_as_astring(args);
args++;
}
/* <message literal> | CATENATE (..) */
valid = FALSE;
*nonsync_r = FALSE;
ctx->catenate = FALSE;
if (imap_arg_get_literal_size(args, &ctx->literal_size)) {
*nonsync_r = args->type == IMAP_ARG_LITERAL_SIZE_NONSYNC;
ctx->binary_input = args->literal8;
valid = TRUE;
} else if (!imap_arg_atom_equals(args, "CATENATE")) {
/* invalid */
} else if (!imap_arg_get_list(++args, &cat_list)) {
/* invalid */
} else {
valid = TRUE;
ctx->catenate = TRUE;
/* We'll do BINARY conversion only if the CATENATE's first
part is a literal8. If it doesn't and a literal8 is seen
later we'll abort the append with UNKNOWN-CTE. */
ctx->binary_input = imap_arg_atom_equals(&cat_list[0], "TEXT") &&
cat_list[1].literal8;
}
if (!IMAP_ARG_IS_EOL(&args[1]))
valid = FALSE;
if (!valid) {
client->input_skip_line = TRUE;
if (!ctx->failed)
client_send_command_error(cmd, "Invalid arguments.");
return -1;
}
if (flags_list == NULL || ctx->failed) {
flags = 0;
keywords = NULL;
} else {
if (!client_parse_mail_flags(cmd, flags_list,
&flags, &keywords_list))
return -1;
if (keywords_list == NULL)
keywords = NULL;
else if (mailbox_keywords_create(ctx->box, keywords_list,
&keywords) < 0) {
/* invalid keywords - delay failure */
client_send_box_error(cmd, ctx->box);
ctx->failed = TRUE;
keywords = NULL;
}
}
if (internal_date_str == NULL || ctx->failed) {
/* no time given, default to now. */
internal_date = (time_t)-1;
timezone_offset = 0;
} else if (!imap_parse_datetime(internal_date_str,
&internal_date, &timezone_offset)) {
client_send_command_error(cmd, "Invalid internal date.");
if (keywords != NULL)
mailbox_keywords_unref(&keywords);
return -1;
}
if (internal_date != (time_t)-1 &&
internal_date > ioloop_time + INTERNALDATE_MAX_FUTURE_SECS) {
/* the client specified a time in the future, set it to now. */
internal_date = (time_t)-1;
timezone_offset = 0;
}
if (cat_list != NULL) {
ctx->cat_msg_size = 0;
ctx->input = i_stream_create_chain(&ctx->catchain);
} else {
if (ctx->literal_size == 0) {
/* no message data, abort */
if (!ctx->failed) {
client_send_tagline(cmd,
"NO Can't save a zero byte message.");
ctx->failed = TRUE;
}
if (!*nonsync_r) {
if (keywords != NULL)
mailbox_keywords_unref(&keywords);
return -1;
}
/* {0+} used. although there isn't any point in using
MULTIAPPEND here and adding more messages, it is
technically valid so we'll continue parsing.. */
}
ctx->litinput = i_stream_create_limit(client->input, ctx->literal_size);
ctx->input = ctx->litinput;
i_stream_ref(ctx->input);
}
if (ctx->binary_input) {
input = i_stream_create_binary_converter(ctx->input);
i_stream_unref(&ctx->input);
ctx->input = input;
}
if (!ctx->failed) {
/* save the mail */
ctx->save_ctx = mailbox_save_alloc(ctx->t);
mailbox_save_set_flags(ctx->save_ctx, flags, keywords);
mailbox_save_set_received_date(ctx->save_ctx,
internal_date, timezone_offset);
if (mailbox_save_begin(&ctx->save_ctx, ctx->input) < 0) {
/* save initialization failed */
client_send_box_error(cmd, ctx->box);
ctx->failed = TRUE;
}
}
if (keywords != NULL)
mailbox_keywords_unref(&keywords);
ctx->count++;
if (cat_list == NULL) {
/* normal APPEND */
return 1;
} else if (cat_list->type == IMAP_ARG_EOL) {
/* zero parts */
if (!ctx->failed)
client_send_command_error(cmd, "Empty CATENATE list.");
client->input_skip_line = TRUE;
return -1;
} else if ((ret = cmd_append_catenate(cmd, cat_list, nonsync_r)) < 0) {
/* invalid parameters, abort immediately */
return -1;
} else if (ret == 0) {
/* CATENATE consisted only of URLs */
return 0;
} else {
/* TEXT part found from CATENATE */
return 1;
}
}
static void test_iostream_temp_istream(void)
{
struct istream *input, *input2, *temp_input;
struct ostream *output;
int fd;
test_begin("iostream_temp istream");
fd = open(".temp.istream", O_RDWR | O_CREAT | O_TRUNC, 0600);
if (fd == -1)
i_fatal("create(.temp.istream) failed: %m");
test_assert(write(fd, "foobar", 6) == 6);
test_assert(lseek(fd, 0, SEEK_SET) == 0);
input = i_stream_create_fd_autoclose(&fd, 1024);
/* a working fd-dup */
output = iostream_temp_create_sized(".nonexistent/",
IOSTREAM_TEMP_FLAG_TRY_FD_DUP, "test", 1);
test_assert(o_stream_send_istream(output, input) == OSTREAM_SEND_ISTREAM_RESULT_FINISHED);
test_assert(output->offset == 6);
temp_input = iostream_temp_finish(&output, 128);
test_assert(i_stream_read(temp_input) == 6);
i_stream_destroy(&temp_input);
/* non-working fd-dup: write data before sending istream */
i_stream_seek(input, 0);
output = iostream_temp_create_sized(".intentional-nonexistent-error/",
IOSTREAM_TEMP_FLAG_TRY_FD_DUP, "test", 4);
test_assert(o_stream_send(output, "1234", 4) == 4);
test_assert(output->offset == 4);
test_expect_error_string("safe_mkstemp");
test_assert(o_stream_send_istream(output, input) == OSTREAM_SEND_ISTREAM_RESULT_FINISHED);
test_assert(output->offset == 10);
test_expect_no_more_errors();
o_stream_destroy(&output);
/* non-working fd-dup: write data after sending istream */
i_stream_seek(input, 0);
output = iostream_temp_create_sized(".intentional-nonexistent-error/",
IOSTREAM_TEMP_FLAG_TRY_FD_DUP, "test", 4);
test_assert(o_stream_send_istream(output, input) == OSTREAM_SEND_ISTREAM_RESULT_FINISHED);
test_assert(output->offset == 6);
test_expect_error_string("safe_mkstemp");
test_assert(o_stream_send(output, "1", 1) == 1);
test_assert(output->offset == 7);
test_expect_no_more_errors();
o_stream_destroy(&output);
/* non-working fd-dup: send two istreams */
i_stream_seek(input, 0);
input2 = i_stream_create_limit(input, (uoff_t)-1);
output = iostream_temp_create_sized(".intentional-nonexistent-error/",
IOSTREAM_TEMP_FLAG_TRY_FD_DUP, "test", 4);
test_assert(o_stream_send_istream(output, input) == OSTREAM_SEND_ISTREAM_RESULT_FINISHED);
test_assert(output->offset == 6);
test_expect_error_string("safe_mkstemp");
test_assert(o_stream_send_istream(output, input2) == OSTREAM_SEND_ISTREAM_RESULT_FINISHED);
test_assert(output->offset == 12);
test_expect_no_more_errors();
o_stream_destroy(&output);
i_stream_unref(&input2);
i_stream_destroy(&input);
i_unlink(".temp.istream");
test_end();
}
