void connection_init_from_streams(struct connection_list *list,
struct connection *conn, const char *name,
struct istream *input, struct ostream *output)
{
i_assert(name != NULL);
conn->list = list;
conn->name = i_strdup(name);
conn->fd_in = i_stream_get_fd(input);
conn->fd_out = o_stream_get_fd(output);
i_assert(conn->fd_in >= 0);
i_assert(conn->fd_out >= 0);
i_assert(conn->io == NULL);
i_assert(conn->input == NULL);
i_assert(conn->output == NULL);
i_assert(conn->to == NULL);
conn->input = input;
i_stream_ref(conn->input);
i_stream_set_name(conn->input, conn->name);
conn->output = output;
o_stream_ref(conn->output);
o_stream_set_no_error_handling(conn->output, TRUE);
o_stream_set_name(conn->output, conn->name);
conn->io = io_add_istream(conn->input, *list->v.input, conn);
DLLIST_PREPEND(&list->connections, conn);
list->connections_count++;
if (list->v.client_connected != NULL)
list->v.client_connected(conn, TRUE);
}
bool cmd_idle(struct client_command_context *cmd)
{
struct client *client = cmd->client;
struct cmd_idle_context *ctx;
ctx = p_new(cmd->pool, struct cmd_idle_context, 1);
ctx->cmd = cmd;
ctx->client = client;
idle_add_keepalive_timeout(ctx);
idle_add_hibernate_timeout(ctx);
if (client->mailbox != NULL)
mailbox_notify_changes(client->mailbox, idle_callback, ctx);
if (!client->state_import_idle_continue)
client_send_line(client, "+ idling");
else {
/* continuing an IDLE after hibernation */
client->state_import_idle_continue = FALSE;
}
io_remove(&client->io);
client->io = io_add_istream(client->input, idle_client_input, ctx);
cmd->func = cmd_idle_continue;
cmd->context = ctx;
/* check immediately if there are changes. if they came before we
added mailbox-notifier, we wouldn't see them otherwise. */
if (client->mailbox != NULL)
idle_sync_now(client->mailbox, ctx);
return idle_client_handle_input(ctx, FALSE);
}
static void connection_init_streams(struct connection *conn)
{
const struct connection_settings *set = &conn->list->set;
i_assert(conn->io == NULL);
i_assert(conn->input == NULL);
i_assert(conn->output == NULL);
i_assert(conn->to == NULL);
conn->version_received = set->major_version == 0;
if (set->input_max_size != 0) {
conn->input = i_stream_create_fd(conn->fd_in,
set->input_max_size, FALSE);
i_stream_set_name(conn->input, conn->name);
conn->io = io_add_istream(conn->input, *conn->list->v.input, conn);
} else {
conn->io = io_add(conn->fd_in, IO_READ, *conn->list->v.input, conn);
}
if (set->output_max_size != 0) {
conn->output = o_stream_create_fd(conn->fd_out,
set->output_max_size, FALSE);
o_stream_set_no_error_handling(conn->output, TRUE);
o_stream_set_name(conn->output, conn->name);
}
if (set->input_idle_timeout_secs != 0) {
conn->to = timeout_add(set->input_idle_timeout_secs*1000,
connection_idle_timeout, conn);
}
if (set->major_version != 0 && !set->dont_send_version) {
o_stream_nsend_str(conn->output, t_strdup_printf(
"VERSION\t%s\t%u\t%u\n", set->service_name_out,
set->major_version, set->minor_version));
}
}
static int iostream_pump_flush(struct iostream_pump *pump)
{
int ret;
if ((ret = o_stream_flush(pump->output)) <= 0) {
if (ret < 0) {
pump->callback(IOSTREAM_PUMP_STATUS_OUTPUT_ERROR,
pump->context);
}
return ret;
}
pump->waiting_output = FALSE;
if (pump->completed) {
pump->callback(IOSTREAM_PUMP_STATUS_INPUT_EOF, pump->context);
return 1;
}
if (pump->input->blocking)
iostream_pump_copy(pump);
else if (pump->io == NULL) {
pump->io = io_add_istream(pump->input,
iostream_pump_copy, pump);
io_set_pending(pump->io);
}
return ret;
}
void login_proxy_detach(struct login_proxy *proxy)
{
struct client *client = proxy->client;
const unsigned char *data;
size_t size;
i_assert(proxy->client_fd == -1);
i_assert(proxy->server_input != NULL);
i_assert(proxy->server_output != NULL);
if (proxy->to != NULL)
timeout_remove(&proxy->to);
proxy->client_fd = i_stream_get_fd(client->input);
proxy->client_input = client->input;
proxy->client_output = client->output;
i_stream_set_persistent_buffers(client->input, FALSE);
o_stream_set_max_buffer_size(client->output, (size_t)-1);
o_stream_set_flush_callback(client->output, proxy_client_output, proxy);
client->input = NULL;
client->output = NULL;
/* send all pending client input to proxy */
data = i_stream_get_data(proxy->client_input, &size);
if (size != 0)
o_stream_nsend(proxy->server_output, data, size);
/* from now on, just do dummy proxying */
io_remove(&proxy->server_io);
proxy->server_io =
io_add(proxy->server_fd, IO_READ, server_input, proxy);
proxy->client_io =
io_add_istream(proxy->client_input, proxy_client_input, proxy);
o_stream_set_flush_callback(proxy->server_output, server_output, proxy);
i_stream_destroy(&proxy->server_input);
if (proxy->notify_refresh_secs != 0) {
proxy->to_notify =
timeout_add(proxy->notify_refresh_secs * 1000,
login_proxy_notify, proxy);
}
proxy->callback = NULL;
if (login_proxy_ipc_server == NULL) {
login_proxy_ipc_server =
ipc_server_init(LOGIN_PROXY_IPC_PATH,
LOGIN_PROXY_IPC_NAME,
login_proxy_ipc_cmd);
}
DLLIST_REMOVE(&login_proxies_pending, proxy);
DLLIST_PREPEND(&login_proxies, proxy);
client->fd = -1;
client->login_proxy = NULL;
}
login_proxy_free_full(struct login_proxy **_proxy, const char *reason,
bool delayed)
{
struct login_proxy *proxy = *_proxy;
struct client *client = proxy->client;
const char *ipstr;
unsigned int delay_ms = 0;
*_proxy = NULL;
if (proxy->destroying)
return;
proxy->destroying = TRUE;
/* we'll disconnect server side in any case. */
login_proxy_disconnect(proxy);
if (proxy->client_fd != -1) {
/* detached proxy */
DLLIST_REMOVE(&login_proxies, proxy);
if (delayed)
delay_ms = login_proxy_delay_disconnect(proxy);
ipstr = net_ip2addr(&proxy->client->ip);
client_log(proxy->client, t_strdup_printf(
"proxy(%s): disconnecting %s%s%s",
proxy->client->virtual_user,
ipstr != NULL ? ipstr : "",
reason == NULL ? "" : t_strdup_printf(" (%s)", reason),
delay_ms == 0 ? "" : t_strdup_printf(" - disconnecting client in %ums", delay_ms)));
if (proxy->client_io != NULL)
io_remove(&proxy->client_io);
} else {
i_assert(proxy->client_io == NULL);
i_assert(proxy->client_input == NULL);
i_assert(proxy->client_output == NULL);
i_assert(proxy->client_fd == -1);
DLLIST_REMOVE(&login_proxies_pending, proxy);
if (proxy->callback != NULL)
proxy->callback(proxy->client);
}
if (delay_ms == 0)
login_proxy_free_final(proxy);
else {
proxy->client_io = io_add_istream(proxy->client_input,
proxy_client_disconnected_input, proxy);
}
client->login_proxy = NULL;
client_unref(&client);
}
static void fts_parser_tika_more(struct fts_parser *_parser,
struct message_block *block)
{
struct tika_fts_parser *parser = (struct tika_fts_parser *)_parser;
const unsigned char *data;
size_t size;
ssize_t ret;
if (block->size > 0) {
/* first we'll send everything to Tika */
if (!parser->failed &&
http_client_request_send_payload(&parser->http_req,
block->data,
block->size) < 0)
parser->failed = TRUE;
block->size = 0;
return;
}
if (parser->payload == NULL) {
/* read the result from Tika */
if (!parser->failed &&
http_client_request_finish_payload(&parser->http_req) < 0)
parser->failed = TRUE;
if (!parser->failed && parser->payload == NULL)
http_client_wait(tika_http_client);
if (parser->failed)
return;
i_assert(parser->payload != NULL);
}
/* continue returning data from Tika */
while ((ret = i_stream_read_data(parser->payload, &data, &size, 0)) == 0) {
if (parser->failed)
return;
/* wait for more input from Tika */
if (parser->ioloop == NULL) {
parser->ioloop = io_loop_create();
parser->io = io_add_istream(parser->payload, io_loop_stop,
current_ioloop);
} else {
io_loop_set_current(parser->ioloop);
}
io_loop_run(current_ioloop);
}
if (size > 0) {
i_assert(ret > 0);
block->data = data;
block->size = size;
i_stream_skip(parser->payload, size);
} else {
/* finished */
i_assert(ret == -1);
}
}
bool cmd_append(struct client_command_context *cmd)
{
struct client *client = cmd->client;
struct cmd_append_context *ctx;
const char *mailbox;
if (client->syncing) {
/* if transaction is created while its view is synced,
appends aren't allowed for it. */
cmd->state = CLIENT_COMMAND_STATE_WAIT_UNAMBIGUITY;
return FALSE;
}
/* <mailbox> */
if (!client_read_string_args(cmd, 1, &mailbox))
return FALSE;
/* we keep the input locked all the time */
client->input_lock = cmd;
ctx = p_new(cmd->pool, struct cmd_append_context, 1);
ctx->cmd = cmd;
ctx->client = client;
ctx->started = ioloop_time;
if (client_open_save_dest_box(cmd, mailbox, &ctx->box) < 0)
ctx->failed = TRUE;
else {
ctx->t = mailbox_transaction_begin(ctx->box,
MAILBOX_TRANSACTION_FLAG_EXTERNAL |
MAILBOX_TRANSACTION_FLAG_ASSIGN_UIDS);
}
io_remove(&client->io);
client->io = io_add_istream(client->input, client_input_append, cmd);
/* append is special because we're only waiting on client input, not
client output, so disable the standard output handler until we're
finished */
o_stream_unset_flush_callback(client->output);
ctx->save_parser = imap_parser_create(client->input, client->output,
client->set->imap_max_line_length);
cmd->func = cmd_append_parse_new_msg;
cmd->context = ctx;
return cmd_append_parse_new_msg(cmd);
}
static int server_output(struct login_proxy *proxy)
{
proxy->last_io = ioloop_time;
if (o_stream_flush(proxy->server_output) < 0) {
login_proxy_free_ostream(&proxy, proxy->server_output, TRUE);
return 1;
}
if (proxy->client_io == NULL &&
o_stream_get_buffer_used_size(proxy->server_output) <
OUTBUF_THRESHOLD) {
/* there's again space in proxy's output buffer, so we can
read more from client. */
proxy->client_io = io_add_istream(proxy->client_input,
proxy_client_input, proxy);
}
return 1;
}
void iostream_pump_start(struct iostream_pump *pump)
{
i_assert(pump != NULL);
i_assert(pump->callback != NULL);
/* add flush handler */
if (!pump->output->blocking) {
o_stream_set_flush_callback(pump->output,
iostream_pump_flush, pump);
}
/* make IO objects */
if (pump->input->blocking) {
i_assert(!pump->output->blocking);
o_stream_set_flush_pending(pump->output, TRUE);
} else {
pump->io = io_add_istream(pump->input,
iostream_pump_copy, pump);
io_set_pending(pump->io);
}
}
int http_client_request_send_more(struct http_client_request *req,
bool pipelined, const char **error_r)
{
struct http_client_connection *conn = req->conn;
struct ostream *output = req->payload_output;
enum ostream_send_istream_result res;
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);
res = o_stream_send_istream(output, req->payload_input);
o_stream_set_max_buffer_size(output, (size_t)-1);
switch (res) {
case OSTREAM_SEND_ISTREAM_RESULT_FINISHED:
/* finished sending */
if (!req->payload_chunked &&
req->payload_input->v_offset - req->payload_offset != req->payload_size) {
*error_r = t_strdup_printf("BUG: stream '%s' input size changed: "
"%"PRIuUOFF_T"-%"PRIuUOFF_T" != %"PRIuUOFF_T,
i_stream_get_name(req->payload_input),
req->payload_input->v_offset, req->payload_offset, req->payload_size);
i_error("%s", *error_r); //FIXME: remove?
return -1;
}
if (req->payload_wait) {
/* this chunk of input is finished
(client needs to act; disable timeout) */
i_assert(!pipelined);
conn->output_locked = TRUE;
http_client_connection_stop_request_timeout(conn);
if (req->client->ioloop != NULL)
io_loop_stop(req->client->ioloop);
} else {
/* finished sending payload */
http_client_request_finish_payload_out(req);
}
return 0;
case OSTREAM_SEND_ISTREAM_RESULT_WAIT_INPUT:
/* input is blocking (client needs to act; disable timeout) */
conn->output_locked = TRUE;
if (!pipelined)
http_client_connection_stop_request_timeout(conn);
conn->io_req_payload = io_add_istream(req->payload_input,
http_client_request_payload_input, req);
return 0;
case OSTREAM_SEND_ISTREAM_RESULT_WAIT_OUTPUT:
/* output is blocking (server needs to act; enable timeout) */
conn->output_locked = TRUE;
if (!pipelined)
http_client_connection_start_request_timeout(conn);
http_client_request_debug(req, "Partially sent payload");
return 0;
case OSTREAM_SEND_ISTREAM_RESULT_ERROR_INPUT:
/* we're in the middle of sending a request, so the connection
will also have to be aborted */
*error_r = t_strdup_printf("read(%s) failed: %s",
i_stream_get_name(req->payload_input),
i_stream_get_error(req->payload_input));
/* the payload stream assigned to this request is broken,
fail this the request immediately */
http_client_request_error(&req,
HTTP_CLIENT_REQUEST_ERROR_BROKEN_PAYLOAD,
"Broken payload stream");
return -1;
case OSTREAM_SEND_ISTREAM_RESULT_ERROR_OUTPUT:
/* failed to send request */
*error_r = t_strdup_printf("write(%s) failed: %s",
o_stream_get_name(output),
o_stream_get_error(output));
return -1;
}
i_unreached();
}
static ssize_t
http_server_istream_read(struct istream_private *stream)
{
struct http_server_istream *hsristream =
(struct http_server_istream *)stream;
struct http_server_request *req = hsristream->req;
struct http_server *server;
struct http_server_connection *conn;
bool blocking = stream->istream.blocking;
ssize_t ret;
if (req == NULL) {
/* request already gone (we shouldn't get here) */
stream->istream.stream_errno = EINVAL;
return -1;
}
i_stream_seek(stream->parent, stream->parent_start_offset +
stream->istream.v_offset);
server = hsristream->req->server;
conn = hsristream->req->conn;
ret = i_stream_read_copy_from_parent(&stream->istream);
if (ret == 0 && blocking) {
struct ioloop *prev_ioloop = current_ioloop;
struct io *io;
http_server_connection_ref(conn);
http_server_request_ref(req);
i_assert(server->ioloop == NULL);
server->ioloop = io_loop_create();
http_server_connection_switch_ioloop(conn);
if (blocking && req->req.expect_100_continue &&
!req->sent_100_continue)
http_server_connection_trigger_responses(conn);
hsristream->read_status = 0;
io = io_add_istream(&stream->istream,
http_server_istream_read_any, hsristream);
while (req->state < HTTP_SERVER_REQUEST_STATE_FINISHED &&
hsristream->read_status == 0) {
io_loop_run(server->ioloop);
}
io_remove(&io);
io_loop_set_current(prev_ioloop);
http_server_connection_switch_ioloop(conn);
io_loop_set_current(server->ioloop);
io_loop_destroy(&server->ioloop);
ret = hsristream->read_status;
if (!http_server_request_unref(&req))
hsristream->req = NULL;
http_server_connection_unref(&conn);
}
return ret;
}
void client_add_missing_io(struct client *client)
{
if (client->io == NULL && !client->disconnected)
client->io = io_add_istream(client->input, client_input, client);
}
struct client *client_create(int fd_in, int fd_out, const char *session_id,
struct mail_user *user,
struct mail_storage_service_user *service_user,
const struct imap_settings *set)
{
const struct mail_storage_settings *mail_set;
struct client *client;
const char *ident;
pool_t pool;
bool explicit_capability = FALSE;
/* always use nonblocking I/O */
net_set_nonblock(fd_in, TRUE);
net_set_nonblock(fd_out, TRUE);
pool = pool_alloconly_create("imap client", 2048);
client = p_new(pool, struct client, 1);
client->pool = pool;
client->v = imap_client_vfuncs;
client->set = set;
client->service_user = service_user;
client->session_id = p_strdup(pool, session_id);
client->fd_in = fd_in;
client->fd_out = fd_out;
client->input = i_stream_create_fd(fd_in,
set->imap_max_line_length, FALSE);
client->output = o_stream_create_fd(fd_out, (size_t)-1, FALSE);
o_stream_set_no_error_handling(client->output, TRUE);
i_stream_set_name(client->input, "<imap client>");
o_stream_set_name(client->output, "<imap client>");
o_stream_set_flush_callback(client->output, client_output, client);
p_array_init(&client->module_contexts, client->pool, 5);
client->io = io_add_istream(client->input, client_input, client);
client->last_input = ioloop_time;
client->to_idle = timeout_add(CLIENT_IDLE_TIMEOUT_MSECS,
client_idle_timeout, client);
client->command_pool =
pool_alloconly_create(MEMPOOL_GROWING"client command", 1024*2);
client->user = user;
client->notify_count_changes = TRUE;
client->notify_flag_changes = TRUE;
mail_namespaces_set_storage_callbacks(user->namespaces,
&mail_storage_callbacks, client);
client->capability_string =
str_new(client->pool, sizeof(CAPABILITY_STRING)+64);
if (*set->imap_capability == '\0')
str_append(client->capability_string, CAPABILITY_STRING);
else if (*set->imap_capability != '+') {
explicit_capability = TRUE;
str_append(client->capability_string, set->imap_capability);
} else {
str_append(client->capability_string, CAPABILITY_STRING);
str_append_c(client->capability_string, ' ');
str_append(client->capability_string, set->imap_capability + 1);
}
if (user->fuzzy_search && !explicit_capability) {
/* Enable FUZZY capability only when it actually has
a chance of working */
str_append(client->capability_string, " SEARCH=FUZZY");
}
mail_set = mail_user_set_get_storage_set(user);
if (mail_set->mailbox_list_index && !explicit_capability) {
/* NOTIFY is enabled only when mailbox list indexes are
enabled, although even that doesn't necessarily guarantee
it always */
str_append(client->capability_string, " NOTIFY");
}
if (*set->imap_urlauth_host != '\0' &&
*mail_set->mail_attribute_dict != '\0') {
/* Enable URLAUTH capability only when dict is
configured correctly */
client_init_urlauth(client);
if (!explicit_capability)
str_append(client->capability_string, " URLAUTH URLAUTH=BINARY");
}
if (set->imap_metadata && *mail_set->mail_attribute_dict != '\0') {
client->imap_metadata_enabled = TRUE;
if (!explicit_capability)
str_append(client->capability_string, " METADATA");
}
if (!explicit_capability && user_has_special_use_mailboxes(user)) {
/* Advertise SPECIAL-USE only if there are actually some
SPECIAL-USE flags in mailbox configuration. */
str_append(client->capability_string, " SPECIAL-USE");
}
ident = mail_user_get_anvil_userip_ident(client->user);
if (ident != NULL) {
master_service_anvil_send(master_service, t_strconcat(
"CONNECT\t", my_pid, "\timap/", ident, "\n", NULL));
client->anvil_sent = TRUE;
}
imap_client_count++;
DLLIST_PREPEND(&imap_clients, client);
if (hook_client_created != NULL)
hook_client_created(&client);
imap_refresh_proctitle();
return client;
}
static bool cmd_idle_continue(struct client_command_context *cmd)
{
struct client *client = cmd->client;
struct cmd_idle_context *ctx = cmd->context;
uoff_t orig_offset = client->output->offset;
if (cmd->cancel) {
idle_finish(ctx, FALSE, FALSE);
return TRUE;
}
if (ctx->to_hibernate != NULL)
timeout_reset(ctx->to_hibernate);
if (ctx->manual_cork) {
/* we're coming from idle_callback instead of a normal
I/O handler, so we'll have to do corking manually */
o_stream_cork(client->output);
}
if (ctx->sync_ctx != NULL) {
if (imap_sync_more(ctx->sync_ctx) == 0) {
/* unfinished */
if (ctx->manual_cork) {
ctx->manual_cork = FALSE;
o_stream_uncork(client->output);
}
cmd->state = CLIENT_COMMAND_STATE_WAIT_OUTPUT;
return FALSE;
}
if (imap_sync_deinit(ctx->sync_ctx, ctx->cmd) < 0) {
client_send_untagged_storage_error(client,
mailbox_get_storage(client->mailbox));
mailbox_notify_changes_stop(client->mailbox);
}
ctx->sync_ctx = NULL;
}
if (client->output->offset != orig_offset &&
ctx->keepalive_to != NULL)
idle_add_keepalive_timeout(ctx);
if (ctx->sync_pending) {
/* more changes occurred while we were sending changes to
client */
idle_sync_now(client->mailbox, ctx);
/* NOTE: this recurses back to this function,
so we return here instead of doing everything twice. */
return FALSE;
}
if (ctx->to_hibernate == NULL)
idle_add_hibernate_timeout(ctx);
cmd->state = CLIENT_COMMAND_STATE_WAIT_INPUT;
if (ctx->manual_cork) {
ctx->manual_cork = FALSE;
o_stream_uncork(client->output);
}
if (client->output->closed) {
idle_finish(ctx, FALSE, FALSE);
return TRUE;
}
if (client->io == NULL) {
/* input is pending */
client->io = io_add_istream(client->input,
idle_client_input, ctx);
idle_client_input_more(ctx);
}
return FALSE;
}
static void fts_parser_tika_more(struct fts_parser *_parser,
struct message_block *block)
{
struct tika_fts_parser *parser = (struct tika_fts_parser *)_parser;
struct ioloop *prev_ioloop = current_ioloop;
const unsigned char *data;
size_t size;
ssize_t ret;
if (block->size > 0) {
/* first we'll send everything to Tika */
if (!parser->failed &&
http_client_request_send_payload(&parser->http_req,
block->data,
block->size) < 0)
parser->failed = TRUE;
block->size = 0;
return;
}
if (parser->payload == NULL) {
/* read the result from Tika */
if (!parser->failed &&
http_client_request_finish_payload(&parser->http_req) < 0)
parser->failed = TRUE;
if (!parser->failed && parser->payload == NULL)
http_client_wait(tika_http_client);
if (parser->failed)
return;
i_assert(parser->payload != NULL);
}
/* continue returning data from Tika. we'll create a new ioloop just
for reading this one payload. */
while ((ret = i_stream_read_data(parser->payload, &data, &size, 0)) == 0) {
if (parser->failed)
break;
/* wait for more input from Tika */
if (parser->ioloop == NULL) {
parser->ioloop = io_loop_create();
parser->io = io_add_istream(parser->payload, io_loop_stop,
current_ioloop);
} else {
io_loop_set_current(parser->ioloop);
}
io_loop_run(current_ioloop);
}
/* switch back to original ioloop. */
io_loop_set_current(prev_ioloop);
if (parser->failed)
;
else if (size > 0) {
i_assert(ret > 0);
block->data = data;
block->size = size;
i_stream_skip(parser->payload, size);
} else {
/* finished */
i_assert(ret == -1);
if (parser->payload->stream_errno != 0) {
i_error("read(%s) failed: %s",
i_stream_get_name(parser->payload),
i_stream_get_error(parser->payload));
parser->failed = TRUE;
}
}
}