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);
}
struct login_connection *
login_connection_init(struct director *dir, int fd,
struct auth_connection *auth,
enum login_connection_type type)
{
struct login_connection *conn;
conn = i_new(struct login_connection, 1);
conn->refcount = 1;
conn->fd = fd;
conn->dir = dir;
conn->output = o_stream_create_fd(conn->fd, (size_t)-1, FALSE);
o_stream_set_no_error_handling(conn->output, TRUE);
if (type != LOGIN_CONNECTION_TYPE_AUTHREPLY) {
i_assert(auth != NULL);
conn->auth = auth;
conn->io = io_add(conn->fd, IO_READ,
login_connection_input, conn);
auth_connection_set_callback(conn->auth, auth_input_line, conn);
} else {
i_assert(auth == NULL);
conn->input = i_stream_create_fd(conn->fd, IO_BLOCK_SIZE, FALSE);
conn->io = io_add(conn->fd, IO_READ,
login_connection_authreply_input, conn);
o_stream_nsend_str(conn->output, t_strdup_printf(
"VERSION\tdirector-authreply-server\t%d\t%d\n",
AUTHREPLY_PROTOCOL_MAJOR_VERSION,
AUTHREPLY_PROTOCOL_MINOR_VERSION));
}
conn->type = type;
DLLIST_PREPEND(&login_connections, conn);
return conn;
}
void mail_index_view_clone(struct mail_index_view *dest,
const struct mail_index_view *src)
{
memset(dest, 0, sizeof(*dest));
dest->refcount = 1;
dest->v = src->v;
dest->index = src->index;
if (src->log_view != NULL) {
dest->log_view =
mail_transaction_log_view_open(src->index->log);
}
dest->indexid = src->indexid;
dest->inconsistency_id = src->inconsistency_id;
dest->map = src->map;
if (dest->map != NULL)
dest->map->refcount++;
dest->log_file_expunge_seq = src->log_file_expunge_seq;
dest->log_file_expunge_offset = src->log_file_expunge_offset;
dest->log_file_head_seq = src->log_file_head_seq;
dest->log_file_head_offset = src->log_file_head_offset;
i_array_init(&dest->module_contexts,
I_MIN(5, mail_index_module_register.id));
DLLIST_PREPEND(&dest->index->views, dest);
}
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;
}
static void
http_client_request_add(struct http_client_request *req)
{
struct http_client *client = req->client;
DLLIST_PREPEND(&client->requests_list, req);
client->requests_count++;
req->listed = TRUE;
}
struct notify_context *
notify_register(const struct notify_vfuncs *v)
{
struct notify_context *ctx;
ctx = i_new(struct notify_context, 1);
ctx->v = *v;
DLLIST_PREPEND(&ctx_list, ctx);
return ctx;
}
enum io_notify_result
io_add_notify(const char *path, const char *source_filename,
unsigned int source_linenum,
io_callback_t *callback, void *context, struct io **io_r)
{
struct ioloop_notify_handler_context *ctx =
current_ioloop->notify_handler_context;
struct kevent ev;
struct io_notify *io;
int fd;
if (ctx == NULL)
ctx = io_loop_notify_handler_init();
fd = open(path, O_RDONLY);
if (fd == -1) {
/* ESTALE could happen with NFS. Don't bother giving an error
message then. */
if (errno != ENOENT && errno != ESTALE)
i_error("open(%s) for kq notify failed: %m", path);
return IO_NOTIFY_NOTFOUND;
}
fd_close_on_exec(fd, TRUE);
io = i_new(struct io_notify, 1);
io->io.condition = IO_NOTIFY;
io->io.source_filename = source_filename;
io->io.source_linenum = source_linenum;
io->io.callback = callback;
io->io.context = context;
io->io.ioloop = current_ioloop;
io->refcount = 1;
io->fd = fd;
/* EV_CLEAR flag is needed because the EVFILT_VNODE filter reports
event state transitions and not the current state. With this flag,
the same event is only returned once. */
MY_EV_SET(&ev, fd, EVFILT_VNODE, EV_ADD | EV_CLEAR,
NOTE_DELETE | NOTE_RENAME | NOTE_WRITE | NOTE_EXTEND |
NOTE_REVOKE, 0, io);
if (kevent(ctx->kq, &ev, 1, NULL, 0, NULL) < 0) {
i_error("kevent(%d, %s) for notify failed: %m", fd, path);
i_close_fd(&fd);
i_free(io);
return IO_NOTIFY_NOSUPPORT;
}
if (ctx->event_io == NULL) {
ctx->event_io = io_add(ctx->kq, IO_READ, event_callback,
io->io.ioloop->notify_handler_context);
}
DLLIST_PREPEND(&ctx->notifies, io);
*io_r = &io->io;
return IO_NOTIFY_ADDED;
}
struct fifo_input_connection *fifo_input_connection_create(int fd)
{
struct fifo_input_connection *conn;
conn = i_new(struct fifo_input_connection, 1);
conn->fd = fd;
conn->input = i_stream_create_fd(fd, MAX_INBUF_SIZE, FALSE);
conn->io = io_add(fd, IO_READ, fifo_input_connection_input, conn);
DLLIST_PREPEND(&fifo_conns, conn);
return conn;
}
static unsigned int login_proxy_delay_disconnect(struct login_proxy *proxy)
{
struct login_proxy_record *rec = proxy->state_rec;
const unsigned int max_delay =
proxy->client->set->login_proxy_max_disconnect_delay;
struct timeval disconnect_time_offset;
unsigned int max_disconnects_per_sec, delay_msecs_since_ts, max_conns;
int delay_msecs;
if (rec->num_disconnects_since_ts == 0) {
rec->disconnect_timestamp = ioloop_timeval;
/* start from a slightly random timestamp. this way all proxy
processes will disconnect at slightly different times to
spread the load. */
timeval_add_msecs(&rec->disconnect_timestamp,
rand() % PROXY_DISCONNECT_INTERVAL_MSECS);
}
rec->num_disconnects_since_ts++;
if (proxy->to != NULL) {
/* we were already lazily disconnecting this */
return 0;
}
if (max_delay == 0) {
/* delaying is disabled */
return 0;
}
max_conns = rec->num_proxying_connections + rec->num_disconnects_since_ts;
max_disconnects_per_sec = (max_conns + max_delay-1) / max_delay;
if (rec->num_disconnects_since_ts <= max_disconnects_per_sec &&
rec->num_delayed_client_disconnects == 0) {
/* wait delaying until we have 1 second's worth of clients
disconnected */
return 0;
}
/* see at which time we should be disconnecting the client.
do it in 100ms intervals so the timeouts are triggered together. */
disconnect_time_offset = rec->disconnect_timestamp;
delay_msecs_since_ts = PROXY_DISCONNECT_INTERVAL_MSECS *
(max_delay * rec->num_disconnects_since_ts *
(1000/PROXY_DISCONNECT_INTERVAL_MSECS) / max_conns);
timeval_add_msecs(&disconnect_time_offset, delay_msecs_since_ts);
delay_msecs = timeval_diff_msecs(&disconnect_time_offset, &ioloop_timeval);
if (delay_msecs <= 0) {
/* we already reached the time */
return 0;
}
rec->num_delayed_client_disconnects++;
proxy->delayed_disconnect = TRUE;
proxy->to = timeout_add(delay_msecs, login_proxy_free_final, proxy);
DLLIST_PREPEND(&login_proxies_disconnecting, proxy);
return delay_msecs;
}
struct config_connection *config_connection_create(int fd)
{
struct config_connection *conn;
conn = i_new(struct config_connection, 1);
conn->fd = fd;
conn->input = i_stream_create_fd(fd, MAX_INBUF_SIZE, FALSE);
conn->output = o_stream_create_fd(fd, (size_t)-1, FALSE);
conn->io = io_add(fd, IO_READ, config_connection_input, conn);
DLLIST_PREPEND(&config_connections, conn);
return conn;
}
void connection_init_client_unix(struct connection_list *list,
struct connection *conn, const char *path)
{
i_assert(list->set.client);
conn->fd_in = conn->fd_out = -1;
conn->list = list;
conn->name = i_strdup(path);
DLLIST_PREPEND(&list->connections, conn);
list->connections_count++;
}
struct client *
client_create(int fd, bool ssl, pool_t pool,
const struct login_settings *set,
const struct master_service_ssl_settings *ssl_set,
void **other_sets,
const struct ip_addr *local_ip, const struct ip_addr *remote_ip)
{
struct client *client;
i_assert(fd != -1);
client = login_binary->client_vfuncs->alloc(pool);
client->v = *login_binary->client_vfuncs;
if (client->v.auth_send_challenge == NULL)
client->v.auth_send_challenge = client_auth_send_challenge;
if (client->v.auth_parse_response == NULL)
client->v.auth_parse_response = client_auth_parse_response;
client->created = ioloop_time;
client->refcount = 1;
client->pool = pool;
client->set = set;
client->ssl_set = ssl_set;
client->real_local_ip = client->local_ip = *local_ip;
client->real_remote_ip = client->ip = *remote_ip;
client->fd = fd;
client->tls = ssl;
client->trusted = client_is_trusted(client);
client->secured = ssl || client->trusted ||
net_ip_compare(remote_ip, local_ip);
client->proxy_ttl = LOGIN_PROXY_TTL;
if (last_client == NULL)
last_client = client;
DLLIST_PREPEND(&clients, client);
clients_count++;
client->to_disconnect =
timeout_add(CLIENT_LOGIN_TIMEOUT_MSECS,
client_idle_disconnect_timeout, client);
client_open_streams(client);
client->v.create(client, other_sets);
if (auth_client_is_connected(auth_client))
client_notify_auth_ready(client);
else
client_set_auth_waiting(client);
login_refresh_proctitle();
return client;
}
void notify_contexts_mail_transaction_begin(struct mailbox_transaction_context *t)
{
struct notify_context *ctx;
struct notify_mail_txn *mail_txn;
for (ctx = ctx_list; ctx != NULL; ctx = ctx->next) {
mail_txn = i_new(struct notify_mail_txn, 1);
mail_txn->parent_mailbox_txn = t;
mail_txn->txn = ctx->v.mail_transaction_begin == NULL ? NULL :
ctx->v.mail_transaction_begin(t);
DLLIST_PREPEND(&ctx->mail_txn_list, mail_txn);
}
}
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;
p_array_init(&cmd->module_contexts, cmd->pool, 5);
DLLIST_PREPEND(&client->command_queue, cmd);
client->command_queue_size++;
return cmd;
}
int login_proxy_new(struct client *client,
const struct login_proxy_settings *set,
proxy_callback_t *callback)
{
struct login_proxy *proxy;
i_assert(client->login_proxy == NULL);
if (set->host == NULL || *set->host == '\0') {
i_error("proxy(%s): host not given", client->virtual_user);
return -1;
}
if (client->proxy_ttl <= 1) {
i_error("proxy(%s): TTL reached zero - "
"proxies appear to be looping?", client->virtual_user);
return -1;
}
proxy = i_new(struct login_proxy, 1);
proxy->client = client;
proxy->client_fd = -1;
proxy->server_fd = -1;
proxy->created = ioloop_timeval;
proxy->ip = set->ip;
proxy->source_ip = set->source_ip;
proxy->host = i_strdup(set->host);
proxy->port = set->port;
proxy->connect_timeout_msecs = set->connect_timeout_msecs;
proxy->notify_refresh_secs = set->notify_refresh_secs;
proxy->ssl_flags = set->ssl_flags;
proxy->state_rec = login_proxy_state_get(proxy_state, &proxy->ip,
proxy->port);
client_ref(client);
if (set->ip.family == 0 &&
net_addr2ip(set->host, &proxy->ip) < 0) {
i_error("proxy(%s): BUG: host %s is not an IP "
"(auth should have changed it)",
client->virtual_user, set->host);
} else {
if (login_proxy_connect(proxy) < 0)
return -1;
}
DLLIST_PREPEND(&login_proxies_pending, proxy);
proxy->callback = callback;
client->login_proxy = proxy;
return 0;
}
int login_proxy_new(struct client *client,
const struct login_proxy_settings *set,
proxy_callback_t *callback)
{
struct login_proxy *proxy;
i_assert(client->login_proxy == NULL);
if (set->host == NULL || *set->host == '\0') {
client_log_err(client, t_strdup_printf(
"proxy(%s): host not given", client->virtual_user));
return -1;
}
if (client->proxy_ttl <= 1) {
client_log_err(client, t_strdup_printf(
"proxy(%s): TTL reached zero - "
"proxies appear to be looping?", client->virtual_user));
return -1;
}
proxy = i_new(struct login_proxy, 1);
proxy->client = client;
proxy->client_fd = -1;
proxy->server_fd = -1;
proxy->created = ioloop_timeval;
proxy->ip = set->ip;
proxy->source_ip = set->source_ip;
proxy->host = i_strdup(set->host);
proxy->port = set->port;
proxy->connect_timeout_msecs = set->connect_timeout_msecs;
proxy->notify_refresh_secs = set->notify_refresh_secs;
proxy->ssl_flags = set->ssl_flags;
proxy->state_rec = login_proxy_state_get(proxy_state, &proxy->ip,
proxy->port);
client_ref(client);
if (login_proxy_connect(proxy) < 0) {
login_proxy_free(&proxy);
return -1;
}
DLLIST_PREPEND(&login_proxies_pending, proxy);
proxy->callback = callback;
client->login_proxy = proxy;
return 0;
}
void connection_init_client_ip(struct connection_list *list,
struct connection *conn,
const struct ip_addr *ip, unsigned int port)
{
i_assert(list->set.client);
conn->fd_in = conn->fd_out = -1;
conn->list = list;
conn->name = i_strdup_printf("%s:%u", net_ip2addr(ip), port);
conn->ip = *ip;
conn->port = port;
DLLIST_PREPEND(&list->connections, conn);
list->connections_count++;
}
void connection_init_server(struct connection_list *list,
struct connection *conn, const char *name,
int fd_in, int fd_out)
{
i_assert(name != NULL);
i_assert(!list->set.client);
conn->list = list;
conn->name = i_strdup(name);
conn->fd_in = fd_in;
conn->fd_out = fd_out;
connection_init_streams(conn);
DLLIST_PREPEND(&list->connections, conn);
list->connections_count++;
}
struct auth_postfix_connection *
auth_postfix_connection_create(struct auth *auth, int fd)
{
struct auth_postfix_connection *conn;
conn = i_new(struct auth_postfix_connection, 1);
conn->refcount = 1;
conn->fd = fd;
conn->auth = auth;
conn->input = i_stream_create_fd(fd, MAX_INBUF_SIZE, FALSE);
conn->output = o_stream_create_fd(fd, (size_t)-1, FALSE);
o_stream_set_no_error_handling(conn->output, TRUE);
conn->io = io_add(fd, IO_READ, postfix_input, conn);
DLLIST_PREPEND(&auth_postfix_connections, conn);
return conn;
}
struct client *client_create(int fd)
{
struct client *client;
client = i_new(struct client, 1);
client->fd = fd;
client->io = io_add(fd, IO_READ, client_input, client);
client->input = i_stream_create_fd(fd, MAX_INBUF_SIZE, FALSE);
client->output = o_stream_create_fd(fd, (size_t)-1, FALSE);
o_stream_set_no_error_handling(client->output, TRUE);
o_stream_set_flush_callback(client->output, client_output, client);
client->cmd_pool = pool_alloconly_create("cmd pool", 1024);
DLLIST_PREPEND(&clients, client);
return client;
}
void notify_connection_create(int fd, bool fifo)
{
struct notify_connection *conn;
conn = i_new(struct notify_connection, 1);
conn->refcount = 1;
conn->fd = fd;
conn->io = io_add(fd, IO_READ, notify_input, conn);
conn->input = i_stream_create_fd(fd, MAX_INBUF_SIZE, FALSE);
if (!fifo) {
conn->output = o_stream_create_fd(fd, (size_t)-1, FALSE);
o_stream_set_no_error_handling(conn->output, TRUE);
}
DLLIST_PREPEND(&conns, conn);
}
static struct client *
client_create_standalone(const char *access_user,
const char *const *access_applications,
int fd_in, int fd_out, bool debug)
{
struct client *client;
/* always use nonblocking I/O */
net_set_nonblock(fd_in, TRUE);
net_set_nonblock(fd_out, TRUE);
client = i_new(struct client, 1);
i_array_init(&client->access_apps, 16);
client->fd_in = fd_in;
client->fd_out = fd_out;
client->fd_ctrl = -1;
if (access_user != NULL && *access_user != '\0')
client->access_user = i_strdup(access_user);
else {
client->access_user = i_strdup("anonymous");
client->access_anonymous = TRUE;
}
if (access_applications != NULL) {
const char *const *apps = access_applications;
for (; *apps != NULL; apps++) {
char *app = i_strdup(*apps);
array_append(&client->access_apps, &app, 1);
}
}
client->debug = debug;
client->input = i_stream_create_fd(fd_in, MAX_INBUF_SIZE, FALSE);
client->output = o_stream_create_fd(fd_out, (size_t)-1, FALSE);
client->io = io_add(fd_in, IO_READ, client_input, client);
client->to_idle = timeout_add(CLIENT_IDLE_TIMEOUT_MSECS,
client_idle_timeout, client);
o_stream_set_flush_callback(client->output, client_output, client);
imap_urlauth_worker_client_count++;
DLLIST_PREPEND(&imap_urlauth_worker_clients, client);
i_set_failure_prefix("imap-urlauth[%s](%s): ",
my_pid, client->access_user);
return client;
}
static struct mailbox_transaction_context *
stats_transaction_begin(struct mailbox *box,
enum mailbox_transaction_flags flags)
{
struct stats_user *suser = STATS_USER_CONTEXT(box->storage->user);
struct stats_mailbox *sbox = STATS_CONTEXT(box);
struct mailbox_transaction_context *trans;
struct stats_transaction_context *strans;
trans = sbox->module_ctx.super.transaction_begin(box, flags);
trans->stats_track = TRUE;
strans = i_new(struct stats_transaction_context, 1);
strans->trans = trans;
DLLIST_PREPEND(&suser->transactions, strans);
MODULE_CONTEXT_SET(trans, stats_storage_module, strans);
return trans;
}
void auth_client_connection_create(struct auth *auth, int fd,
bool login_requests, bool token_auth)
{
static unsigned int connect_uid_counter = 0;
struct auth_client_connection *conn;
const char *mechanisms;
string_t *str;
conn = i_new(struct auth_client_connection, 1);
conn->auth = auth;
conn->refcount = 1;
conn->connect_uid = ++connect_uid_counter;
conn->login_requests = login_requests;
conn->token_auth = token_auth;
random_fill(conn->cookie, sizeof(conn->cookie));
conn->fd = fd;
conn->input = i_stream_create_fd(fd, AUTH_CLIENT_MAX_LINE_LENGTH);
conn->output = o_stream_create_fd(fd, (size_t)-1);
o_stream_set_no_error_handling(conn->output, TRUE);
o_stream_set_flush_callback(conn->output, auth_client_output, conn);
conn->io = io_add(fd, IO_READ, auth_client_input, conn);
DLLIST_PREPEND(&auth_client_connections, conn);
if (token_auth) {
mechanisms = t_strconcat("MECH\t",
mech_dovecot_token.mech_name, "\n", NULL);
} else {
mechanisms = str_c(auth->reg->handshake);
}
str = t_str_new(128);
str_printfa(str, "VERSION\t%u\t%u\n%sSPID\t%s\nCUID\t%u\nCOOKIE\t",
AUTH_CLIENT_PROTOCOL_MAJOR_VERSION,
AUTH_CLIENT_PROTOCOL_MINOR_VERSION,
mechanisms, my_pid, conn->connect_uid);
binary_to_hex_append(str, conn->cookie, sizeof(conn->cookie));
str_append(str, "\nDONE\n");
if (o_stream_send(conn->output, str_data(str), str_len(str)) < 0)
auth_client_disconnected(&conn);
}
struct notify_connection *
notify_connection_create(int fd, struct replicator_queue *queue)
{
struct notify_connection *conn;
i_assert(fd >= 0);
conn = i_new(struct notify_connection, 1);
conn->refcount = 1;
conn->queue = queue;
conn->fd = fd;
conn->input = i_stream_create_fd(fd, MAX_INBUF_SIZE, FALSE);
conn->output = o_stream_create_fd(fd, (size_t)-1, FALSE);
o_stream_set_no_error_handling(conn->output, TRUE);
conn->io = io_add(fd, IO_READ, notify_connection_input, conn);
conn->queue = queue;
DLLIST_PREPEND(&connections, conn);
return conn;
}
struct login_connection *
login_connection_init(struct director *dir, int fd,
struct auth_connection *auth, bool userdb)
{
struct login_connection *conn;
conn = i_new(struct login_connection, 1);
conn->refcount = 1;
conn->fd = fd;
conn->auth = auth;
conn->dir = dir;
conn->output = o_stream_create_fd(conn->fd, (size_t)-1, FALSE);
o_stream_set_no_error_handling(conn->output, TRUE);
conn->io = io_add(conn->fd, IO_READ, login_connection_input, conn);
conn->userdb = userdb;
auth_connection_set_callback(conn->auth, auth_input_line, conn);
DLLIST_PREPEND(&login_connections, conn);
return conn;
}
static struct client *client_create(int fd)
{
struct client *client;
/* always use nonblocking I/O */
net_set_nonblock(fd, TRUE);
client = i_new(struct client, 1);
i_array_init(&client->access_apps, 16);
client->fd_in = -1;
client->fd_out = -1;
client->fd_ctrl = fd;
client->access_anonymous = TRUE; /* default until overridden */
client->ctrl_io = io_add(fd, IO_READ, client_ctrl_input, client);
client->to_idle = timeout_add(CLIENT_IDLE_TIMEOUT_MSECS,
client_idle_timeout, client);
imap_urlauth_worker_client_count++;
DLLIST_PREPEND(&imap_urlauth_worker_clients, client);
imap_urlauth_worker_refresh_proctitle();
return 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 submission_settings *set,
const char *helo,
const unsigned char *pdata, unsigned int pdata_len)
{
const struct mail_storage_settings *mail_set;
struct smtp_server_settings smtp_set;
const char *ident;
struct client *client;
/* always use nonblocking I/O */
net_set_nonblock(fd_in, TRUE);
net_set_nonblock(fd_out, TRUE);
client = i_new(struct client, 1);
client->user = user;
client->service_user = service_user;
client->set = set;
client->session_id = i_strdup(session_id);
i_zero(&smtp_set);
smtp_set.hostname = set->hostname;
smtp_set.login_greeting = set->login_greeting;
smtp_set.max_recipients = set->submission_max_recipients;
smtp_set.max_client_idle_time_msecs = CLIENT_IDLE_TIMEOUT_MSECS;
smtp_set.debug = user->mail_debug;
client->conn = smtp_server_connection_create(smtp_server,
fd_in, fd_out, user->conn.remote_ip, user->conn.remote_port,
FALSE, &smtp_set, &smtp_callbacks, client);
client_proxy_create(client, set);
smtp_server_connection_login(client->conn,
client->user->username, helo,
pdata, pdata_len, user->conn.ssl_secured);
smtp_server_connection_start_pending(client->conn);
mail_set = mail_user_set_get_storage_set(user);
if (*set->imap_urlauth_host != '\0' &&
*mail_set->mail_attribute_dict != '\0') {
/* Enable BURL capability only when urlauth dict is
configured correctly */
client_init_urlauth(client);
}
submission_client_count++;
DLLIST_PREPEND(&submission_clients, client);
ident = mail_user_get_anvil_userip_ident(client->user);
if (ident != NULL) {
master_service_anvil_send(master_service, t_strconcat(
"CONNECT\t", my_pid, "\tsubmission/",
ident, "\n", NULL));
client->anvil_sent = TRUE;
}
if (hook_client_created != NULL)
hook_client_created(&client);
submission_refresh_proctitle();
return client;
}
struct service_process *service_process_create(struct service *service)
{
static unsigned int uid_counter = 0;
struct service_process *process;
unsigned int uid = ++uid_counter;
const char *hostdomain;
pid_t pid;
bool process_forked;
i_assert(service->status_fd[0] != -1);
if (service->to_throttle != NULL) {
/* throttling service, don't create new processes */
return NULL;
}
if (service->list->destroying) {
/* these services are being destroyed, no point in creating
new processes now */
return NULL;
}
/* look this up before fork()ing so that it gets cached for all the
future lookups. */
hostdomain = my_hostdomain();
if (service->type == SERVICE_TYPE_ANVIL &&
service_anvil_global->pid != 0) {
pid = service_anvil_global->pid;
uid = service_anvil_global->uid;
process_forked = FALSE;
} else {
pid = fork();
process_forked = TRUE;
service->list->fork_counter++;
}
if (pid < 0) {
service_error(service, "fork() failed: %m");
return NULL;
}
if (pid == 0) {
/* child */
service_process_setup_environment(service, uid, hostdomain);
service_reopen_inet_listeners(service);
service_dup_fds(service);
drop_privileges(service);
process_exec(service->executable, NULL);
}
i_assert(hash_table_lookup(service_pids, POINTER_CAST(pid)) == NULL);
process = i_new(struct service_process, 1);
process->service = service;
process->refcount = 1;
process->pid = pid;
process->uid = uid;
if (process_forked) {
process->to_status =
timeout_add(SERVICE_FIRST_STATUS_TIMEOUT_SECS * 1000,
service_process_status_timeout, process);
}
process->available_count = service->client_limit;
service->process_count++;
service->process_avail++;
DLLIST_PREPEND(&service->processes, process);
service_list_ref(service->list);
hash_table_insert(service_pids, POINTER_CAST(process->pid), process);
if (service->type == SERVICE_TYPE_ANVIL && process_forked)
service_anvil_process_created(process);
return process;
}
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;
}