path: root/src/imap/imap-client.c

/* Copyright (c) 2002-2018 Dovecot authors, see the included COPYING file */

#include "imap-common.h"
#include "ioloop.h"
#include "llist.h"
#include "str.h"
#include "hostpid.h"
#include "net.h"
#include "iostream.h"
#include "iostream-rawlog.h"
#include "istream.h"
#include "istream-concat.h"
#include "ostream.h"
#include "time-util.h"
#include "var-expand.h"
#include "master-service.h"
#include "imap-resp-code.h"
#include "imap-util.h"
#include "imap-urlauth.h"
#include "mail-error.h"
#include "mail-namespace.h"
#include "mail-storage-service.h"
#include "mail-autoexpunge.h"
#include "imap-state.h"
#include "imap-search.h"
#include "imap-notify.h"
#include "imap-commands.h"
#include "imap-feature.h"

#include <unistd.h>

/* If the last command took longer than this to run, log statistics on
   where the time was spent. */
#define IMAP_CLIENT_DISCONNECT_LOG_STATS_CMD_MIN_RUNNING_MSECS 1000

extern struct mail_storage_callbacks mail_storage_callbacks;
extern struct imap_client_vfuncs imap_client_vfuncs;

struct imap_module_register imap_module_register = { 0 };

struct client *imap_clients = NULL;
unsigned int imap_client_count = 0;

unsigned int imap_feature_condstore = UINT_MAX;
unsigned int imap_feature_qresync = UINT_MAX;

static const char *client_command_state_names[CLIENT_COMMAND_STATE_DONE+1] = {
	"wait-input",
	"wait-output",
	"wait-external",
	"wait-unambiguity",
	"wait-sync",
	"done"
};

static void client_idle_timeout(struct client *client)
{
	if (client->output_cmd_lock == NULL)
		client_send_line(client, "* BYE Disconnected for inactivity.");
	client_destroy(client, t_strdup_printf(
		"Inactivity - no input for %"PRIdTIME_T" secs",
		ioloop_time - client->last_input));
}

static void client_init_urlauth(struct client *client)
{
	struct imap_urlauth_config config;

	i_zero(&config);
	config.url_host = client->set->imap_urlauth_host;
	config.url_port = client->set->imap_urlauth_port;
	config.socket_path = t_strconcat(client->user->set->base_dir,
					 "/"IMAP_URLAUTH_SOCKET_NAME, NULL);
	config.session_id = client->user->session_id;
	config.access_user = client->user->username;
	config.access_service = "imap";
	config.access_anonymous = client->user->anonymous;

	client->urlauth_ctx = imap_urlauth_init(client->user, &config);
}

static bool user_has_special_use_mailboxes(struct mail_user *user)
{
	struct mail_namespace_settings *ns_set;

	/*
	 * We have to iterate over namespace and mailbox *settings* since
	 * the namespaces haven't been set up yet.  The namespaces haven't
	 * been set up so that we don't hold up the OK response to LOGIN
	 * when using slow lib-storage backends.
	 */

	/* no namespaces => no special use flags */
	if (!array_is_created(&user->set->namespaces))
		return FALSE;

	array_foreach_elem(&user->set->namespaces, ns_set) {
		struct mailbox_settings *box_set;

		/* no mailboxes => no special use flags */
		if (!array_is_created(&ns_set->mailboxes))
			continue;

		array_foreach_elem(&ns_set->mailboxes, box_set) {
			if (box_set->special_use != NULL)
				return TRUE;
		}
	}

	return FALSE;
}

struct client *client_create(int fd_in, int fd_out,
			     struct event *event, struct mail_user *user,
			     struct mail_storage_service_user *service_user,
			     const struct imap_settings *set,
			     const struct smtp_submit_settings *smtp_set)
{
	const struct mail_storage_settings *mail_set;
	struct client *client;
	const char *ident;
	pool_t pool;

	/* 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->event = event;
	event_ref(client->event);
	client->set = set;
	client->smtp_set = smtp_set;
	client->service_user = service_user;
	client->fd_in = fd_in;
	client->fd_out = fd_out;
	client->input = i_stream_create_fd(fd_in,
					   set->imap_max_line_length);
	client->output = o_stream_create_fd(fd_out, SIZE_MAX);
	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->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;
	p_array_init(&client->enabled_features, client->pool, 8);

	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 != '+') {
		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 (client->set->imap_literal_minus)
		client_add_capability(client, "LITERAL-");
	else
		client_add_capability(client, "LITERAL+");
	if (user->fuzzy_search) {
		/* Enable FUZZY capability only when it actually has
		   a chance of working */
		client_add_capability(client, "SEARCH=FUZZY");
	}

	mail_set = mail_user_set_get_storage_set(user);
	if (mail_set->mailbox_list_index) {
		/* NOTIFY is enabled only when mailbox list indexes are
		   enabled, although even that doesn't necessarily guarantee
		   it always */
		client_add_capability(client, "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);
		client_add_capability(client, "URLAUTH");
		client_add_capability(client, "URLAUTH=BINARY");
	}
	if (set->imap_metadata && *mail_set->mail_attribute_dict != '\0')
		client_add_capability(client, "METADATA");
	if (user_has_special_use_mailboxes(user)) {
		/* Advertise SPECIAL-USE only if there are actually some
		   SPECIAL-USE flags in mailbox configuration. */
		client_add_capability(client, "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;
}

void client_create_finish_io(struct client *client)
{
	if (client->set->rawlog_dir[0] != '\0') {
		(void)iostream_rawlog_create(client->set->rawlog_dir,
					     &client->input, &client->output);
	}
	client->io = io_add_istream(client->input, client_input, client);
}

int client_create_finish(struct client *client, const char **error_r)
{
	if (mail_namespaces_init(client->user, error_r) < 0)
		return -1;
	mail_namespaces_set_storage_callbacks(client->user->namespaces,
					      &mail_storage_callbacks, client);
	client->v.init(client);
	return 0;
}

void client_add_istream_prefix(struct client *client,
			       const unsigned char *data, size_t size)
{
	i_assert(client->io == NULL);

	struct istream *inputs[] = {
		i_stream_create_copy_from_data(data, size),
		client->input,
		NULL
	};
	client->input = i_stream_create_concat(inputs);
	i_stream_copy_fd(client->input, inputs[1]);
	i_stream_unref(&inputs[0]);
	i_stream_unref(&inputs[1]);

	i_stream_set_input_pending(client->input, TRUE);
}

static void client_default_init(struct client *client ATTR_UNUSED)
{
	/* nothing */
}

void client_command_cancel(struct client_command_context **_cmd)
{
	struct client_command_context *cmd = *_cmd;
	bool cmd_ret;

	switch (cmd->state) {
	case CLIENT_COMMAND_STATE_WAIT_INPUT:
		/* a bit kludgy check: cancel command only if it has context
		   set. currently only append command matches this check. all
		   other commands haven't even started the processing yet. */
		if (cmd->context == NULL)
			break;
		/* fall through */
	case CLIENT_COMMAND_STATE_WAIT_EXTERNAL:
	case CLIENT_COMMAND_STATE_WAIT_OUTPUT:
		cmd->cancel = TRUE;
		break;
	case CLIENT_COMMAND_STATE_WAIT_UNAMBIGUITY:
	case CLIENT_COMMAND_STATE_WAIT_SYNC:
		/* commands haven't started yet */
		break;
	case CLIENT_COMMAND_STATE_DONE:
		i_unreached();
	}

	cmd_ret = !cmd->cancel || cmd->func == NULL ? TRUE :
		command_exec(cmd);
	if (!cmd_ret) {
		if (cmd->client->output->closed)
			i_panic("command didn't cancel itself: %s", cmd->name);
	} else {
		client_command_free(*_cmd != NULL ? _cmd : &cmd);
	}
}

const char *client_stats(struct client *client)
{
	const struct var_expand_table logout_tab[] = {
		{ 'i', dec2str(i_stream_get_absolute_offset(client->input)), "input" },
		{ 'o', dec2str(client->output->offset), "output" },
		{ '\0', client->user->session_id, "session" },
		{ '\0', dec2str(client->fetch_hdr_count), "fetch_hdr_count" },
		{ '\0', dec2str(client->fetch_hdr_bytes), "fetch_hdr_bytes" },
		{ '\0', dec2str(client->fetch_body_count), "fetch_body_count" },
		{ '\0', dec2str(client->fetch_body_bytes), "fetch_body_bytes" },
		{ '\0', dec2str(client->deleted_count), "deleted" },
		{ '\0', dec2str(client->expunged_count), "expunged" },
		{ '\0', dec2str(client->trashed_count), "trashed" },
		{ '\0', dec2str(client->autoexpunged_count), "autoexpunged" },
		{ '\0', dec2str(client->append_count), "appended" },
		{ '\0', NULL, NULL }
	};
	const struct var_expand_table *user_tab =
		mail_user_var_expand_table(client->user);
	const struct var_expand_table *tab =
		t_var_expand_merge_tables(logout_tab, user_tab);
	string_t *str;
	const char *error;

	str = t_str_new(128);
	if (var_expand_with_funcs(str, client->set->imap_logout_format,
				  tab, mail_user_var_expand_func_table,
				  client->user, &error) < 0) {
		e_error(client->event,
			"Failed to expand imap_logout_format=%s: %s",
			client->set->imap_logout_format, error);
	}
	return str_c(str);
}

void client_destroy(struct client *client, const char *reason)
{
	client->v.destroy(client, reason);
}

static void
client_command_stats_append(string_t *str,
			    const struct client_command_stats *stats,
			    const char *wait_condition,
			    size_t buffered_size)
{
	uint64_t ioloop_wait_usecs;
	unsigned int msecs_in_ioloop;

	ioloop_wait_usecs = io_loop_get_wait_usecs(current_ioloop);
	msecs_in_ioloop = (ioloop_wait_usecs -
		stats->start_ioloop_wait_usecs + 999) / 1000;
	str_printfa(str, "running for %d.%03d + waiting ",
		    (int)((stats->running_usecs+999)/1000 / 1000),
		    (int)((stats->running_usecs+999)/1000 % 1000));
	if (wait_condition[0] != '\0')
		str_printfa(str, "%s ", wait_condition);
	str_printfa(str, "for %d.%03d secs",
		    msecs_in_ioloop / 1000, msecs_in_ioloop % 1000);
	if (stats->lock_wait_usecs > 0) {
		int lock_wait_msecs = (stats->lock_wait_usecs+999)/1000;
		str_printfa(str, ", %d.%03d in locks",
			    lock_wait_msecs/1000, lock_wait_msecs%1000);
	}
	str_printfa(str, ", %"PRIu64" B in + %"PRIu64,
		    stats->bytes_in, stats->bytes_out);
	if (buffered_size > 0)
		str_printfa(str, "+%zu", buffered_size);
	str_append(str, " B out");
}

static const char *client_get_last_command_status(struct client *client)
{
	if (client->logged_out)
		return "";
	if (client->last_cmd_name == NULL)
		return " (No commands sent)";

	/* client disconnected without sending LOGOUT. if the last command
	   took over 1 second to run, log it. */
	const struct client_command_stats *stats = &client->last_cmd_stats;

	string_t *str = t_str_new(128);
	int last_run_secs = timeval_diff_msecs(&ioloop_timeval,
					       &stats->last_run_timeval);
	str_printfa(str, " (%s finished %d.%03d secs ago",
		    client->last_cmd_name, last_run_secs/1000,
		    last_run_secs%1000);

	if (timeval_diff_msecs(&stats->last_run_timeval, &stats->start_time) >=
	    IMAP_CLIENT_DISCONNECT_LOG_STATS_CMD_MIN_RUNNING_MSECS) {
		str_append(str, " - ");
		client_command_stats_append(str, stats, "", 0);
	}
	str_append_c(str, ')');
	return str_c(str);
}

static const char *client_get_commands_status(struct client *client)
{
	struct client_command_context *cmd, *last_cmd = NULL;
	struct client_command_stats all_stats;
	string_t *str;
	enum io_condition cond;
	const char *cond_str;

	if (client->command_queue == NULL)
		return client_get_last_command_status(client);

	i_zero(&all_stats);
	str = t_str_new(128);
	str_append(str, " (");
	for (cmd = client->command_queue; cmd != NULL; cmd = cmd->next) {
		if (cmd->name == NULL) {
			/* (parts of a) tag were received, but not yet
			   the command name */
			continue;
		}
		str_append(str, cmd->name);
		if (cmd->next != NULL)
			str_append_c(str, ',');
		all_stats.running_usecs += cmd->stats.running_usecs;
		all_stats.lock_wait_usecs += cmd->stats.lock_wait_usecs;
		all_stats.bytes_in += cmd->stats.bytes_in;
		all_stats.bytes_out += cmd->stats.bytes_out;
		last_cmd = cmd;
	}
	if (last_cmd == NULL)
		return client_get_last_command_status(client);

	cond = io_loop_find_fd_conditions(current_ioloop, client->fd_out);
	if ((cond & (IO_READ | IO_WRITE)) == (IO_READ | IO_WRITE))
		cond_str = "input/output";
	else if ((cond & IO_READ) != 0)
		cond_str = "input";
	else if ((cond & IO_WRITE) != 0)
		cond_str = "output";
	else
		cond_str = "nothing";

	all_stats.start_ioloop_wait_usecs =
		last_cmd->stats.start_ioloop_wait_usecs;
	str_append_c(str, ' ');
	client_command_stats_append(str, &all_stats, cond_str,
		o_stream_get_buffer_used_size(client->output));
	str_printfa(str, ", state=%s)",
		    client_command_state_names[last_cmd->state]);
	return str_c(str);
}

static void client_log_disconnect(struct client *client, const char *reason)
{
	e_info(client->event, "Disconnected: %s %s", reason, client_stats(client));
}

static void client_default_destroy(struct client *client, const char *reason)
{
	struct client_command_context *cmd;

	i_assert(!client->destroyed);
	client->destroyed = TRUE;
	client->disconnected = TRUE;

	if (client->disconnect_reason != NULL)
		reason = client->disconnect_reason;
	if (reason == NULL)
		reason = t_strconcat(
			io_stream_get_disconnect_reason(client->input,
							client->output),
			client_get_commands_status(client), NULL);

	i_stream_close(client->input);
	o_stream_close(client->output);

	/* finish off all the queued commands. */
	if (client->output_cmd_lock != NULL)
		client_command_cancel(&client->output_cmd_lock);
	while (client->command_queue != NULL) {
		cmd = client->command_queue;
		client_command_cancel(&cmd);
	}
	/* handle the input_lock command last. it might have been waiting on
	   other queued commands (although we probably should just drop the
	   command at that point since it hasn't started running. but this may
	   change in future). */
	if (client->input_lock != NULL)
		client_command_cancel(&client->input_lock);

	if (client->notify_ctx != NULL)
		imap_notify_deinit(&client->notify_ctx);
	if (client->urlauth_ctx != NULL)
		imap_urlauth_deinit(&client->urlauth_ctx);
	/* Keep mailbox closing close to last, so anything that could
	   potentially have transactions open will close them first. */
	if (client->mailbox != NULL)
		imap_client_close_mailbox(client);
	if (client->anvil_sent) {
		master_service_anvil_send(master_service, t_strconcat(
			"DISCONNECT\t", my_pid, "\timap/",
			mail_user_get_anvil_userip_ident(client->user),
			"\n", NULL));
	}

	if (client->free_parser != NULL)
		imap_parser_unref(&client->free_parser);
	io_remove(&client->io);
	timeout_remove(&client->to_idle_output);
	timeout_remove(&client->to_idle);

	/* i/ostreams are already closed at this stage, so fd can be closed */
	fd_close_maybe_stdio(&client->fd_in, &client->fd_out);

	/* Autoexpunging might run for a long time. Disconnect the client
	   before it starts, and refresh proctitle so it's clear that it's
	   doing autoexpunging. We've also sent DISCONNECT to anvil already,
	   because this is background work and shouldn't really be counted
	   as an active IMAP session for the user.

	   Don't autoexpunge if the client is hibernated - it shouldn't be any
	   different from the non-hibernating IDLE case. For frequent
	   hibernations it could also be doing unnecessarily much work. */
	imap_refresh_proctitle();
	if (!client->hibernated) {
		client->autoexpunged_count = mail_user_autoexpunge(client->user);
		client_log_disconnect(client, reason);
	}
	mail_user_deinit(&client->user);

	/* free the i/ostreams after mail_user_unref(), which could trigger
	   mail_storage_callbacks notifications that write to the ostream. */
	i_stream_destroy(&client->input);
	o_stream_destroy(&client->output);

	if (array_is_created(&client->search_saved_uidset))
		array_free(&client->search_saved_uidset);
	if (array_is_created(&client->search_updates))
		array_free(&client->search_updates);
	pool_unref(&client->command_pool);
	mail_storage_service_user_unref(&client->service_user);

	imap_client_count--;
	DLLIST_REMOVE(&imap_clients, client);

	event_unref(&client->event);
	i_free(client->last_cmd_name);
	pool_unref(&client->pool);

	master_service_client_connection_destroyed(master_service);
	imap_refresh_proctitle();
}

static void client_destroy_timeout(struct client *client)
{
	client_destroy(client, NULL);
}

void client_disconnect(struct client *client, const char *reason)
{
	if (client->disconnected)
		return;

	client->disconnected = TRUE;
	client->disconnect_reason = p_strdup(client->pool, reason);
	/* Finish the ostream. With IMAP COMPRESS this sends the EOF marker. */
	(void)o_stream_finish(client->output);
	o_stream_uncork(client->output);

	i_stream_close(client->input);
	o_stream_close(client->output);

	timeout_remove(&client->to_idle);
	client->to_idle = timeout_add(0, client_destroy_timeout, client);
}

void client_disconnect_with_error(struct client *client,
				  const char *client_error)
{
	client_send_line(client, t_strconcat("* BYE ", client_error, NULL));
	client_disconnect(client, client_error);
}

void client_add_capability(struct client *client, const char *capability)
{
	/* require a single capability at a time (feels cleaner) */
	i_assert(strchr(capability, ' ') == NULL);

	if (client->set->imap_capability[0] != '\0' &&
	    client->set->imap_capability[0] != '+') {
		/* explicit capability - don't change it */
		return;
	}
	str_append_c(client->capability_string, ' ');
	str_append(client->capability_string, capability);
}

void client_send_line(struct client *client, const char *data)
{
	(void)client_send_line_next(client, data);
}

int client_send_line_next(struct client *client, const char *data)
{
	struct const_iovec iov[2];

	if (client->output->closed)
		return -1;

	iov[0].iov_base = data;
	iov[0].iov_len = strlen(data);
	iov[1].iov_base = "\r\n";
	iov[1].iov_len = 2;

	if (o_stream_sendv(client->output, iov, 2) < 0)
		return -1;
	client->last_output = ioloop_time;

	if (o_stream_get_buffer_used_size(client->output) >=
	    CLIENT_OUTPUT_OPTIMAL_SIZE) {
		/* buffer full, try flushing */
		return o_stream_flush(client->output);
	}
	return 1;
}

static void
client_cmd_append_timing_stats(struct client_command_context *cmd,
			       string_t *str)
{
	unsigned int msecs_in_cmd, msecs_in_ioloop;
	uint64_t ioloop_wait_usecs;
	unsigned int msecs_since_cmd;

	if (cmd->stats.start_time.tv_sec == 0)
		return;
	command_stats_flush(cmd);

	ioloop_wait_usecs = io_loop_get_wait_usecs(current_ioloop);
	msecs_in_cmd = (cmd->stats.running_usecs + 999) / 1000;
	msecs_in_ioloop = (ioloop_wait_usecs -
			   cmd->stats.start_ioloop_wait_usecs + 999) / 1000;
	msecs_since_cmd = timeval_diff_msecs(&ioloop_timeval,
					     &cmd->stats.last_run_timeval);

	if (str_data(str)[str_len(str)-1] == '.')
		str_truncate(str, str_len(str)-1);
	str_printfa(str, " (%d.%03d + %d.%03d ",
		    msecs_in_cmd / 1000, msecs_in_cmd % 1000,
		    msecs_in_ioloop / 1000, msecs_in_ioloop % 1000);
	if (msecs_since_cmd > 0) {
		str_printfa(str, "+ %d.%03d ",
			    msecs_since_cmd / 1000, msecs_since_cmd % 1000);
	}
	str_append(str, "secs).");
}

void client_send_tagline(struct client_command_context *cmd, const char *data)
{
	cmd->client->v.send_tagline(cmd, data);
}

static void
client_default_send_tagline(struct client_command_context *cmd, const char *data)
{
	struct client *client = cmd->client;
	const char *tag = cmd->tag;

	if (client->output->closed || cmd->cancel)
		return;

	i_assert(!cmd->tagline_sent);
	cmd->tagline_sent = TRUE;
	cmd->tagline_reply = p_strdup(cmd->pool, data);

	if (tag == NULL || *tag == '\0')
		tag = "*";

	T_BEGIN {
		string_t *str = t_str_new(256);
		str_printfa(str, "%s %s", tag, data);
		client_cmd_append_timing_stats(cmd, str);
		str_append(str, "\r\n");
		o_stream_nsend(client->output, str_data(str), str_len(str));
	} T_END;

	client->last_output = ioloop_time;
}

static int
client_default_sync_notify_more(struct imap_sync_context *ctx ATTR_UNUSED)
{
	return 1;
}

void client_send_command_error(struct client_command_context *cmd,
			       const char *client_error)
{
	struct client *client = cmd->client;
	const char *error, *cmd_name;
	enum imap_parser_error parse_error;

	if (client_error == NULL) {
		client_error = imap_parser_get_error(cmd->parser, &parse_error);
		switch (parse_error) {
		case IMAP_PARSE_ERROR_NONE:
			i_unreached();
		case IMAP_PARSE_ERROR_LITERAL_TOO_BIG:
			client_disconnect_with_error(client, client_error);
			return;
		default:
			break;
		}
	}

	if (cmd->tag == NULL)
		error = t_strconcat("BAD Error in IMAP tag: ", client_error, NULL);
	else if (cmd->name == NULL)
		error = t_strconcat("BAD Error in IMAP command: ", client_error, NULL);
	else {
		cmd_name = t_str_ucase(cmd->name);
		error = t_strconcat("BAD Error in IMAP command ",
				    cmd_name, ": ", client_error, NULL);
	}

	client_send_tagline(cmd, error);

	if (++client->bad_counter >= CLIENT_MAX_BAD_COMMANDS) {
		client_disconnect_with_error(client,
			"Too many invalid IMAP commands.");
	}

	cmd->param_error = TRUE;
	/* client_read_args() failures rely on this being set, so that the
	   command processing is stopped even while command function returns
	   FALSE. */
	cmd->state = CLIENT_COMMAND_STATE_DONE;
}

void client_send_internal_error(struct client_command_context *cmd)
{
	client_send_tagline(cmd,
		t_strflocaltime("NO "MAIL_ERRSTR_CRITICAL_MSG_STAMP, ioloop_time));
}

bool client_read_args(struct client_command_context *cmd, unsigned int count,
		      unsigned int flags, const struct imap_arg **args_r)
{
	int ret;

	i_assert(count <= INT_MAX);

	ret = imap_parser_read_args(cmd->parser, count, flags, args_r);
	if (ret >= (int)count) {
		/* all parameters read successfully */
		i_assert(cmd->client->input_lock == NULL ||
			 cmd->client->input_lock == cmd);

		client_args_finished(cmd, *args_r);
		cmd->client->input_lock = NULL;
		return TRUE;
	} else if (ret == -2) {
		/* need more data */
		if (cmd->client->input->closed) {
			/* disconnected */
			cmd->state = CLIENT_COMMAND_STATE_DONE;
		}
		return FALSE;
	} else {
		/* error, or missing arguments */
		client_send_command_error(cmd, ret < 0 ? NULL :
					  "Missing arguments");
		return FALSE;
	}
}

bool client_read_string_args(struct client_command_context *cmd,
			     unsigned int count, ...)
{
	const struct imap_arg *imap_args;
	va_list va;
	const char *str;
	unsigned int i;

	if (!client_read_args(cmd, count, 0, &imap_args))
		return FALSE;

	va_start(va, count);
	for (i = 0; i < count; i++) {
		const char **ret = va_arg(va, const char **);

		if (IMAP_ARG_IS_EOL(&imap_args[i])) {
			client_send_command_error(cmd, "Missing arguments.");
			break;
		}

		if (!imap_arg_get_astring(&imap_args[i], &str)) {
			client_send_command_error(cmd, "Invalid arguments.");
			break;
		}

		if (ret != NULL)
			*ret = str;
	}
	va_end(va);

	return i == count;
}

void client_args_finished(struct client_command_context *cmd,
			  const struct imap_arg *args)
{
	string_t *str = t_str_new(256);

	if (cmd->args != NULL && cmd->args[0] != '\0') {
		str_append(str, cmd->args);
		str_append_c(str, ' ');
	}
	imap_write_args(str, args);
	cmd->args = p_strdup(cmd->pool, str_c(str));
	event_add_str(cmd->event, "cmd_args", cmd->args);

	str_truncate(str, 0);
	if (cmd->human_args != NULL && cmd->human_args[0] != '\0') {
		str_append(str, cmd->human_args);
		str_append_c(str, ' ');
	}
	imap_write_args_for_human(str, args);
	cmd->human_args = p_strdup(cmd->pool, str_c(str));
	event_add_str(cmd->event, "cmd_human_args", cmd->human_args);
}

static struct client_command_context *
client_command_find_with_flags(struct client_command_context *new_cmd,
			       enum command_flags flags,
			       enum client_command_state max_state)
{
	struct client_command_context *cmd;

	cmd = new_cmd->client->command_queue;
	for (; cmd != NULL; cmd = cmd->next) {
		/* The tagline_sent check is a bit kludgy here. Plugins may
		   hook into sync_notify_more() and send the tagline before
		   finishing the command. During this stage the state was been
		   dropped from _WAIT_SYNC to _WAIT_OUTPUT, so the <= max_state
		   check doesn't work correctly here. (Perhaps we should add
		   a new _WAIT_SYNC_OUTPUT?) */
		if (cmd->state <= max_state && !cmd->tagline_sent &&
		    cmd != new_cmd && (cmd->cmd_flags & flags) != 0)
			return cmd;
	}
	return NULL;
}

static bool client_command_is_ambiguous(struct client_command_context *cmd)
{
	enum command_flags flags;
	enum client_command_state max_state =
		CLIENT_COMMAND_STATE_WAIT_UNAMBIGUITY;
	bool broken_client = FALSE;

	if ((cmd->cmd_flags & COMMAND_FLAG_REQUIRES_SYNC) != 0 &&
	    !imap_sync_is_allowed(cmd->client))
		return TRUE;

	if (cmd->search_save_result_used) {
		/* if there are pending commands that update the search
		   save result, wait */
		struct client_command_context *old_cmd = cmd->next;

		for (; old_cmd != NULL; old_cmd = old_cmd->next) {
			if (old_cmd->search_save_result)
				return TRUE;
		}
	}

	if ((cmd->cmd_flags & COMMAND_FLAG_BREAKS_MAILBOX) ==
	    COMMAND_FLAG_BREAKS_MAILBOX) {
		/* there must be no other command running that uses the
		   selected mailbox */
		flags = COMMAND_FLAG_USES_MAILBOX;
		max_state = CLIENT_COMMAND_STATE_DONE;
	} else if ((cmd->cmd_flags & COMMAND_FLAG_USES_SEQS) != 0) {
		/* no existing command must be breaking sequences */
		flags = COMMAND_FLAG_BREAKS_SEQS;
		broken_client = TRUE;
	} else if ((cmd->cmd_flags & COMMAND_FLAG_BREAKS_SEQS) != 0) {
		/* if existing command uses sequences, we'll have to block */
		flags = COMMAND_FLAG_USES_SEQS;
	} else {
		return FALSE;
	}

	if (client_command_find_with_flags(cmd, flags, max_state) == NULL) {
		if (cmd->client->syncing) {
			/* don't do anything until syncing is finished */
			return TRUE;
		}
		if (cmd->client->mailbox_change_lock != NULL &&
		    cmd->client->mailbox_change_lock != cmd) {
			/* don't do anything until mailbox is fully
			   opened/closed */
			return TRUE;
		}
		return FALSE;
	}

	if (broken_client) {
		client_send_line(cmd->client,
				 "* BAD ["IMAP_RESP_CODE_CLIENTBUG"] "
				 "Command pipelining results in ambiguity.");
	}

	return TRUE;
}

struct client_command_context *client_command_alloc(struct client *client)
{
	struct client_command_context *cmd;

	cmd = p_new(client->command_pool, struct client_command_context, 1);
	cmd->client = client;
	cmd->pool = client->command_pool;
	cmd->global_event = event_create(client->event);
	cmd->event = event_create(cmd->global_event);
	cmd->stats.start_time = ioloop_timeval;
	cmd->stats.last_run_timeval = ioloop_timeval;
	cmd->stats.start_ioloop_wait_usecs =
		io_loop_get_wait_usecs(current_ioloop);
	p_array_init(&cmd->module_contexts, cmd->pool, 5);

	DLLIST_PREPEND(&client->command_queue, cmd);
	client->command_queue_size++;

	imap_client_notify_command_allocated(client);
	return cmd;
}

void client_command_init_finished(struct client_command_context *cmd)
{
	event_add_str(cmd->event, "cmd_tag", cmd->tag);
	/* use "unknown" until we checked that the command name is known/valid */
	event_add_str(cmd->event, "cmd_name", "unknown");
	/* the actual command name received from client - as-is */
	event_add_str(cmd->event, "cmd_input_name", cmd->name);
}

static struct client_command_context *
client_command_new(struct client *client)
{
	struct client_command_context *cmd;

	cmd = client_command_alloc(client);
	if (client->free_parser != NULL) {
		cmd->parser = client->free_parser;
		client->free_parser = NULL;
	} else {
		cmd->parser =
			imap_parser_create(client->input, client->output,
					   client->set->imap_max_line_length);
		if (client->set->imap_literal_minus)
			imap_parser_enable_literal_minus(cmd->parser);
	}
	return cmd;
}

void client_add_missing_io(struct client *client)
{
	if (client->io == NULL && !client->disconnected)
		client->io = io_add_istream(client->input, client_input, client);
}

void client_command_free(struct client_command_context **_cmd)
{
	struct client_command_context *cmd = *_cmd;
	struct client *client = cmd->client;
	enum client_command_state state = cmd->state;

	*_cmd = NULL;

	i_assert(!cmd->executing);
	i_assert(client->output_cmd_lock == NULL);

	/* reset input idle time because command output might have taken a
	   long time and we don't want to disconnect client immediately then */
	client->last_input = ioloop_time;
	timeout_reset(client->to_idle);

	if (cmd->cancel) {
		cmd->cancel = FALSE;
		client_send_tagline(cmd, "NO Command cancelled.");
	}

	i_free(client->last_cmd_name);
	client->last_cmd_name = i_strdup(cmd->name);
	client->last_cmd_stats = cmd->stats;

	if (!cmd->param_error)
		client->bad_counter = 0;

	if (client->input_lock == cmd)
		client->input_lock = NULL;
	if (client->mailbox_change_lock == cmd)
		client->mailbox_change_lock = NULL;

	event_set_name(cmd->event, "imap_command_finished");
	if (cmd->tagline_reply != NULL) {
		event_add_str(cmd->event, "tagged_reply_state",
			      t_strcut(cmd->tagline_reply, ' '));
		event_add_str(cmd->event, "tagged_reply", cmd->tagline_reply);
	}
	event_add_timeval(cmd->event, "last_run_time",
			  &cmd->stats.last_run_timeval);
	event_add_int(cmd->event, "running_usecs", cmd->stats.running_usecs);
	event_add_int(cmd->event, "lock_wait_usecs", cmd->stats.lock_wait_usecs);
	event_add_int(cmd->event, "bytes_in", cmd->stats.bytes_in);
	event_add_int(cmd->event, "bytes_out", cmd->stats.bytes_out);

	e_debug(cmd->event, "Command finished: %s %s", cmd->name,
		cmd->human_args != NULL ? cmd->human_args : "");
	event_unref(&cmd->event);
	event_unref(&cmd->global_event);

	if (cmd->parser != NULL) {
		if (client->free_parser == NULL) {
			imap_parser_reset(cmd->parser);
			client->free_parser = cmd->parser;
		} else {
			imap_parser_unref(&cmd->parser);
		}
	}

	client->command_queue_size--;
	DLLIST_REMOVE(&client->command_queue, cmd);
	cmd = NULL;

	if (client->command_queue == NULL) {
		/* no commands left in the queue, we can clear the pool */
		p_clear(client->command_pool);
		timeout_remove(&client->to_idle_output);
	}
	imap_client_notify_command_freed(client);
	imap_refresh_proctitle();

	/* if command finished from external event, check input for more
	   unhandled commands since we may not be executing from client_input
	   or client_output. */
	if (state == CLIENT_COMMAND_STATE_WAIT_EXTERNAL &&
	    !client->disconnected) {
		client_add_missing_io(client);
		io_set_pending(client->io);
	}
}

static void client_check_command_hangs(struct client *client)
{
	struct client_command_context *cmd;
	unsigned int unfinished_count = 0;
	bool have_wait_unfinished = FALSE;

	for (cmd = client->command_queue; cmd != NULL; cmd = cmd->next) {
		switch (cmd->state) {
		case CLIENT_COMMAND_STATE_WAIT_INPUT:
			/* We need to be reading input for this command.
			   However, if there is already an output lock for
			   another command we'll wait for it to finish first.
			   This is needed because if there are any literals
			   we'd need to send "+ OK" responses. */
			i_assert(client->io != NULL ||
				 (client->output_cmd_lock != NULL &&
				  client->output_cmd_lock != client->input_lock));
			unfinished_count++;
			break;
		case CLIENT_COMMAND_STATE_WAIT_OUTPUT:
			i_assert((io_loop_find_fd_conditions(current_ioloop, client->fd_out) & IO_WRITE) != 0);
			unfinished_count++;
			break;
		case CLIENT_COMMAND_STATE_WAIT_EXTERNAL:
			unfinished_count++;
			break;
		case CLIENT_COMMAND_STATE_WAIT_UNAMBIGUITY:
			have_wait_unfinished = TRUE;
			break;
		case CLIENT_COMMAND_STATE_WAIT_SYNC:
			if ((io_loop_find_fd_conditions(current_ioloop, client->fd_out) & IO_WRITE) == 0)
				have_wait_unfinished = TRUE;
			else {
				/* we have an output callback, which will be
				   called soon and it'll run cmd_sync_delayed().
				   FIXME: is this actually wanted? */
			}
			break;
		case CLIENT_COMMAND_STATE_DONE:
			i_unreached();
		}
	}
	i_assert(!have_wait_unfinished || unfinished_count > 0);
}

static bool client_remove_pending_unambiguity(struct client *client)
{
	if (client->input_lock != NULL) {
		/* there's a command that has locked the input */
		struct client_command_context *cmd = client->input_lock;

		if (cmd->state != CLIENT_COMMAND_STATE_WAIT_UNAMBIGUITY)
			return TRUE;

		/* the command is waiting for existing ambiguity causing
		   commands to finish. */
		if (client_command_is_ambiguous(cmd)) {
			/* we could be waiting for existing sync to finish */
			if (!cmd_sync_delayed(client))
				return FALSE;
			if (client_command_is_ambiguous(cmd))
				return FALSE;
		}
		cmd->state = CLIENT_COMMAND_STATE_WAIT_INPUT;
	}
	return TRUE;
}

void client_continue_pending_input(struct client *client)
{
	i_assert(!client->handling_input);

	if (client->disconnected) {
		client_destroy(client, NULL);
		return;
	}

	/* this function is called at the end of I/O callbacks (and only there).
	   fix up the command states and verify that they're correct. */
	while (client_remove_pending_unambiguity(client)) {
		client_add_missing_io(client);

		/* if there's unread data in buffer, handle it. */
		if (i_stream_get_data_size(client->input) == 0 ||
		    client->disconnected)
			break;

		struct ostream *output = client->output;
		o_stream_ref(output);
		o_stream_cork(output);
		bool ret = client_handle_input(client);
		o_stream_uncork(output);
		o_stream_unref(&output);
		if (!ret)
			break;
	}
	if (client->input->closed || client->output->closed)
		client_destroy(client, NULL);
	else
		client_check_command_hangs(client);
}

/* Skip incoming data until newline is found,
   returns TRUE if newline was found. */
static bool client_skip_line(struct client *client)
{
	const unsigned char *data;
	size_t i, data_size;

	data = i_stream_get_data(client->input, &data_size);

	for (i = 0; i < data_size; i++) {
		if (data[i] == '\n') {
			client->input_skip_line = FALSE;
			i++;
			break;
		}
	}

	i_stream_skip(client->input, i);
	return !client->input_skip_line;
}

static void client_idle_output_timeout(struct client *client)
{
	client_destroy(client, t_strdup_printf(
		"Client has not read server output for for %"PRIdTIME_T" secs",
		ioloop_time - client->last_output));
}

bool client_handle_unfinished_cmd(struct client_command_context *cmd)
{
	if (cmd->state == CLIENT_COMMAND_STATE_WAIT_INPUT) {
		/* need more input */
		return FALSE;
	}
	if (cmd->state != CLIENT_COMMAND_STATE_WAIT_OUTPUT) {
		/* waiting for something */
		if (cmd->state == CLIENT_COMMAND_STATE_WAIT_SYNC) {
			/* this is mainly for APPEND. */
			client_add_missing_io(cmd->client);
		}
		return TRUE;
	}

	/* output is blocking, we can execute more commands */
	o_stream_set_flush_pending(cmd->client->output, TRUE);
	if (cmd->client->to_idle_output == NULL) {
		/* disconnect sooner if client isn't reading our output */
		cmd->client->to_idle_output =
			timeout_add(CLIENT_OUTPUT_TIMEOUT_MSECS,
				    client_idle_output_timeout, cmd->client);
	}
	return TRUE;
}

static void
client_command_failed_early(struct client_command_context **_cmd,
			    const char *error)
{
	struct client_command_context *cmd = *_cmd;

	/* ignore the rest of this line */
	cmd->client->input_skip_line = TRUE;

	io_loop_time_refresh();
	command_stats_start(cmd);
	client_send_command_error(cmd, error);
	cmd->param_error = TRUE;
	client_command_free(_cmd);
}

static bool client_command_input(struct client_command_context *cmd)
{
	struct client *client = cmd->client;
	struct command *command;
	const char *tag, *name;
	int ret;

        if (cmd->func != NULL) {
		/* command is being executed - continue it */
		if (command_exec(cmd)) {
			/* command execution was finished */
			client_command_free(&cmd);
			client_add_missing_io(client);
			return TRUE;
		}

		return client_handle_unfinished_cmd(cmd);
	}

	if (cmd->tag == NULL) {
		ret = imap_parser_read_tag(cmd->parser, &tag);
		if (ret == 0)
			return FALSE; /* need more data */
		if (ret < 0) {
			client_command_failed_early(&cmd, "Invalid tag.");
			return TRUE;
		}
		cmd->tag = p_strdup(cmd->pool, tag);
	}

	if (cmd->name == NULL) {
		ret = imap_parser_read_command_name(cmd->parser, &name);
		if (ret == 0)
			return FALSE; /* need more data */
		if (ret < 0) {
			client_command_failed_early(&cmd, "Invalid command name.");
			return TRUE;
		}

		/* UID commands are a special case. better to handle them
		   here. */
		if (!cmd->uid && strcasecmp(name, "UID") == 0) {
			cmd->uid = TRUE;
			return client_command_input(cmd);
		}
		cmd->name = !cmd->uid ? p_strdup(cmd->pool, name) :
			p_strconcat(cmd->pool, "UID ", name, NULL);
		client_command_init_finished(cmd);
		imap_refresh_proctitle();
	}

	client->input_skip_line = TRUE;

	if (cmd->name[0] == '\0') {
		/* command not given - cmd->func is already NULL. */
	} else if ((command = command_find(cmd->name)) != NULL) {
		cmd->func = command->func;
		cmd->cmd_flags = command->flags;
		/* valid command - overwrite the "unknown" string set earlier */
		event_add_str(cmd->global_event, "cmd_name", command->name);
		event_strlist_append(cmd->global_event, "reason_code",
			event_reason_code_prefix("imap", "cmd_", command->name));
		event_add_str(cmd->event, "cmd_name", command->name);
		if (client_command_is_ambiguous(cmd)) {
			/* do nothing until existing commands are finished */
			i_assert(cmd->state == CLIENT_COMMAND_STATE_WAIT_INPUT);
			cmd->state = CLIENT_COMMAND_STATE_WAIT_UNAMBIGUITY;
			io_remove(&client->io);
			return FALSE;
		}
	}

	if (cmd->func == NULL) {
		/* unknown command */
		client_command_failed_early(&cmd, "Unknown command.");
		return TRUE;
	} else {
		i_assert(!client->disconnected);

		return client_command_input(cmd);
	}
}

static bool client_handle_next_command(struct client *client, bool *remove_io_r)
{
	*remove_io_r = FALSE;

	if (client->input_lock != NULL) {
		if (client->input_lock->state ==
		    CLIENT_COMMAND_STATE_WAIT_UNAMBIGUITY ||
		    /* we can't send literal "+ OK" replies if output is
		       locked by another command. */
		    (client->output_cmd_lock != NULL &&
		     client->output_cmd_lock != client->input_lock)) {
			*remove_io_r = TRUE;
			return FALSE;
		}
		return client_command_input(client->input_lock);
	}

	if (client->input_skip_line) {
		/* first eat the previous command line */
		if (!client_skip_line(client))
			return FALSE;
		client->input_skip_line = FALSE;
	}

	/* don't bother creating a new client command before there's at least
	   some input */
	if (i_stream_get_data_size(client->input) == 0)
		return FALSE;

	/* beginning a new command */
	if (client->command_queue_size >= CLIENT_COMMAND_QUEUE_MAX_SIZE ||
	    client->output_cmd_lock != NULL) {
		/* wait for some of the commands to finish */
		*remove_io_r = TRUE;
		return FALSE;
	}

	client->input_lock = client_command_new(client);
	return client_command_input(client->input_lock);
}

bool client_handle_input(struct client *client)
{
	bool ret, remove_io, handled_commands = FALSE;

	i_assert(o_stream_is_corked(client->output) ||
		 client->output->stream_errno != 0);
	i_assert(!client->disconnected);

	client->handling_input = TRUE;
	do {
		T_BEGIN {
			ret = client_handle_next_command(client, &remove_io);
		} T_END;
		if (ret)
			handled_commands = TRUE;
	} while (ret && !client->disconnected && client->io != NULL);
	client->handling_input = FALSE;

	if (remove_io)
		io_remove(&client->io);
	else
		client_add_missing_io(client);
	if (!handled_commands)
		return FALSE;

	if (client->input_lock == NULL) {
		/* finished handling all commands. sync them all at once now. */
		cmd_sync_delayed(client);
	} else if (client->input_lock->state == CLIENT_COMMAND_STATE_WAIT_UNAMBIGUITY) {
		/* the command may be waiting for previous command to sync. */
		cmd_sync_delayed(client);
	}
	return TRUE;
}

void client_input(struct client *client)
{
	struct client_command_context *cmd;
	struct ostream *output = client->output;
	ssize_t bytes;

	i_assert(client->io != NULL);

	client->last_input = ioloop_time;
	timeout_reset(client->to_idle);

	bytes = i_stream_read(client->input);
	if (bytes == -1) {
		/* disconnected */
		client_destroy(client, NULL);
		return;
	}

	o_stream_ref(output);
	o_stream_cork(output);
	if (!client_handle_input(client) && bytes == -2) {
		/* parameter word is longer than max. input buffer size.
		   this is most likely an error, so skip the new data
		   until newline is found. */
		client->input_skip_line = TRUE;

		cmd = client->input_lock != NULL ? client->input_lock :
			client_command_new(client);
		cmd->param_error = TRUE;
		client_send_command_error(cmd, "Too long argument.");
		client_command_free(&cmd);
	}
	o_stream_uncork(output);
	o_stream_unref(&output);
	imap_refresh_proctitle();

	client_continue_pending_input(client);
}

static void client_output_cmd(struct client_command_context *cmd)
{
	bool finished;

	/* continue processing command */
	finished = command_exec(cmd);

	if (!finished)
		(void)client_handle_unfinished_cmd(cmd);
	else {
		/* command execution was finished */
		client_command_free(&cmd);
	}
}

static void client_output_commands(struct client *client)
{
	struct client_command_context *cmd;

	/* mark all commands non-executed */
	for (cmd = client->command_queue; cmd != NULL; cmd = cmd->next)
		cmd->temp_executed = FALSE;

	if (client->output_cmd_lock != NULL) {
		client->output_cmd_lock->temp_executed = TRUE;
		client_output_cmd(client->output_cmd_lock);
	}
	while (client->output_cmd_lock == NULL) {
		/* go through the entire commands list every time in case
		   multiple commands were freed. temp_executed keeps track of
		   which messages we've called so far */
		cmd = client->command_queue;
		for (; cmd != NULL; cmd = cmd->next) {
			if (!cmd->temp_executed &&
			    cmd->state == CLIENT_COMMAND_STATE_WAIT_OUTPUT) {
				cmd->temp_executed = TRUE;
				client_output_cmd(cmd);
				break;
			}
		}
		if (cmd == NULL) {
			/* all commands executed */
			break;
		}
	}
}

int client_output(struct client *client)
{
	int ret;

	i_assert(!client->destroyed);

	client->last_output = ioloop_time;
	timeout_reset(client->to_idle);
	if (client->to_idle_output != NULL)
		timeout_reset(client->to_idle_output);

	if ((ret = o_stream_flush(client->output)) < 0) {
		client_destroy(client, NULL);
		return 1;
	}

	client_output_commands(client);
	(void)cmd_sync_delayed(client);

	imap_refresh_proctitle_delayed();
	if (client->output->closed)
		client_destroy(client, NULL);
	else {
		/* corking is added automatically by ostream-file. we need to
		   uncork here before client_check_command_hangs() is called,
		   because otherwise it can assert-crash due to ioloop not
		   having IO_WRITE callback set for the ostream. */
		o_stream_uncork(client->output);
		client_continue_pending_input(client);
	}
	return ret;
}

bool client_handle_search_save_ambiguity(struct client_command_context *cmd)
{
	struct client_command_context *old_cmd = cmd->next;

	/* search only commands that were added before this command
	   (commands are prepended to the queue, so they're after ourself) */
	for (; old_cmd != NULL; old_cmd = old_cmd->next) {
		if (old_cmd->search_save_result)
			break;
	}
	if (old_cmd == NULL)
		return FALSE;

	/* ambiguity, wait until it's over */
	i_assert(cmd->state == CLIENT_COMMAND_STATE_WAIT_INPUT);
	cmd->client->input_lock = cmd;
	cmd->state = CLIENT_COMMAND_STATE_WAIT_UNAMBIGUITY;
	cmd->search_save_result_used = TRUE;
	io_remove(&cmd->client->io);
	return TRUE;
}

void client_enable(struct client *client, unsigned int feature_idx)
{
	if (client_has_enabled(client, feature_idx))
		return;

	const struct imap_feature *feat = imap_feature_idx(feature_idx);
	feat->callback(client);
	/* set after the callback, so the callback can see what features were
	   previously set */
	bool value = TRUE;
	array_idx_set(&client->enabled_features, feature_idx, &value);
}

bool client_has_enabled(struct client *client, unsigned int feature_idx)
{
	if (feature_idx >= array_count(&client->enabled_features))
		return FALSE;
	const bool *featurep =
		array_idx(&client->enabled_features, feature_idx);
	return *featurep;
}

static void imap_client_enable_condstore(struct client *client)
{
	struct mailbox_status status;
	int ret;

	if (client->mailbox == NULL)
		return;

	if ((client_enabled_mailbox_features(client) & MAILBOX_FEATURE_CONDSTORE) != 0)
		return;

	ret = mailbox_enable(client->mailbox, MAILBOX_FEATURE_CONDSTORE);
	if (ret == 0) {
		/* CONDSTORE being enabled while mailbox is selected.
		   Notify client of the latest HIGHESTMODSEQ. */
		ret = mailbox_get_status(client->mailbox,
					 STATUS_HIGHESTMODSEQ, &status);
		if (ret == 0) {
			client_send_line(client, t_strdup_printf(
				"* OK [HIGHESTMODSEQ %"PRIu64"] Highest",
				status.highest_modseq));
		}
	}
	if (ret < 0) {
		client_send_untagged_storage_error(client,
			mailbox_get_storage(client->mailbox));
	}
}

static void imap_client_enable_qresync(struct client *client)
{
	/* enable also CONDSTORE */
	client_enable(client, imap_feature_condstore);
}

enum mailbox_feature client_enabled_mailbox_features(struct client *client)
{
	enum mailbox_feature mailbox_features = 0;
	const struct imap_feature *feature;
	const bool *client_enabled;
	unsigned int count;

	client_enabled = array_get(&client->enabled_features, &count);
	for (unsigned int idx = 0; idx < count; idx++) {
		if (client_enabled[idx]) {
			feature = imap_feature_idx(idx);
			mailbox_features |= feature->mailbox_features;
		}
	}
	return mailbox_features;
}

const char *const *client_enabled_features(struct client *client)
{
	ARRAY_TYPE(const_string) feature_strings;
	const struct imap_feature *feature;
	const bool *client_enabled;
	unsigned int count;

	t_array_init(&feature_strings, 8);
	client_enabled = array_get(&client->enabled_features, &count);
	for (unsigned int idx = 0; idx < count; idx++) {
		if (client_enabled[idx]) {
			feature = imap_feature_idx(idx);
			array_push_back(&feature_strings, &feature->feature);
		}
	}
	array_append_zero(&feature_strings);
	return array_front(&feature_strings);
}

struct imap_search_update *
client_search_update_lookup(struct client *client, const char *tag,
			    unsigned int *idx_r)
{
	struct imap_search_update *updates;
	unsigned int i, count;

	if (!array_is_created(&client->search_updates))
		return NULL;

	updates = array_get_modifiable(&client->search_updates, &count);
	for (i = 0; i < count; i++) {
		if (strcmp(updates[i].tag, tag) == 0) {
			*idx_r = i;
			return &updates[i];
		}
	}
	return NULL;
}

void client_search_updates_free(struct client *client)
{
	struct imap_search_update *update;

	if (!array_is_created(&client->search_updates))
		return;

	array_foreach_modifiable(&client->search_updates, update)
		imap_search_update_free(update);
	array_clear(&client->search_updates);
}

void clients_init(void)
{
	imap_feature_condstore =
		imap_feature_register("CONDSTORE", MAILBOX_FEATURE_CONDSTORE,
				      imap_client_enable_condstore);
	imap_feature_qresync =
		imap_feature_register("QRESYNC", MAILBOX_FEATURE_CONDSTORE,
				      imap_client_enable_qresync);
}

void clients_destroy_all(void)
{
	while (imap_clients != NULL) {
		mail_storage_service_io_activate_user(imap_clients->service_user);
		client_send_line(imap_clients, "* BYE Server shutting down.");
		client_destroy(imap_clients, "Server shutting down.");
	}
}

struct imap_client_vfuncs imap_client_vfuncs = {
	.init = client_default_init,
	.destroy = client_default_destroy,

	.send_tagline = client_default_send_tagline,
	.sync_notify_more = client_default_sync_notify_more,

	.state_export = imap_state_export_base,
	.state_import = imap_state_import_base,
};