Lines Matching refs:user
20 #include "mail-user.h"
39 "Invalid user settings. Refer to server log for more information."
101 struct mail_storage_service_user *user,
118 struct mail_storage_service_user *user,
121 struct setting_parser_context *set_parser = user->set_parser;
125 if (mail_user_set_get_mail_debug(user->user_info,
126 user->user_set)) {
140 struct mail_storage_service_user *user,
143 struct setting_parser_context *set_parser = user->set_parser;
149 mail_debug = mail_user_set_get_mail_debug(user->user_info,
150 user->user_set);
230 struct mail_storage_service_user *user,
245 user->uid_source = "userdb lookup";
246 set_keyval(ctx, user, "mail_uid", dec2str(reply->uid));
249 user->gid_source = "userdb lookup";
250 set_keyval(ctx, user, "mail_gid", dec2str(reply->gid));
254 *user->user_set->valid_chroot_dirs != '\0' &&
263 set_keyval(ctx, user, "mail_home", home);
266 if (!validate_chroot(user->user_set, chroot)) {
272 set_keyval(ctx, user, "mail_chroot", chroot);
275 user->anonymous = reply->anonymous;
281 user->system_groups_user =
282 p_strdup(user->pool, line + 19);
284 user->chdir_path = p_strdup(user->pool, line+6);
297 user->auth_token = p_strdup(user->pool, line+11);
299 user->auth_user = p_strdup(user->pool, line+10);
301 user->admin = line[6] == 'y' || line[6] == 'Y' ||
304 ret = set_line(ctx, user, line);
312 str[i], settings_parser_get_error(user->set_parser));
320 pool_t pool, const char **user,
337 ret = auth_master_user_lookup(ctx->conn, *user, &info, pool,
340 if (strcmp(*user, new_username) != 0) {
343 *user = t_strdup(new_username);
345 *user = new_username;
347 *error_r = "Unknown user";
369 *error_r = t_strconcat("Unknown UNIX UID user: ", str, NULL);
399 struct mail_storage_service_user *user,
411 if (user == NULL || user->auth_user == NULL) {
416 auth_user = user->auth_user;
417 auth_username = t_strcut(user->auth_user, '@');
418 auth_domain = i_strchr_to_next(user->auth_user, '@');
422 { 'u', input->username, "user" },
458 struct mail_storage_service_user *user,
473 ret = mail_storage_service_var_expand(ctx, value, str + 1, user,
474 &user->input, priv, error_r);
481 struct mail_storage_service_user *user,
485 const struct mail_user_settings *set = user->user_set;
494 user->uid_source);
503 dec2str(uid), user->uid_source);
508 priv_r->uid_source = user->uid_source;
513 user->gid_source);
522 dec2str(gid), user->gid_source);
527 priv_r->gid_source = user->gid_source;
531 if (!user_expand_varstr(ctx, user, priv_r, user->user_set->mail_home,
535 user->user_set->mail_home, error);
538 if (!user_expand_varstr(ctx, user, priv_r, user->user_set->mail_chroot,
542 user->user_set->mail_chroot, error);
558 service_drop_privileges(struct mail_storage_service_user *user,
563 const struct mail_user_settings *set = user->user_set;
604 rset.system_groups_user = user->system_groups_user;
611 "can't un-chroot for this user";
658 struct mail_storage_service_user *user,
670 conn_data.local_ip = &user->input.local_ip;
671 conn_data.remote_ip = &user->input.remote_ip;
672 conn_data.local_port = user->input.local_port;
673 conn_data.remote_port = user->input.remote_port;
674 conn_data.secured = user->input.conn_secured;
675 conn_data.ssl_secured = user->input.conn_ssl_secured;
677 /* NOTE: if more user initialization is added, add it also to
679 mail_user = mail_user_alloc_nodup_set(user->event, user->input.username,
680 user->user_info, user->user_set);
681 mail_user->_service_user = user;
682 mail_storage_service_user_ref(user);
687 mail_user->anonymous = user->anonymous;
688 mail_user->admin = user->admin;
689 mail_user->auth_token = p_strdup(mail_user->pool, user->auth_token);
690 mail_user->auth_user = p_strdup(mail_user->pool, user->auth_user);
691 if (user->input.session_create_time != 0) {
693 user->input.session_create_time;
698 if (user->session_id_counter++ == 0) {
700 p_strdup(mail_user->pool, user->input.session_id);
704 user->input.session_id,
705 user->session_id_counter);
710 user->input.session_id,
712 event_add_str(user->event, "session", mail_user->session_id);
714 mail_user->userdb_fields = user->input.userdb_fields == NULL ? NULL :
715 p_strarray_dup(mail_user->pool, user->input.userdb_fields);
729 if ((user->flags & MAIL_STORAGE_SERVICE_FLAG_TEMP_PRIV_DROP) != 0 &&
730 (user->flags & MAIL_STORAGE_SERVICE_FLAG_ENABLE_CORE_DUMPS) == 0) {
734 } else if ((user->flags & MAIL_STORAGE_SERVICE_FLAG_NO_CHDIR) == 0) {
742 const char *chdir_path = user->chdir_path != NULL ?
743 user->chdir_path : home;
766 if ((user->flags & MAIL_STORAGE_SERVICE_FLAG_NO_NAMESPACES) == 0) {
777 void mail_storage_service_io_activate_user(struct mail_storage_service_user *user)
779 io_loop_context_activate(user->ioloop_ctx);
782 void mail_storage_service_io_deactivate_user(struct mail_storage_service_user *user)
784 io_loop_context_deactivate(user->ioloop_ctx);
788 mail_storage_service_io_activate_user_cb(struct mail_storage_service_user *user)
790 event_push_global(user->event);
791 if (array_is_created(&user->event_stack)) {
796 events = array_get(&user->event_stack, &count);
799 array_clear(&user->event_stack);
801 if (user->log_prefix != NULL)
802 i_set_failure_prefix("%s", user->log_prefix);
806 mail_storage_service_io_deactivate_user_cb(struct mail_storage_service_user *user)
813 these global events back when the user's context is activated
814 again. (We'll assert-crash if the user is freed before these
816 while ((event = event_get_global()) != user->event) {
818 if (!array_is_created(&user->event_stack))
819 i_array_init(&user->event_stack, 4);
820 array_append(&user->event_stack, &event, 1);
823 event_pop_global(user->event);
824 if (user->log_prefix != NULL)
825 i_set_failure_prefix("%s", user->service_ctx->default_log_prefix);
865 struct mail_storage_service_user *user = context;
868 user == NULL ? NULL : user->input.userdb_fields);
875 struct mail_storage_service_user *user,
885 get_var_expand_table(ctx->service, user, input, priv),
886 func_table, user, error_r);
891 struct mail_storage_service_user *user,
902 user->user_set->mail_log_prefix,
903 user, &user->input, priv, &error);
904 user->log_prefix = p_strdup(user->pool, str_c(str));
907 master_service_init_log(ctx->service, user->log_prefix);
909 event_replace_log_prefix(user->event, user->log_prefix);
912 i_set_failure_send_prefix(user->log_prefix);
966 /* service { user } isn't root. the permission drop can't be
1187 struct mail_storage_service_user *user,
1196 user, input, priv, &error);
1227 struct mail_storage_service_user *user;
1238 user_pool = pool_alloconly_create(MEMPOOL_GROWING"mail storage service user", 1024*6);
1306 user = p_new(user_pool, struct mail_storage_service_user, 1);
1307 user->refcount = 1;
1308 user->service_ctx = ctx;
1309 user->pool = user_pool;
1310 user->input = *input;
1311 user->input.userdb_fields = userdb_fields == NULL ? NULL :
1313 user->input.username = p_strdup(user_pool, username);
1314 user->input.session_id = p_strdup(user_pool, input->session_id);
1315 if (user->input.session_id == NULL) {
1316 user->input.session_id =
1320 user->input.session_create_time = input->session_create_time;
1321 user->user_info = user_info;
1322 user->flags = flags;
1324 user->set_parser = settings_parser_dup(set_parser, user_pool);
1327 user->set_parser);
1328 user->user_set = sets[0];
1329 user->gid_source = "mail_gid setting";
1330 user->uid_source = "mail_uid setting";
1334 user->event = event_create(input->parent_event);
1335 event_add_fields(user->event, (const struct event_add_field []){
1336 { .key = "user", .value = user->input.username },
1338 { .key = "session", .value = user->input.session_id },
1341 if (user->input.local_ip.family != 0) {
1342 event_add_str(user->event, "local_ip",
1343 net_ip2addr(&user->input.local_ip));
1345 if (user->input.local_port != 0) {
1346 event_add_int(user->event, "local_port",
1347 user->input.local_port);
1349 if (user->input.remote_ip.family != 0) {
1350 event_add_str(user->event, "remote_ip",
1351 net_ip2addr(&user->input.remote_ip));
1353 if (user->input.remote_port != 0) {
1354 event_add_int(user->event, "remote_port",
1355 user->input.remote_port);
1359 (void)settings_parse_line(user->set_parser, "mail_debug=yes");
1364 set_keyval(ctx, user, "mail_home", home);
1370 if (user_reply_handle(ctx, user, &reply, &error) < 0) {
1376 if (ret > 0 && !settings_parser_check(user->set_parser, user_pool, &error)) {
1383 /* load per-user plugins */
1386 user->user_set,
1402 (void)settings_parse_line(user->set_parser, "mail_plugins=");
1405 *user_r = user;
1419 /* no user yet. log prefix should be just "imap:" or something
1433 /* we might be here because we're doing a user lookup for a
1434 shared user. the log prefix is likely already usable, so
1461 struct mail_storage_service_user *user,
1470 (user->flags & MAIL_STORAGE_SERVICE_FLAG_ALLOW_ROOT) != 0;
1472 (user->flags & MAIL_STORAGE_SERVICE_FLAG_TEMP_PRIV_DROP) != 0;
1475 if (service_parse_privileges(ctx, user, &priv, error_r) < 0)
1503 set_keyval(ctx, user, "mail_home", priv.home);
1504 set_keyval(ctx, user, "mail_chroot", priv.chroot);
1514 set_keyval(ctx, user, "mail_home", priv.home);
1519 user->ioloop_ctx = io_loop_context_new(current_ioloop);
1520 io_loop_context_add_callbacks(user->ioloop_ctx,
1523 user);
1525 if ((user->flags & MAIL_STORAGE_SERVICE_FLAG_NO_LOG_INIT) == 0)
1526 mail_storage_service_init_log(ctx, user, &priv);
1528 if ((user->flags & MAIL_STORAGE_SERVICE_FLAG_NO_RESTRICT_ACCESS) == 0) {
1529 if (service_drop_privileges(user, &priv,
1537 (user->flags & MAIL_STORAGE_SERVICE_FLAG_ENABLE_CORE_DUMPS) != 0)
1545 if (mail_storage_service_init_post(ctx, user, &priv,
1553 struct mail_storage_service_user *user,
1558 user,
1565 struct mail_storage_service_user *user,
1573 mail_storage_service_set_log_prefix(ctx, user->user_set, user,
1574 &user->input, NULL);
1576 ret = mail_storage_service_next_real(ctx, user,
1579 if ((user->flags & MAIL_STORAGE_SERVICE_FLAG_NO_LOG_INIT) != 0)
1586 struct mail_storage_service_user *user)
1591 if (service_parse_privileges(ctx, user, &priv, &error) < 0)
1592 i_fatal("user %s: %s", user->input.username, error);
1593 if (service_drop_privileges(user, &priv,
1595 i_fatal("user %s: %s", user->input.username, error);
1604 struct mail_storage_service_user *user;
1607 ret = mail_storage_service_lookup(ctx, input, &user, error_r);
1611 ret = mail_storage_service_next(ctx, user, mail_user_r, error_r);
1613 mail_storage_service_user_unref(&user);
1616 *user_r = user;
1620 void mail_storage_service_user_ref(struct mail_storage_service_user *user)
1622 i_assert(user->refcount > 0);
1623 user->refcount++;
1628 struct mail_storage_service_user *user = *_user;
1632 i_assert(user->refcount > 0);
1633 if (--user->refcount > 0)
1636 if (user->ioloop_ctx != NULL) {
1637 if (io_loop_get_current_context(current_ioloop) == user->ioloop_ctx)
1638 mail_storage_service_io_deactivate_user(user);
1639 io_loop_context_remove_callbacks(user->ioloop_ctx,
1641 mail_storage_service_io_deactivate_user_cb, user);
1642 io_loop_context_unref(&user->ioloop_ctx);
1645 if (array_is_created(&user->event_stack)) {
1646 i_assert(array_count(&user->event_stack) == 0);
1647 array_free(&user->event_stack);
1649 settings_parser_deinit(&user->set_parser);
1650 event_unref(&user->event);
1651 pool_unref(&user->pool);
1742 void **mail_storage_service_user_get_set(struct mail_storage_service_user *user)
1745 user->set_parser);
1749 mail_storage_service_user_get_mail_set(struct mail_storage_service_user *user)
1752 user->user_info, user->user_set,
1757 mail_storage_service_user_get_input(struct mail_storage_service_user *user)
1759 return &user->input;
1763 mail_storage_service_user_get_settings_parser(struct mail_storage_service_user *user)
1765 return user->set_parser;
1769 mail_storage_service_user_get_service_ctx(struct mail_storage_service_user *user)
1771 return user->service_ctx;
1774 pool_t mail_storage_service_user_get_pool(struct mail_storage_service_user *user)
1776 return user->pool;
1790 int mail_storage_service_user_set_setting(struct mail_storage_service_user *user,
1795 int ret = settings_parse_keyvalue(user->set_parser, key, value);
1796 *error_r = settings_parser_get_error(user->set_parser);