static bool
master_input_cache_flush(struct auth_master_connection *conn, const char *args)
{
const char *const *list;
unsigned int count;
/* <id> [<user> [<user> [..]] */
list = t_strsplit_tabescaped(args);
if (list[0] == NULL) {
i_error("BUG: doveadm sent broken CACHE-FLUSH");
return FALSE;
}
if (passdb_cache == NULL) {
/* cache disabled */
count = 0;
} else if (list[1] == NULL) {
/* flush the whole cache */
count = auth_cache_clear(passdb_cache);
} else {
count = auth_cache_clear_users(passdb_cache, list+1);
}
(void)o_stream_send_str(conn->output,
t_strdup_printf("OK\t%s\t%u\n", list[0], count));
return TRUE;
}
static int
auth_server_connection_input_line(struct auth_server_connection *conn,
const char *line)
{
const char *const *args;
if (conn->client->debug)
i_debug("auth input: %s", line);
args = t_strsplit_tabescaped(line);
if (args[0] == NULL) {
i_error("Auth server sent empty line");
return -1;
}
if (strcmp(args[0], "OK") == 0)
return auth_server_input_ok(conn, args + 1);
else if (strcmp(args[0], "CONT") == 0)
return auth_server_input_cont(conn, args + 1);
else if (strcmp(args[0], "FAIL") == 0)
return auth_server_input_fail(conn, args + 1);
else if (strcmp(args[0], "MECH") == 0)
return auth_server_input_mech(conn, args + 1);
else if (strcmp(args[0], "SPID") == 0)
return auth_server_input_spid(conn, args + 1);
else if (strcmp(args[0], "CUID") == 0)
return auth_server_input_cuid(conn, args + 1);
else if (strcmp(args[0], "COOKIE") == 0)
return auth_server_input_cookie(conn, args + 1);
else if (strcmp(args[0], "DONE") == 0)
return auth_server_input_done(conn);
else {
i_error("Auth server sent unknown command: %s", args[0]);
return -1;
}
}
static int
imap_master_client_input_line(struct connection *conn, const char *line)
{
char *const *args;
pool_t pool;
int fd_client, ret;
if (!conn->version_received) {
if (connection_verify_version(conn, t_strsplit_tabescaped(line)) < 0)
return -1;
conn->version_received = TRUE;
return 1;
}
fd_client = i_stream_unix_get_read_fd(conn->input);
if (fd_client == -1) {
i_error("imap-master: IMAP client fd not received");
return -1;
}
if (imap_debug)
i_debug("imap-master: Client input: %s", line);
pool = pool_alloconly_create("imap master client cmd", 1024);
args = p_strsplit_tabescaped(pool, line);
ret = imap_master_client_input_args(conn, (void *)args, fd_client, pool);
pool_unref(&pool);
return ret;
}
static bool
master_login_auth_input_fail(struct master_login_auth *auth,
const char *args_line)
{
struct master_login_auth_request *request;
const char *const *args, *error = NULL;
unsigned int i, id;
args = t_strsplit_tabescaped(args_line);
if (args[0] == NULL || str_to_uint(args[0], &id) < 0) {
i_error("Auth server sent broken FAIL line");
return FALSE;
}
for (i = 1; args[i] != NULL; i++) {
if (strncmp(args[i], "reason=", 7) == 0)
error = args[i] + 7;
}
request = master_login_auth_lookup_request(auth, id);
if (request != NULL) {
if (error == NULL) {
request_internal_failure(request,
"Internal auth failure");
} else {
i_error("Internal auth failure: %s "
"(client-pid=%u client-id=%u)",
error, request->client_pid, request->auth_id);
request->callback(NULL, error, request->context);
}
i_free(request);
}
return TRUE;
}
static void cmd_proxy_list_callback(enum ipc_client_cmd_state state,
const char *data, void *context)
{
bool *seen_header = context;
switch (state) {
case IPC_CLIENT_CMD_STATE_REPLY: {
const char *const *args = t_strsplit_tabescaped(data);
if (!*seen_header) {
cmd_proxy_list_header(args);
*seen_header = TRUE;
} else {
for (; *args != NULL; args++)
doveadm_print(*args);
}
return;
}
case IPC_CLIENT_CMD_STATE_OK:
break;
case IPC_CLIENT_CMD_STATE_ERROR:
i_error("LIST-FULL failed: %s", data);
break;
}
io_loop_stop(current_ioloop);
}
static bool client_handle_input(struct client *client)
{
const char *line, *cmd, *error;
int ret;
if (client->url != NULL || client->to_delay != NULL) {
/* we're still processing a URL. wait until it's
finished. */
io_remove(&client->io);
client->io = NULL;
client->waiting_input = TRUE;
return TRUE;
}
if (client->io == NULL) {
client->io = io_add(client->fd_in, IO_READ,
client_input, client);
}
client->waiting_input = FALSE;
timeout_reset(client->to_idle);
switch (i_stream_read(client->input)) {
case -1:
/* disconnected */
if (client->ctrl_output != NULL)
(void)o_stream_send_str(client->ctrl_output, "DISCONNECTED\n");
client_destroy(client);
return FALSE;
case -2:
/* line too long, kill it */
client_abort(client, "Session aborted: Input line too long");
return FALSE;
}
while ((line = i_stream_next_line(client->input)) != NULL) {
const char *const *args = t_strsplit_tabescaped(line);
if (args[0] == NULL)
continue;
cmd = args[0]; args++;
if (client->mail_user == NULL)
ret = client_handle_user_command(client, cmd, args, &error);
else
ret = client_handle_command(client, cmd, args, &error);
if (ret <= 0) {
if (ret == 0)
break;
i_error("Client input error: %s", error);
client_abort(client, "Session aborted: Unexpected input");
return FALSE;
}
}
return TRUE;
}
static int
master_input_auth_request(struct auth_master_connection *conn, const char *args,
const char *cmd, struct auth_request **request_r,
const char **error_r)
{
struct auth_request *auth_request;
const char *const *list, *name, *arg, *username;
unsigned int id;
/* <id> <userid> [<parameters>] */
list = t_strsplit_tabescaped(args);
if (list[0] == NULL || list[1] == NULL ||
str_to_uint(list[0], &id) < 0) {
i_error("BUG: Master sent broken %s", cmd);
return -1;
}
auth_request = auth_request_new_dummy();
auth_request->id = id;
auth_request->master = conn;
auth_master_connection_ref(conn);
username = list[1];
for (list += 2; *list != NULL; list++) {
arg = strchr(*list, '=');
if (arg == NULL) {
name = *list;
arg = "";
} else {
name = t_strdup_until(*list, arg);
arg++;
}
(void)auth_request_import_info(auth_request, name, arg);
}
if (auth_request->service == NULL) {
i_error("BUG: Master sent %s request without service", cmd);
auth_request_unref(&auth_request);
auth_master_connection_unref(&conn);
return -1;
}
auth_request_init(auth_request);
if (!auth_request_set_username(auth_request, username, error_r)) {
*request_r = auth_request;
return 0;
}
*request_r = auth_request;
return 1;
}
static int
config_read_reply_header(struct istream *istream, const char *path, pool_t pool,
const struct master_service_settings_input *input,
struct master_service_settings_output *output_r,
const char **error_r)
{
const char *line;
ssize_t ret;
while ((ret = i_stream_read(istream)) > 0) {
line = i_stream_next_line(istream);
if (line != NULL)
break;
}
if (ret <= 0) {
if (ret == 0)
return 1;
*error_r = istream->stream_errno != 0 ?
t_strdup_printf("read(%s) failed: %s", path,
i_stream_get_error(istream)) :
t_strdup_printf("read(%s) failed: EOF", path);
return -1;
}
T_BEGIN {
const char *const *arg = t_strsplit_tabescaped(line);
ARRAY_TYPE(const_string) services;
p_array_init(&services, pool, 8);
for (; *arg != NULL; arg++) {
if (strcmp(*arg, "service-uses-local") == 0)
output_r->service_uses_local = TRUE;
else if (strcmp(*arg, "service-uses-remote") == 0)
output_r->service_uses_remote = TRUE;
if (strcmp(*arg, "used-local") == 0)
output_r->used_local = TRUE;
else if (strcmp(*arg, "used-remote") == 0)
output_r->used_remote = TRUE;
else if (strncmp(*arg, "service=", 8) == 0) {
const char *name = p_strdup(pool, *arg + 8);
array_append(&services, &name, 1);
}
}
if (input->service == NULL) {
array_append_zero(&services);
output_r->specific_services = array_idx(&services, 0);
}
} T_END;
return 0;
}
int connection_input_line_default(struct connection *conn, const char *line)
{
const char *const *args;
args = t_strsplit_tabescaped(line);
if (!conn->version_received) {
if (connection_verify_version(conn, args) < 0)
return -1;
conn->version_received = TRUE;
return 1;
}
return conn->list->v.input_args(conn, args);
}
static enum passdb_result
auth_worker_reply_parse(struct auth_request *request, const char *reply)
{
enum passdb_result ret;
const char *const *args;
args = t_strsplit_tabescaped(reply);
if (strcmp(*args, "OK") == 0 && args[1] != NULL && args[2] != NULL) {
/* OK \t user \t password [\t extra] */
auth_request_set_field(request, "user", args[1], NULL);
auth_worker_reply_parse_args(request, args + 2);
return PASSDB_RESULT_OK;
}
if (strcmp(*args, "NEXT") == 0 && args[1] != NULL) {
/* NEXT \t user [\t extra] */
auth_request_set_field(request, "user", args[1], NULL);
auth_worker_reply_parse_args(request, args + 1);
return PASSDB_RESULT_NEXT;
}
if (strcmp(*args, "FAIL") == 0 && args[1] != NULL) {
int result;
/* FAIL \t result [\t user \t password [\t extra]] */
if (str_to_int(args[1], &result) < 0) {
/* shouldn't happen */
} else {
ret = (enum passdb_result)result;
if (ret == PASSDB_RESULT_OK) {
/* shouldn't happen */
} else if (args[2] == NULL) {
/* internal failure most likely */
return ret;
} else if (args[3] != NULL) {
if (*args[2] != '\0') {
auth_request_set_field(request, "user",
args[2], NULL);
}
auth_worker_reply_parse_args(request, args + 3);
return ret;
}
}
}
auth_request_log_error(request, AUTH_SUBSYS_DB,
"Received invalid reply from worker: %s", reply);
return PASSDB_RESULT_INTERNAL_FAILURE;
}
static int
master_connection_input_line(struct master_connection *conn, const char *line)
{
const char *const *args = t_strsplit_tabescaped(line);
struct mail_storage_service_input input;
struct mail_storage_service_user *service_user;
struct mail_user *user;
const char *str, *error;
unsigned int max_recent_msgs;
int ret;
/* <username> <mailbox> <session ID> <max_recent_msgs> [i][o] */
if (str_array_length(args) != 5 ||
str_to_uint(args[3], &max_recent_msgs) < 0 || args[4][0] == '\0') {
i_error("Invalid input from master: %s", line);
return -1;
}
i_zero(&input);
input.module = "mail";
input.service = "indexer-worker";
input.username = args[0];
/* if session-id is given, use it as a prefix to a unique session ID.
we can't use the session-id directly or stats process will complain
about duplicates. (especially LMTP would use the same session-id for
multiple users' indexing at the same time.) */
if (args[2][0] != '\0')
input.session_id_prefix = args[2];
if (mail_storage_service_lookup_next(conn->storage_service, &input,
&service_user, &user, &error) <= 0) {
i_error("User %s lookup failed: %s", args[0], error);
ret = -1;
} else {
indexer_worker_refresh_proctitle(user->username, args[1], 0, 0);
ret = index_mailbox(conn, user, args[1],
max_recent_msgs, args[4]);
/* refresh proctitle before a potentially long-running
user unref */
indexer_worker_refresh_proctitle(user->username, "(deinit)", 0, 0);
mail_user_unref(&user);
mail_storage_service_user_unref(&service_user);
indexer_worker_refresh_proctitle(NULL, NULL, 0, 0);
}
str = ret < 0 ? "-1\n" : "100\n";
return write_full(conn->fd, str, strlen(str));
}
static bool
master_input_request(struct auth_master_connection *conn, const char *args)
{
struct auth_client_connection *client_conn;
const char *const *list, *const *params;
unsigned int id, client_pid, client_id;
uint8_t cookie[MASTER_AUTH_COOKIE_SIZE];
buffer_t buf;
/* <id> <client-pid> <client-id> <cookie> [<parameters>] */
list = t_strsplit_tabescaped(args);
if (str_array_length(list) < 4 ||
str_to_uint(list[0], &id) < 0 ||
str_to_uint(list[1], &client_pid) < 0 ||
str_to_uint(list[2], &client_id) < 0) {
i_error("BUG: Master sent broken REQUEST");
return FALSE;
}
buffer_create_from_data(&buf, cookie, sizeof(cookie));
if (hex_to_binary(list[3], &buf) < 0) {
i_error("BUG: Master sent broken REQUEST cookie");
return FALSE;
}
params = list + 4;
client_conn = auth_client_connection_lookup(client_pid);
if (client_conn == NULL) {
i_error("Master requested auth for nonexistent client %u",
client_pid);
o_stream_nsend_str(conn->output,
t_strdup_printf("FAIL\t%u\n", id));
} else if (memcmp(client_conn->cookie, cookie, sizeof(cookie)) != 0) {
i_error("Master requested auth for client %u with invalid cookie",
client_pid);
o_stream_nsend_str(conn->output,
t_strdup_printf("FAIL\t%u\n", id));
} else if (!auth_request_handler_master_request(
client_conn->request_handler, conn, id, client_id, params)) {
i_error("Master requested auth for non-login client %u",
client_pid);
o_stream_nsend_str(conn->output,
t_strdup_printf("FAIL\t%u\n", id));
}
return TRUE;
}
static void fifo_input_connection_input(struct fifo_input_connection *conn)
{
const char *line, *const *args, *error;
switch (i_stream_read(conn->input)) {
case -2:
i_error("BUG: Mail server sent too much data");
fifo_input_connection_destroy(&conn);
return;
case -1:
fifo_input_connection_destroy(&conn);
return;
}
while ((line = i_stream_next_line(conn->input)) != NULL) T_BEGIN {
args = t_strsplit_tabescaped(line);
if (fifo_input_connection_request(args, &error) < 0)
i_error("FIFO input error: %s", error);
} T_END;
}
static int
master_connection_input_line(struct master_connection *conn, const char *line)
{
const char *const *args = t_strsplit_tabescaped(line);
struct mail_storage_service_input input;
struct mail_storage_service_user *service_user;
struct mail_user *user;
const char *str, *error;
unsigned int max_recent_msgs;
int ret;
/* <username> <mailbox> <max_recent_msgs> [i][o] */
if (str_array_length(args) != 4 ||
str_to_uint(args[2], &max_recent_msgs) < 0 || args[3][0] == '\0') {
i_error("Invalid input from master: %s", line);
return -1;
}
memset(&input, 0, sizeof(input));
input.module = "mail";
input.service = "indexer-worker";
input.username = args[0];
if (mail_storage_service_lookup_next(conn->storage_service, &input,
&service_user, &user, &error) <= 0) {
i_error("User %s lookup failed: %s", args[0], error);
ret = -1;
} else {
indexer_worker_refresh_proctitle(user->username, args[1], 0, 0);
ret = index_mailbox(conn, user, args[1],
max_recent_msgs, args[3]);
indexer_worker_refresh_proctitle(NULL, NULL, 0, 0);
mail_user_unref(&user);
mail_storage_service_user_free(&service_user);
}
str = ret < 0 ? "-1\n" : "100\n";
return write_full(conn->fd, str, strlen(str));
}
static bool
master_login_auth_input_user(struct master_login_auth *auth, const char *args)
{
struct master_login_auth_request *request;
const char *const *list;
unsigned int id;
/* <id> <userid> [..] */
list = t_strsplit_tabescaped(args);
if (list[0] == NULL || list[1] == NULL ||
str_to_uint(list[0], &id) < 0) {
i_error("Auth server sent corrupted USER line");
return FALSE;
}
request = master_login_auth_lookup_request(auth, id);
if (request != NULL) {
request->callback(list + 1, NULL, request->context);
i_free(request);
}
return TRUE;
}
static int
notify_connection_input_line(struct notify_connection *conn, const char *line)
{
struct notify_sync_request *request;
const char *const *args;
enum replication_priority priority;
unsigned int id;
/* U \t <username> \t <priority> [\t <sync id>] */
args = t_strsplit_tabescaped(line);
if (str_array_length(args) < 2) {
i_error("notify client sent invalid input: %s", line);
return -1;
}
if (strcmp(args[0], "U") != 0) {
i_error("notify client sent unknown command: %s", args[0]);
return -1;
}
if (replication_priority_parse(args[2], &priority) < 0) {
i_error("notify client sent invalid priority: %s", args[2]);
return -1;
}
if (priority != REPLICATION_PRIORITY_SYNC)
(void)replicator_queue_add(conn->queue, args[1], priority);
else if (args[3] == NULL || str_to_uint(args[3], &id) < 0) {
i_error("notify client sent invalid sync id: %s", line);
return -1;
} else {
request = i_new(struct notify_sync_request, 1);
request->conn = conn;
request->id = id;
notify_connection_ref(conn);
replicator_queue_add_sync(conn->queue, args[1],
notify_sync_callback, request);
}
return 0;
}
static int
notify_input_line(struct notify_connection *conn, const char *line)
{
const char *const *args;
enum replication_priority priority;
/* <username> \t <priority> */
args = t_strsplit_tabescaped(line);
if (str_array_length(args) < 2) {
i_error("Client sent invalid input");
return -1;
}
if (replication_priority_parse(args[1], &priority) < 0) {
i_error("Client sent invalid priority: %s", args[1]);
return -1;
}
if (priority != REPLICATION_PRIORITY_SYNC)
replicator_connection_notify(replicator, args[0], priority);
else {
conn->refcount++;
replicator_connection_notify_sync(replicator, args[0], conn);
}
return 0;
}
static int
imap_master_client_parse_input(const char *const *args, pool_t pool,
struct mail_storage_service_input *input_r,
struct imap_master_input *master_input_r,
const char **error_r)
{
const char *key, *value;
unsigned int peer_dev_major = 0, peer_dev_minor = 0;
i_zero(input_r);
i_zero(master_input_r);
master_input_r->client_input = buffer_create_dynamic(pool, 64);
master_input_r->client_output = buffer_create_dynamic(pool, 16);
master_input_r->state = buffer_create_dynamic(pool, 512);
input_r->module = input_r->service = "imap";
/* we never want to do userdb lookup again when restoring the client.
we have the userdb_fields cached already. */
input_r->flags_override_remove = MAIL_STORAGE_SERVICE_FLAG_USERDB_LOOKUP;
if (args[0] == NULL) {
*error_r = "Missing username in input";
return -1;
}
input_r->username = args[0];
for (args++; *args != NULL; args++) {
value = strchr(*args, '=');
if (value != NULL)
key = t_strdup_until(*args, value++);
else {
key = *args;
value = "";
}
if (strcmp(key, "lip") == 0) {
if (net_addr2ip(value, &input_r->local_ip) < 0) {
*error_r = t_strdup_printf(
"Invalid lip value: %s", value);
return -1;
}
} else if (strcmp(key, "rip") == 0) {
if (net_addr2ip(value, &input_r->remote_ip) < 0) {
*error_r = t_strdup_printf(
"Invalid rip value: %s", value);
return -1;
}
} else if (strcmp(key, "peer_dev_major") == 0) {
if (str_to_uint(value, &peer_dev_major) < 0) {
*error_r = t_strdup_printf(
"Invalid peer_dev_major value: %s", value);
return -1;
}
} else if (strcmp(key, "peer_dev_minor") == 0) {
if (str_to_uint(value, &peer_dev_minor) < 0) {
*error_r = t_strdup_printf(
"Invalid peer_dev_minor value: %s", value);
return -1;
}
} else if (strcmp(key, "peer_ino") == 0) {
if (str_to_ino(value, &master_input_r->peer_ino) < 0) {
*error_r = t_strdup_printf(
"Invalid peer_ino value: %s", value);
return -1;
}
} else if (strcmp(key, "session") == 0) {
input_r->session_id = value;
} else if (strcmp(key, "session_created") == 0) {
if (str_to_time(value, &input_r->session_create_time) < 0) {
*error_r = t_strdup_printf(
"Invalid session_created value: %s", value);
return -1;
}
} else if (strcmp(key, "userdb_fields") == 0) {
input_r->userdb_fields =
t_strsplit_tabescaped(value);
} else if (strcmp(key, "client_input") == 0) {
if (base64_decode(value, strlen(value), NULL,
master_input_r->client_input) < 0) {
*error_r = t_strdup_printf(
"Invalid client_input base64 value: %s", value);
return -1;
}
} else if (strcmp(key, "client_output") == 0) {
if (base64_decode(value, strlen(value), NULL,
master_input_r->client_output) < 0) {
*error_r = t_strdup_printf(
"Invalid client_output base64 value: %s", value);
return -1;
}
} else if (strcmp(key, "state") == 0) {
if (base64_decode(value, strlen(value), NULL,
master_input_r->state) < 0) {
*error_r = t_strdup_printf(
"Invalid state base64 value: %s", value);
return -1;
}
} else if (strcmp(key, "tag") == 0) {
master_input_r->tag = t_strdup(value);
} else if (strcmp(key, "bad-done") == 0) {
master_input_r->state_import_bad_idle_done = TRUE;
} else if (strcmp(key, "idle-continue") == 0) {
master_input_r->state_import_idle_continue = TRUE;
}
}
if (peer_dev_major != 0 || peer_dev_minor != 0) {
master_input_r->peer_dev =
makedev(peer_dev_major, peer_dev_minor);
}
return 0;
}
static int
imap_hibernate_client_input_line(struct connection *conn, const char *line)
{
struct imap_hibernate_client *client =
(struct imap_hibernate_client *)conn;
int fd = -1, ret;
if (!conn->version_received) {
if (connection_verify_version(conn, t_strsplit_tabescaped(line)) < 0)
return -1;
conn->version_received = TRUE;
return 1;
}
if (client->imap_client == NULL) {
char *const *args;
pool_t pool;
fd = i_stream_unix_get_read_fd(conn->input);
if (fd == -1) {
i_error("IMAP client fd not received");
return -1;
}
pool = pool_alloconly_create("client cmd", 1024);
args = p_strsplit_tabescaped(pool, line);
ret = imap_hibernate_client_input_args(conn, (void *)args, fd, pool);
if (ret >= 0 && client->debug)
i_debug("Create client with input: %s", line);
pool_unref(&pool);
} else {
fd = i_stream_unix_get_read_fd(conn->input);
if (fd == -1) {
i_error("IMAP notify fd not received (input: %s)", line);
ret = -1;
} else if (line[0] != '\0') {
i_error("Expected empty notify fd line from client, but got: %s", line);
o_stream_send_str(conn->output,
"Expected empty notify fd line");
ret = -1;
} else {
imap_client_add_notify_fd(client->imap_client, fd);
ret = 1;
}
}
if (ret < 0) {
if (client->imap_client != NULL)
imap_client_destroy(&client->imap_client, NULL);
if (fd != -1)
i_close_fd(&fd);
return -1;
} else if (ret == 0) {
/* still need to read another fd */
i_stream_unix_set_read_fd(conn->input);
o_stream_send_str(conn->output, "+\n");
return 1;
} else {
/* finished - always disconnect the hibernate client
afterwards */
o_stream_send_str(conn->output, "+\n");
imap_client_create_finish(client->imap_client);
return -1;
}
}
static void client_ctrl_input(struct client *client)
{
const char *const *args;
const char *line;
int ret;
timeout_reset(client->to_idle);
if (client->fd_in == -1 || client->fd_out == -1) {
if ((ret = client_ctrl_read_fds(client)) <= 0) {
if (ret < 0)
client_abort(client, "FD Transfer failed");
return;
}
}
switch (i_stream_read(client->ctrl_input)) {
case -1:
/* disconnected */
client_destroy(client);
return;
case -2:
/* line too long, kill it */
client_abort(client,
"Control session aborted: Input line too long");
return;
}
if (!client->version_received) {
if ((line = i_stream_next_line(client->ctrl_input)) == NULL)
return;
if (!version_string_verify(line, "imap-urlauth-worker",
IMAP_URLAUTH_WORKER_PROTOCOL_MAJOR_VERSION)) {
i_error("imap-urlauth-worker client not compatible with this server "
"(mixed old and new binaries?) %s", line);
client_abort(client, "Control session aborted: Version mismatch");
return;
}
client->version_received = TRUE;
if (o_stream_send_str(client->ctrl_output, "OK\n") < 0) {
client_destroy(client);
return;
}
}
if (client->access_received) {
client_abort(client, "Control session aborted: Unexpected input");
return;
}
if ((line = i_stream_next_line(client->ctrl_input)) == NULL)
return;
args = t_strsplit_tabescaped(line);
if (*args == NULL || strcmp(*args, "ACCESS") != 0) {
i_error("Invalid control command: %s", str_sanitize(line, 80));
client_abort(client, "Control session aborted: Invalid command");
return;
}
args++;
if (*args == NULL) {
i_error("Invalid ACCESS command: %s", str_sanitize(line, 80));
client_abort(client, "Control session aborted: Invalid command");
return;
}
i_assert(client->access_user == NULL);
if (**args != '\0') {
client->access_user = i_strdup(*args);
client->access_anonymous = FALSE;
} else {
client->access_user = i_strdup("anonymous");
client->access_anonymous = TRUE;
}
i_set_failure_prefix("imap-urlauth[%s](%s): ",
my_pid, client->access_user);
args++;
while (*args != NULL) {
/* debug */
if (strcasecmp(*args, "debug") == 0) {
client->debug = TRUE;
/* apps=<access-application>[,<access-application,...] */
} else if (strncasecmp(*args, "apps=", 5) == 0 &&
(*args)[5] != '\0') {
const char *const *apps = t_strsplit(*args+5, ",");
while (*apps != NULL) {
char *app = i_strdup(*apps);
array_append(&client->access_apps, &app, 1);
if (client->debug) {
i_debug("User %s has URLAUTH %s access",
client->access_user, app);
}
apps++;
}
} else {
i_error("Invalid ACCESS parameter: %s", str_sanitize(*args, 80));
client_abort(client, "Control session aborted: Invalid command");
return;
}
args++;
}
client->access_received = TRUE;
if (o_stream_send_str(client->ctrl_output, "OK\n") < 0) {
client_destroy(client);
return;
}
client->input = i_stream_create_fd(client->fd_in, MAX_INBUF_SIZE, FALSE);
client->output = o_stream_create_fd(client->fd_out, (size_t)-1, FALSE);
client->io = io_add(client->fd_in, IO_READ, client_input, client);
o_stream_set_flush_callback(client->output, client_output, client);
if (client->debug) {
i_debug("Worker activated for access by user %s",
client->access_user);
}
}
