const char *show_field, const char *expand_field)
{
struct mail_storage_service_input service_input;
- struct mail_storage_service_user *service_user;
struct mail_user *user;
const char *error, *const *userdb_fields;
pool_t pool;
&userdb_fields);
if ((ret = mail_storage_service_lookup_next(storage_service, &service_input,
- &service_user, &user,
- &error)) <= 0) {
+ &user, &error)) <= 0) {
pool_unref(&pool);
if (ret < 0)
return -1;
}
mail_user_deinit(&user);
- mail_storage_service_user_unref(&service_user);
pool_unref(&pool);
return 1;
}
struct event *event)
{
struct mail_storage_service_input service_input;
- struct mail_storage_service_user *service_user;
struct mail_user *user;
const char *error, *const *userdb_fields;
pool_t pool;
&userdb_fields);
if ((ret = mail_storage_service_lookup_next(storage_service, &service_input,
- &service_user, &user,
- &error)) <= 0) {
+ &user, &error)) <= 0) {
pool_unref(&pool);
if (ret < 0)
return -1;
}
mail_user_deinit(&user);
- mail_storage_service_user_unref(&service_user);
pool_unref(&pool);
return 1;
}
struct doveadm_mail_cmd_context ctx;
const char *source_username;
- struct mail_storage_service_user *source_service_user;
struct mail_user *source_user;
const char *destname;
mail_storage_service_io_deactivate_user(ctx->ctx.cur_service_user);
if (mail_storage_service_lookup_next(ctx->ctx.storage_service, &input,
- &ctx->source_service_user,
&ctx->source_user,
&error) < 0)
i_fatal("Couldn't lookup user %s: %s", input.username, error);
- mail_storage_service_io_deactivate_user(ctx->source_service_user);
+ mail_storage_service_io_deactivate_user(ctx->source_user->service_user);
mail_storage_service_io_activate_user(ctx->ctx.cur_service_user);
}
struct copy_cmd_context *ctx =
container_of(_ctx, struct copy_cmd_context, ctx);
- if (ctx->source_user != NULL) {
- mail_storage_service_user_unref(&ctx->source_service_user);
+ if (ctx->source_user != NULL)
mail_user_deinit(&ctx->source_user);
- }
}
static struct doveadm_mail_cmd_context *cmd_copy_alloc(void)
static void cmd_import_init_source_user(struct import_cmd_context *ctx, struct mail_user *dest_user)
{
struct mail_storage_service_input input;
- struct mail_storage_service_user *service_user;
struct mail_user *user;
const char *error;
input.flags_override_add = MAIL_STORAGE_SERVICE_FLAG_NO_NAMESPACES |
MAIL_STORAGE_SERVICE_FLAG_NO_RESTRICT_ACCESS;
if (mail_storage_service_lookup_next(ctx->ctx.storage_service, &input,
- &service_user, &user, &error) < 0)
+ &user, &error) < 0)
i_fatal("Import user initialization failed: %s", error);
if (mail_namespaces_init_location(user, ctx->src_location, &error) < 0)
i_fatal("Import namespace initialization failed: %s", error);
ctx->src_user = user;
- mail_storage_service_io_deactivate_user(service_user);
- mail_storage_service_user_unref(&service_user);
+ mail_storage_service_io_deactivate_user(user->service_user);
mail_storage_service_io_activate_user(ctx->ctx.cur_service_user);
}
char *access_user, *access_service;
ARRAY_TYPE(string) access_apps;
- struct mail_storage_service_user *service_user;
struct mail_user *mail_user;
struct imap_urlauth_context *urlauth_ctx;
if (client->fd_ctrl >= 0)
net_disconnect(client->fd_ctrl);
- if (client->service_user != NULL)
- mail_storage_service_user_unref(&client->service_user);
i_free(client->access_user);
i_free(client->access_service);
array_foreach_elem(&client->access_apps, app)
{
struct mail_storage_service_input input;
struct imap_urlauth_worker_settings *set;
- struct mail_storage_service_user *user;
struct imap_urlauth_config config;
struct mail_user *mail_user;
const char *error;
e_debug(client->event, "Looking up user %s", input.username);
ret = mail_storage_service_lookup_next(storage_service, &input,
- &user, &mail_user, &error);
+ &mail_user, &error);
if (ret < 0) {
e_error(client->event,
"Failed to lookup user %s: %s", input.username, error);
imap_urlauth_worker_refresh_proctitle();
}
- client->service_user = user;
client->mail_user = mail_user;
client->set = set;
struct client *client_create(int fd_in, int fd_out, bool unhibernated,
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)
{
client->unhibernated = unhibernated;
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,
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);
void client_kick(struct client *client)
{
- mail_storage_service_io_activate_user(client->service_user);
+ mail_storage_service_io_activate_user(client->user->service_user);
if (client->output_cmd_lock == NULL) {
client_send_line(client,
"* BYE "MASTER_SERVICE_SHUTTING_DOWN_MSG".");
guid_128_t anvil_conn_guid;
pool_t pool;
- struct mail_storage_service_user *service_user;
const struct imap_settings *set;
const struct smtp_submit_settings *smtp_set;
string_t *capability_string;
if the handle is a socket. */
struct client *client_create(int fd_in, int fd_out, bool unhibernated,
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);
void client_create_finish_io(struct client *client);
if (client->output_cmd_lock != NULL)
return;
- mail_storage_service_io_activate_user(client->service_user);
+ mail_storage_service_io_activate_user(client->user->service_user);
client_send_line(client, "* BYE "MASTER_SERVICE_SHUTTING_DOWN_MSG".");
client_destroy(client, MASTER_SERVICE_SHUTTING_DOWN_MSG);
}
struct client **client_r, const char **error_r)
{
struct mail_storage_service_input service_input;
- struct mail_storage_service_user *user;
struct mail_user *mail_user;
struct client *client;
struct imap_settings *imap_set;
service_input = *input;
service_input.event_parent = event;
if (mail_storage_service_lookup_next(storage_service, &service_input,
- &user, &mail_user, error_r) <= 0) {
+ &mail_user, error_r) <= 0) {
event_unref(&event);
return -1;
}
verbose_proctitle = TRUE;
client = client_create(fd_in, fd_out, unhibernated,
- event, mail_user, user, imap_set, smtp_set);
+ event, mail_user, imap_set, smtp_set);
client->userdb_fields = input->userdb_fields == NULL ? NULL :
p_strarray_dup(client->pool, input->userdb_fields);
event_unref(&event);
{
struct client *client;
struct smtp_submit_settings smtp_set;
- struct mail_storage_service_user *service_user;
struct mail_user *mail_user;
struct test_imap_client_hibernate ctx;
const char *error;
test_assert(net_addr2ip("127.0.0.1", &input.local_ip) == 0);
test_assert(net_addr2ip("127.0.0.2", &input.remote_ip) == 0);
test_assert(mail_storage_service_lookup_next(storage_service, &input,
- &service_user, &mail_user, &error) == 1);
+ &mail_user, &error) == 1);
mail_user->set->base_dir = tmpdir;
mail_user->set->mail_log_prefix = EVILSTR"%u";
mail_user->session_id = EVILSTR"session";
struct event *event = event_create(NULL);
int client_fd = dup(dev_null_fd);
- client = client_create(client_fd, client_fd, FALSE, event,
- mail_user, service_user,
+ client = client_create(client_fd, client_fd, FALSE, event, mail_user,
imap_setting_parser_info.defaults, &smtp_set);
ctx.client = client;
unsigned int max_recent_msgs, const char *what)
{
struct mail_storage_service_input input;
- struct mail_storage_service_user *service_user;
struct mail_user *user;
const char *error;
int ret;
input.session_id_prefix = session_id;
if (mail_storage_service_lookup_next(conn->storage_service, &input,
- &service_user, &user, &error) <= 0) {
+ &user, &error) <= 0) {
e_error(conn->conn.event, "User %s lookup failed: %s",
username, error);
return -1;
}
mail_user_deinit(&user);
- mail_storage_service_user_unref(&service_user);
indexer_worker_refresh_proctitle(NULL, NULL, 0, 0);
return ret;
}
const char *user, *errstr, *path;
struct smtp_address *rcpt_to, *final_rcpt_to, *mail_from;
struct mail_storage_service_ctx *storage_service;
- struct mail_storage_service_user *service_user;
struct mail_storage_service_input service_input;
struct event *event;
const char *user_source = "", *rcpt_to_source = "", *mail_from_error;
_lookup() and _next(), but don't bother) */
dinput.delivery_time_started = ioloop_timeval;
ret = mail_storage_service_lookup_next(storage_service,
- &service_input, &service_user,
+ &service_input,
&dinput.rcpt_user,
&errstr);
if (ret <= 0) {
mailbox_free(&box);
mail_user_deinit(&dinput.rcpt_user);
- mail_storage_service_user_unref(&service_user);
}
mail_deliver_session_deinit(&dinput.session);
raw_storage_create_from_set(struct mail_storage_service_ctx *ctx,
struct setting_parser_context *unexpanded_set_parser)
{
- struct mail_storage_service_user *service_user;
struct mail_user *user;
struct mail_namespace *ns;
struct mail_namespace_settings *ns_set;
MAIL_STORAGE_SERVICE_FLAG_NO_PLUGINS |
MAIL_STORAGE_SERVICE_FLAG_NO_NAMESPACES,
};
- if (mail_storage_service_lookup_next(ctx, &input, &service_user,
+ if (mail_storage_service_lookup_next(ctx, &input,
&user, &error) < 0)
i_fatal("Raw user initialization failed: %s", error);
event_unref(&event);
if (old_ioloop_ctx != NULL)
io_loop_context_switch(old_ioloop_ctx);
else
- mail_storage_service_io_deactivate_user(service_user);
- mail_storage_service_user_unref(&service_user);
+ mail_storage_service_io_deactivate_user(user->service_user);
return user;
}
MAIL_STORAGE_SERVICE_FLAG_NO_PLUGINS |
MAIL_STORAGE_SERVICE_FLAG_NO_NAMESPACES,
};
- struct mail_storage_service_user *service_user;
if (mail_storage_service_lookup_next(storage_service, &input,
- &service_user, &owner,
- &error) < 0) {
+ &owner, &error) < 0) {
if (owner != NULL && !owner->nonexistent) {
mailbox_list_set_critical(list,
"Couldn't create namespace '%s' for user %s: %s",
ns->prefix, owner->username, error);
mail_user_deinit(&owner);
- mail_storage_service_user_unref(&service_user);
io_loop_context_switch(old_ioloop_ctx);
return -1;
}
}
- mail_storage_service_user_unref(&service_user);
owner->creator = user;
int ret = shared_mail_user_init(_storage, user, owner, &ns, tab,
int mail_storage_service_lookup_next(struct mail_storage_service_ctx *ctx,
const struct mail_storage_service_input *input,
- struct mail_storage_service_user **user_r,
struct mail_user **mail_user_r,
const char **error_r)
{
+ struct mail_storage_service_user *user;
int ret;
- ret = mail_storage_service_lookup(ctx, input, user_r, error_r);
+ ret = mail_storage_service_lookup(ctx, input, &user, error_r);
if (ret <= 0) {
- *user_r = NULL;
*mail_user_r = NULL;
return ret;
}
- ret = mail_storage_service_next(ctx, *user_r, mail_user_r, error_r);
- if (ret < 0) {
- if (*mail_user_r == NULL)
- mail_storage_service_user_unref(user_r);
- return ret;
- }
- return 1;
+ ret = mail_storage_service_next(ctx, user, mail_user_r, error_r);
+ mail_storage_service_user_unref(&user);
+ return ret < 0 ? -1 : 1;
}
void mail_storage_service_user_ref(struct mail_storage_service_user *user)
/* Combine lookup() and next() into one call. */
int mail_storage_service_lookup_next(struct mail_storage_service_ctx *ctx,
const struct mail_storage_service_input *input,
- struct mail_storage_service_user **user_r,
struct mail_user **mail_user_r,
const char **error_r);
void mail_storage_service_user_ref(struct mail_storage_service_user *user);
};
if (mail_storage_service_lookup_next(ctx->storage_service, &input,
- &ctx->service_user, &ctx->user,
- &error) < 0) {
+ &ctx->user, &error) < 0) {
i_fatal("mail_storage_service_lookup_next(%s) failed: %s",
username, error);
}
void test_mail_storage_deinit_user(struct test_mail_storage_ctx *ctx)
{
mail_user_deinit(&ctx->user);
- mail_storage_service_user_unref(&ctx->service_user);
}
pool_t pool;
struct mail_storage_service_ctx *storage_service;
struct mail_user *user;
- struct mail_storage_service_user *service_user;
struct ioloop *ioloop;
const char *home_root;
};
static int
mcp_user_create(struct mail_user *user, const char *dest_username,
struct mail_user **dest_user_r,
- struct mail_storage_service_user **dest_service_user_r,
const char **error_r)
{
const struct mail_storage_service_input *old_input;
MAIL_STORAGE_SERVICE_FLAG_NO_LOG_INIT;
ret = mail_storage_service_lookup_next(service_ctx, &input,
- dest_service_user_r,
dest_user_r, error_r);
if (ret == 0)
{
const char *error;
struct mail_user *dest_user;
- struct mail_storage_service_user *dest_service_user;
struct ioloop_context *cur_ioloop_ctx;
struct dcrypt_public_key *pkey;
const char *dest_username;
bool disallow_insecure =
mail_user_plugin_getenv_bool(user, MAIL_CRYPT_ACL_SECURE_SHARE_SETTING);
- ret = mcp_user_create(user, target_uid, &dest_user,
- &dest_service_user, &error);
+ ret = mcp_user_create(user, target_uid, &dest_user, &error);
/* to make sure we get correct logging context */
if (ret > 0)
- mail_storage_service_io_deactivate_user(dest_service_user);
+ mail_storage_service_io_deactivate_user(dest_user->service_user);
mail_storage_service_io_activate_user(user->service_user);
if (ret <= 0) {
/* logging context swap again */
mail_storage_service_io_deactivate_user(user->service_user);
- mail_storage_service_io_activate_user(dest_service_user);
+ mail_storage_service_io_activate_user(dest_user->service_user);
mail_user_deinit(&dest_user);
- mail_storage_service_user_unref(&dest_service_user);
if ((cur_ioloop_ctx = io_loop_get_current_context(current_ioloop)) != NULL)
io_loop_context_deactivate(cur_ioloop_ctx);
static int
mail_crypt_acl_user_create(struct mail_user *user, const char *dest_username,
struct mail_user **dest_user_r,
- struct mail_storage_service_user **dest_service_user_r,
const char **error_r)
{
const struct mail_storage_service_input *old_input;
input.flags_override_remove = MAIL_STORAGE_SERVICE_FLAG_NO_NAMESPACES;
ret = mail_storage_service_lookup_next(service_ctx, &input,
- dest_service_user_r,
dest_user_r, error_r);
return ret;
struct event *event = aclobj->backend->event;
const char *username;
struct mail_user *dest_user;
- struct mail_storage_service_user *dest_service_user;
struct ioloop_context *cur_ioloop_ctx;
bool have_rights;
int ret = 0;
have_rights = ret > 0;
ret = mail_crypt_acl_user_create(aclobj->backend->list->ns->user,
- username, &dest_user,
- &dest_service_user, &error);
+ username, &dest_user, &error);
/* to make sure we get correct logging context */
if (ret > 0)
- mail_storage_service_io_deactivate_user(dest_service_user);
+ mail_storage_service_io_deactivate_user(dest_user->service_user);
mail_storage_service_io_activate_user(
aclobj->backend->list->ns->user->service_user
);
mail_storage_service_io_deactivate_user(
aclobj->backend->list->ns->user->service_user
);
- mail_storage_service_io_activate_user(dest_service_user);
+ mail_storage_service_io_activate_user(dest_user->service_user);
mail_user_deinit(&dest_user);
- mail_storage_service_user_unref(&dest_service_user);
if ((cur_ioloop_ctx = io_loop_get_current_context(current_ioloop)) != NULL)
io_loop_context_deactivate(cur_ioloop_ctx);
static void client_handle_request(struct quota_client *client)
{
struct mail_storage_service_input input;
- struct mail_storage_service_user *service_user;
struct mail_user *user;
struct smtp_address *rcpt;
const char *value = NULL, *error;
rcpt, &input.username, &delim,
&detail);
ret = mail_storage_service_lookup_next(storage_service, &input,
- &service_user, &user, &error);
+ &user, &error);
restrict_access_allow_coredumps(TRUE);
if (ret == 0) {
e_debug(client->event, "User `%s' not found", input.username);
}
value = t_strdup(value); /* user's pool is being freed */
mail_user_deinit(&user);
- mail_storage_service_user_unref(&service_user);
} else {
e_error(client->event,
"Failed to lookup user %s: %s", input.username, error);
{
const char *lookup_error_str =
"-ERR [SYS/TEMP] "MAIL_ERRSTR_CRITICAL_MSG"\r\n";
- struct mail_storage_service_user *user;
struct mail_user *mail_user;
struct pop3_settings *set;
service_input.event_parent = event;
if (mail_storage_service_lookup_next(storage_service, &service_input,
- &user, &mail_user, error_r) <= 0) {
+ &mail_user, error_r) <= 0) {
if (write(fd_out, lookup_error_str, strlen(lookup_error_str)) < 0) {
/* ignored */
}
if (set->verbose_proctitle)
verbose_proctitle = TRUE;
- *client_r = client_create(fd_in, fd_out, event, mail_user, user, set);
+ *client_r = client_create(fd_in, fd_out, event, mail_user, set);
event_unref(&event);
return 0;
}
int pop3_lock_session(struct client *client)
{
const struct mail_storage_settings *mail_set =
- mail_storage_service_user_get_mail_set(client->service_user);
+ mail_storage_service_user_get_mail_set(client->user->service_user);
struct dotlock_settings dotlock_set;
enum mailbox_list_path_type type;
const char *dir, *path;
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 pop3_settings *set)
{
struct client *client;
client->pool = pool;
client->event = event;
event_ref(client->event);
- client->service_user = service_user;
client->v = pop3_client_vfuncs;
client->set = set;
client->fd_in = fd_in;
pop3_refresh_proctitle();
mail_user_autoexpunge(client->user);
mail_user_deinit(&client->user);
- mail_storage_service_user_unref(&client->service_user);
pop3_client_count--;
DLLIST_REMOVE(&pop3_clients, client);
void client_kick(struct client *client)
{
- mail_storage_service_io_activate_user(client->service_user);
+ mail_storage_service_io_activate_user(client->user->service_user);
if (client->cmd == NULL) {
client_send_line(client,
"-ERR [SYS/TEMP] "MASTER_SERVICE_SHUTTING_DOWN_MSG".");
void *cmd_context;
pool_t pool;
- struct mail_storage_service_user *service_user;
struct mail_user *user;
struct mail_namespace *inbox_ns;
struct mailbox *mailbox;
if the handle is a socket. */
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 pop3_settings *set);
void client_create_finish(struct client *client);
int client_init_mailbox(struct client *client, const char **error_r);
const char **error_r)
{
struct mail_storage_service_input service_input;
- struct mail_storage_service_user *user;
struct mail_user *mail_user;
struct submission_settings *set;
bool no_greeting = HAS_ALL_BITS(login_flags,
service_input = *input;
service_input.event_parent = event;
if (mail_storage_service_lookup_next(storage_service, &service_input,
- &user, &mail_user, error_r) <= 0) {
+ &mail_user, error_r) <= 0) {
send_error(fd_out, event, my_hostname,
"4.7.0", MAIL_ERRSTR_CRITICAL_MSG);
event_unref(&event);
send_error(fd_out, event, set->hostname,
"4.3.5", MAIL_ERRSTR_CRITICAL_MSG);
mail_user_deinit(&mail_user);
- mail_storage_service_user_unref(&user);
event_unref(&event);
return -1;
}
}
(void)client_create(fd_in, fd_out, event, mail_user,
- user, set, helo, &proxy_data, data, data_len,
+ set, helo, &proxy_data, data, data_len,
no_greeting);
event_unref(&event);
return 0;
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 submission_settings *set, const char *helo,
const struct smtp_proxy_data *proxy_data,
const unsigned char *pdata, unsigned int pdata_len,
client->event = event;
event_ref(client->event);
client->user = user;
- client->service_user = service_user;
client->set = set;
i_array_init(&client->pending_backends, 4);
imap_urlauth_deinit(&client->urlauth_ctx);
mail_user_deinit(&client->user);
- mail_storage_service_user_unref(&client->service_user);
client_state_reset(client);
void client_kick(struct client *client)
{
- mail_storage_service_io_activate_user(client->service_user);
+ mail_storage_service_io_activate_user(client->user->service_user);
client_destroy(&client, "4.3.2", MASTER_SERVICE_SHUTTING_DOWN_MSG);
}
ARRAY(struct submission_recipient *) rcpt_to;
ARRAY(struct submission_backend *) rcpt_backends;
- struct mail_storage_service_user *service_user;
struct mail_user *user;
/* IMAP URLAUTH context (RFC4467) for BURL (RFC4468) */
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 submission_settings *set, const char *helo,
const struct smtp_proxy_data *proxy_data,
const unsigned char *pdata, unsigned int pdata_len,