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);
if (client->mailbox != NULL)
mailbox_notify_changes(client->mailbox, idle_callback, ctx);
client_send_line(client, "+ idling");
io_remove(&client->io);
client->io = io_add(i_stream_get_fd(client->input),
IO_READ, 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);
}
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 idle_callback(struct mailbox *box, struct cmd_idle_context *ctx)
{
struct client *client = ctx->client;
if (ctx->sync_ctx != NULL)
ctx->sync_pending = TRUE;
else {
ctx->manual_cork = TRUE;
idle_sync_now(box, ctx);
if (client->disconnected)
client_destroy(client, NULL);
}
}
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->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;
}
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(i_stream_get_fd(client->input),
IO_READ, idle_client_input, ctx);
idle_client_input_more(ctx);
}
return FALSE;
}
