static int fs_sis_write_stream_finish(struct fs_file *_file, bool success)
{
struct sis_fs_file *file = (struct sis_fs_file *)_file;
if (!success) {
fs_write_stream_abort(file->super, &file->fs_output);
fs_sis_file_copy_error(file);
return -1;
}
if (file->hash_input != NULL &&
o_stream_cmp_equals(_file->output) &&
i_stream_is_eof(file->hash_input)) {
if (fs_sis_try_link(file)) {
fs_write_stream_abort(file->super, &file->fs_output);
return 0;
}
}
if (fs_write_stream_finish(file->super, &file->fs_output) < 0) {
fs_sis_file_copy_error(file);
return -1;
}
T_BEGIN {
fs_sis_replace_hash_file(file);
} T_END;
return 0;
}
static ssize_t
i_stream_mail_filter_read_once(struct mail_filter_istream *mstream)
{
struct istream_private *stream = &mstream->istream;
ssize_t ret;
if (mstream->ext_out != NULL) {
/* we haven't sent everything yet */
(void)o_stream_send_istream(mstream->ext_out, stream->parent);
if (mstream->ext_out->stream_errno != 0) {
stream->istream.stream_errno =
mstream->ext_out->stream_errno;
return -1;
}
if (i_stream_is_eof(stream->parent)) {
o_stream_destroy(&mstream->ext_out);
/* if we wanted to be a blocking stream,
from now on the rest of the reads are */
if (stream->istream.blocking)
net_set_nonblock(mstream->fd, FALSE);
if (shutdown(mstream->fd, SHUT_WR) < 0)
i_error("ext-filter: shutdown() failed: %m");
}
}
i_stream_skip(mstream->ext_in, mstream->prev_ret);
ret = i_stream_read_copy_from(&stream->istream, mstream->ext_in);
mstream->prev_ret = ret < 0 ? 0 : ret;
return ret;
}
static void program_client_program_input(struct program_client *pclient)
{
struct istream *input = pclient->program_input;
struct ostream *output = pclient->output;
const unsigned char *data;
size_t size;
int ret = 0;
if ( input != NULL ) {
while ( (ret=i_stream_read_data(input, &data, &size, 0)) > 0 ) {
if ( output != NULL ) {
ssize_t sent;
if ( (sent=o_stream_send(output, data, size)) < 0 ) {
program_client_fail(pclient, PROGRAM_CLIENT_ERROR_IO);
return;
}
size = (size_t)sent;
}
i_stream_skip(input, size);
}
if ( ret < 0 ) {
if ( i_stream_is_eof(input) ) {
if ( !program_client_input_pending(pclient) )
program_client_disconnect(pclient, FALSE);
return;
}
program_client_fail(pclient, PROGRAM_CLIENT_ERROR_IO);
}
}
}
int dsync_mail_get_hdr_hash(struct mail *mail, const char **hdr_hash_r)
{
struct istream *hdr_input, *input;
struct mailbox_header_lookup_ctx *hdr_ctx;
struct md5_context md5_ctx;
unsigned char md5_result[MD5_RESULTLEN];
const unsigned char *data;
size_t size;
int ret = 0;
hdr_ctx = mailbox_header_lookup_init(mail->box, hashed_headers);
ret = mail_get_header_stream(mail, hdr_ctx, &hdr_input);
mailbox_header_lookup_unref(&hdr_ctx);
if (ret < 0)
return -1;
input = i_stream_create_lf(hdr_input);
md5_init(&md5_ctx);
while (!i_stream_is_eof(input)) {
if (i_stream_read_data(input, &data, &size, 0) == -1)
break;
if (size == 0)
break;
md5_update(&md5_ctx, data, size);
i_stream_skip(input, size);
}
if (input->stream_errno != 0)
ret = -1;
i_stream_unref(&input);
md5_final(&md5_ctx, md5_result);
*hdr_hash_r = binary_to_hex(md5_result, sizeof(md5_result));
return ret;
}
static void program_client_extra_fd_input
(struct program_client_extra_fd *efd)
{
struct program_client *pclient = efd->pclient;
i_assert(efd->callback != NULL);
efd->callback(efd->context, efd->input);
if (efd->input->closed || i_stream_is_eof(efd->input)) {
if ( !program_client_input_pending(pclient) )
program_client_disconnect(pclient, FALSE);
}
}
static bool program_client_input_pending(struct program_client *pclient)
{
struct program_client_extra_fd *efds = NULL;
unsigned int count, i;
if ( pclient->program_input != NULL &&
!pclient->program_input->closed &&
!i_stream_is_eof(pclient->program_input) ) {
return TRUE;
}
if ( array_is_created(&pclient->extra_fds) ) {
efds = array_get_modifiable(&pclient->extra_fds, &count);
for ( i = 0; i < count; i++ ) {
if ( efds[i].input != NULL &&
!efds[i].input->closed &&
!i_stream_is_eof(efds[i].input) ) {
return TRUE;
}
}
}
return FALSE;
}
static int fs_sis_write(struct fs_file *_file, const void *data, size_t size)
{
struct sis_fs_file *file = (struct sis_fs_file *)_file;
if (file->hash_input != NULL &&
stream_cmp_block(file->hash_input, data, size) &&
i_stream_is_eof(file->hash_input)) {
/* try to use existing file */
if (fs_sis_try_link(file))
return 0;
}
if (fs_write(file->super, data, size) < 0) {
fs_sis_file_copy_error(file);
return -1;
}
T_BEGIN {
fs_sis_replace_hash_file(file);
} T_END;
return 0;
}
int http_header_parse_next_field(struct http_header_parser *parser,
const char **name_r, const unsigned char **data_r, size_t *size_r,
const char **error_r)
{
const uoff_t max_size = parser->limits.max_size;
const uoff_t max_field_size = parser->limits.max_field_size;
const unsigned char *data;
size_t size;
int ret;
*error_r = NULL;
while ((ret=i_stream_read_more(parser->input, &parser->begin, &size)) > 0) {
/* check header size limits */
if (parser->size >= max_size) {
*error_r = "Excessive header size";
return -1;
}
if (parser->field_size > max_field_size) {
*error_r = "Excessive header field size";
return -1;
}
/* don't parse beyond header size limits */
if (size > (max_size - parser->size))
size = max_size - parser->size;
if (size > (max_field_size - parser->field_size)) {
size = max_field_size - parser->field_size;
size = (size == 0 ? 1 : size); /* need to parse one more byte */
}
parser->cur = parser->begin;
parser->end = parser->cur + size;
if ((ret=http_header_parse(parser)) < 0) {
*error_r = parser->error;
return -1;
}
i_stream_skip(parser->input, parser->cur - parser->begin);
parser->size += parser->cur - parser->begin;
parser->field_size += parser->cur - parser->begin;
if (ret == 1) {
parser->field_size = 0;
if (parser->state != HTTP_HEADER_PARSE_STATE_EOH) {
data = buffer_get_data(parser->value_buf, &size);
/* trim trailing OWS */
while (size > 0 &&
(data[size-1] == ' ' || data[size-1] == '\t'))
size--;
*name_r = str_c(parser->name);
*data_r = data;
*size_r = size;
parser->state = HTTP_HEADER_PARSE_STATE_INIT;
} else {
*name_r = NULL;
*data_r = NULL;
}
return 1;
}
}
i_assert(ret != -2);
if (ret < 0) {
if (i_stream_is_eof(parser->input))
*error_r = "Premature end of input";
else
*error_r = "Stream error";
}
return ret;
}
static ssize_t i_stream_zlib_read(struct istream_private *stream)
{
struct zlib_istream *zstream = (struct zlib_istream *)stream;
const unsigned char *data;
uoff_t high_offset;
size_t size, out_size;
int ret;
high_offset = stream->istream.v_offset + (stream->pos - stream->skip);
if (zstream->eof_offset == high_offset) {
i_assert(zstream->high_pos == 0 ||
zstream->high_pos == stream->pos);
if (!zstream->trailer_read) {
do {
ret = i_stream_zlib_read_trailer(zstream);
} while (ret == 0 && stream->istream.blocking);
if (ret <= 0)
return ret;
}
if (!zstream->gz || i_stream_is_eof(stream->parent)) {
stream->istream.eof = TRUE;
return -1;
}
/* gzip file with concatenated content */
zstream->eof_offset = (uoff_t)-1;
zstream->stream_size = (uoff_t)-1;
zstream->header_read = FALSE;
zstream->trailer_read = FALSE;
zstream->crc32 = 0;
(void)inflateEnd(&zstream->zs);
i_stream_zlib_init(zstream);
}
if (!zstream->header_read) {
do {
ret = i_stream_zlib_read_header(stream);
} while (ret == 0 && stream->istream.blocking);
if (ret <= 0)
return ret;
zstream->header_read = TRUE;
}
if (stream->pos < zstream->high_pos) {
/* we're here because we seeked back within the read buffer. */
ret = zstream->high_pos - stream->pos;
stream->pos = zstream->high_pos;
zstream->high_pos = 0;
if (zstream->trailer_read) {
high_offset = stream->istream.v_offset +
(stream->pos - stream->skip);
i_assert(zstream->eof_offset == high_offset);
stream->istream.eof = TRUE;
}
return ret;
}
zstream->high_pos = 0;
if (stream->pos + CHUNK_SIZE > stream->buffer_size) {
/* try to keep at least CHUNK_SIZE available */
if (!zstream->marked && stream->skip > 0) {
/* don't try to keep anything cached if we don't
have a seek mark. */
i_stream_compress(stream);
}
if (stream->buffer_size < i_stream_get_max_buffer_size(&stream->istream))
i_stream_grow_buffer(stream, CHUNK_SIZE);
if (stream->pos == stream->buffer_size) {
if (stream->skip > 0) {
/* lose our buffer cache */
i_stream_compress(stream);
}
if (stream->pos == stream->buffer_size)
return -2; /* buffer full */
}
}
if (i_stream_read_more(stream->parent, &data, &size) < 0) {
if (stream->parent->stream_errno != 0) {
stream->istream.stream_errno =
stream->parent->stream_errno;
} else {
i_assert(stream->parent->eof);
zlib_read_error(zstream, "unexpected EOF");
stream->istream.stream_errno = EPIPE;
}
return -1;
}
if (size == 0) {
/* no more input */
i_assert(!stream->istream.blocking);
return 0;
}
zstream->zs.next_in = (void *)data;
zstream->zs.avail_in = size;
out_size = stream->buffer_size - stream->pos;
zstream->zs.next_out = stream->w_buffer + stream->pos;
zstream->zs.avail_out = out_size;
ret = inflate(&zstream->zs, Z_SYNC_FLUSH);
out_size -= zstream->zs.avail_out;
zstream->crc32 = crc32_data_more(zstream->crc32,
stream->w_buffer + stream->pos,
out_size);
stream->pos += out_size;
i_stream_skip(stream->parent, size - zstream->zs.avail_in);
switch (ret) {
case Z_OK:
break;
case Z_NEED_DICT:
zlib_read_error(zstream, "can't read file without dict");
stream->istream.stream_errno = EINVAL;
return -1;
case Z_DATA_ERROR:
zlib_read_error(zstream, "corrupted data");
stream->istream.stream_errno = EINVAL;
return -1;
case Z_MEM_ERROR:
i_fatal_status(FATAL_OUTOFMEM, "zlib.read(%s): Out of memory",
i_stream_get_name(&stream->istream));
case Z_STREAM_END:
zstream->eof_offset = stream->istream.v_offset +
(stream->pos - stream->skip);
zstream->stream_size = zstream->eof_offset;
zstream->zs.avail_in = 0;
if (!zstream->trailer_read) {
/* try to read and verify the trailer, we might not
be called again. */
if (i_stream_zlib_read_trailer(zstream) < 0)
return -1;
}
break;
default:
i_fatal("inflate() failed with %d", ret);
}
if (out_size == 0) {
/* read more input */
return i_stream_zlib_read(stream);
}
return out_size;
}
static int
cmd_append_catenate_mpurl(struct client_command_context *cmd,
const char *caturl, struct imap_msgpart_url *mpurl)
{
struct cmd_append_context *ctx = cmd->context;
struct imap_msgpart_open_result mpresult;
uoff_t newsize;
const char *error;
int ret;
/* catenate URL */
ret = imap_msgpart_url_read_part(mpurl, &mpresult, &error);
if (ret < 0) {
client_send_box_error(cmd, ctx->box);
return -1;
}
if (ret == 0) {
/* invalid url, abort */
client_send_tagline(cmd,
t_strdup_printf("NO [BADURL %s] %s.", caturl, error));
return -1;
}
if (mpresult.size == 0) {
/* empty input */
return 0;
}
newsize = ctx->cat_msg_size + mpresult.size;
if (newsize < ctx->cat_msg_size) {
client_send_tagline(cmd,
"NO [TOOBIG] Composed message grows too big.");
return -1;
}
ctx->cat_msg_size = newsize;
/* add this input stream to chain */
i_stream_chain_append(ctx->catchain, mpresult.input);
/* save by reading the chain stream */
while (!i_stream_is_eof(mpresult.input)) {
ret = i_stream_read(mpresult.input);
i_assert(ret != 0); /* we can handle only blocking input here */
if (mailbox_save_continue(ctx->save_ctx) < 0 || ret == -1)
break;
}
if (mpresult.input->stream_errno != 0) {
errno = mpresult.input->stream_errno;
mail_storage_set_critical(ctx->box->storage,
"read(%s) failed: %s (for CATENATE URL %s)",
i_stream_get_name(mpresult.input),
i_stream_get_error(mpresult.input), caturl);
client_send_box_error(cmd, ctx->box);
ret = -1;
} else if (!mpresult.input->eof) {
/* save failed */
client_send_box_error(cmd, ctx->box);
ret = -1;
} else {
/* all the input must be consumed, so istream-chain's read()
unreferences the stream and we can free its parent mail */
i_assert(!i_stream_have_bytes_left(mpresult.input));
ret = 0;
}
return ret;
}
int http_client_request_send_more(struct http_client_request *req,
const char **error_r)
{
struct http_client_connection *conn = req->conn;
struct ostream *output = req->payload_output;
off_t ret;
int fd;
i_assert(req->payload_input != NULL);
i_assert(req->payload_output != NULL);
if (conn->io_req_payload != NULL)
io_remove(&conn->io_req_payload);
/* chunked ostream needs to write to the parent stream's buffer */
o_stream_set_max_buffer_size(output, IO_BLOCK_SIZE);
ret = o_stream_send_istream(output, req->payload_input);
o_stream_set_max_buffer_size(output, (size_t)-1);
if (req->payload_input->stream_errno != 0) {
/* the payload stream assigned to this request is broken,
fail this the request immediately */
http_client_request_send_error(req,
HTTP_CLIENT_REQUEST_ERROR_BROKEN_PAYLOAD,
"Broken payload stream");
/* we're in the middle of sending a request, so the connection
will also have to be aborted */
errno = req->payload_input->stream_errno;
*error_r = t_strdup_printf("read(%s) failed: %s",
i_stream_get_name(req->payload_input),
i_stream_get_error(req->payload_input));
ret = -1;
} else if (output->stream_errno != 0) {
/* failed to send request */
errno = output->stream_errno;
*error_r = t_strdup_printf("write(%s) failed: %s",
o_stream_get_name(output),
o_stream_get_error(output));
ret = -1;
} else {
i_assert(ret >= 0);
}
if (ret < 0 || i_stream_is_eof(req->payload_input)) {
if (!req->payload_chunked &&
req->payload_input->v_offset - req->payload_offset != req->payload_size) {
*error_r = "stream input size changed [BUG]";
i_error("stream input size changed"); //FIXME
return -1;
}
if (req->payload_wait) {
conn->output_locked = TRUE;
if (req->client->ioloop != NULL)
io_loop_stop(req->client->ioloop);
} else {
http_client_request_finish_payload_out(req);
}
} else if (i_stream_get_data_size(req->payload_input) > 0) {
/* output is blocking */
conn->output_locked = TRUE;
o_stream_set_flush_pending(output, TRUE);
http_client_request_debug(req, "Partially sent payload");
} else {
/* input is blocking */
fd = i_stream_get_fd(req->payload_input);
conn->output_locked = TRUE;
i_assert(fd >= 0);
conn->io_req_payload = io_add
(fd, IO_READ, http_client_request_payload_input, req);
}
return ret < 0 ? -1 : 0;
}
