static void replication_add_users(struct replicator_queue *queue)
{
struct auth_master_connection *auth_conn;
struct auth_master_user_list_ctx *ctx;
struct auth_user_info user_info;
struct replicator_user *user;
const char *path, *username;
auth_conn = auth_master_init(set->auth_socket_path,
AUTH_MASTER_FLAG_NO_IDLE_TIMEOUT);
memset(&user_info, 0, sizeof(user_info));
user_info.service = REPLICATOR_AUTH_SERVICE_NAME;
/* add all users into replication queue, so that we can start doing
full syncs for everyone whose state can't be found */
ctx = auth_master_user_list_init(auth_conn, "", &user_info);
while ((username = auth_master_user_list_next(ctx)) != NULL) {
user = replicator_queue_add(queue, username,
REPLICATION_PRIORITY_NONE);
user->last_update = 0;
}
if (auth_master_user_list_deinit(&ctx) < 0)
i_error("listing users failed, can't replicate existing data");
auth_master_deinit(&auth_conn);
/* add updates from replicator db, if it exists */
path = t_strconcat(service_set->state_dir, "/"REPLICATOR_DB_FNAME, NULL);
(void)replicator_queue_import(queue, path);
}
void replicator_queue_add_auth_users(struct replicator_queue *queue,
const char *auth_socket_path,
const char *usermask, time_t last_update)
{
struct auth_master_connection *auth_conn;
struct auth_master_user_list_ctx *ctx;
struct auth_user_info user_info;
struct replicator_user *user;
const char *username;
auth_conn = auth_master_init(auth_socket_path,
AUTH_MASTER_FLAG_NO_IDLE_TIMEOUT);
memset(&user_info, 0, sizeof(user_info));
user_info.service = REPLICATOR_AUTH_SERVICE_NAME;
/* add all users into replication queue, so that we can start doing
full syncs for everyone whose state can't be found */
ctx = auth_master_user_list_init(auth_conn, usermask, &user_info);
while ((username = auth_master_user_list_next(ctx)) != NULL) {
user = replicator_queue_add(queue, username,
REPLICATION_PRIORITY_NONE);
user->last_update = last_update;
}
if (auth_master_user_list_deinit(&ctx) < 0)
i_error("listing users failed, can't replicate existing data");
auth_master_deinit(&auth_conn);
}
static int
cmd_user_input(const char *auth_socket_path, const struct authtest_input *input,
const char *show_field, bool userdb)
{
const char *lookup_name = userdb ? "userdb lookup" : "passdb lookup";
struct auth_master_connection *conn;
pool_t pool;
const char *username, *const *fields, *p;
int ret;
if (auth_socket_path == NULL) {
auth_socket_path = t_strconcat(doveadm_settings->base_dir,
"/auth-userdb", NULL);
}
pool = pool_alloconly_create("auth master lookup", 1024);
conn = auth_master_init(auth_socket_path, 0);
if (userdb) {
ret = auth_master_user_lookup(conn, input->username, &input->info,
pool, &username, &fields);
} else {
ret = auth_master_pass_lookup(conn, input->username, &input->info,
pool, &fields);
}
if (ret < 0) {
if (fields[0] == NULL)
i_error("%s failed for %s", lookup_name, input->username);
else {
i_error("%s failed for %s: %s", lookup_name,
input->username, fields[0]);
}
} else if (ret == 0) {
fprintf(show_field == NULL ? stdout : stderr,
"%s: user %s doesn't exist\n", lookup_name,
input->username);
} else if (show_field != NULL) {
unsigned int show_field_len = strlen(show_field);
for (; *fields; fields++) {
if (strncmp(*fields, show_field, show_field_len) == 0 &&
(*fields)[show_field_len] == '=')
printf("%s\n", *fields + show_field_len + 1);
}
} else {
printf("%s: %s\n", userdb ? "userdb" : "passdb", input->username);
for (; *fields; fields++) {
p = strchr(*fields, '=');
if (p == NULL)
printf(" %-10s\n", *fields);
else {
printf(" %-10s: %s\n",
t_strcut(*fields, '='), p + 1);
}
}
}
auth_master_deinit(&conn);
return ret;
}
static struct auth_master_connection *
doveadm_get_auth_master_conn(const char *auth_socket_path)
{
enum auth_master_flags flags = 0;
if (doveadm_debug)
flags |= AUTH_MASTER_FLAG_DEBUG;
return auth_master_init(auth_socket_path, flags);
}
static void
mail_storage_service_first_init(struct mail_storage_service_ctx *ctx,
const struct setting_parser_info *user_info,
const struct mail_user_settings *user_set)
{
enum auth_master_flags flags = 0;
ctx->debug = mail_user_set_get_mail_debug(user_info, user_set);
if (ctx->debug)
flags |= AUTH_MASTER_FLAG_DEBUG;
if ((ctx->flags & MAIL_STORAGE_SERVICE_FLAG_NO_IDLE_TIMEOUT) != 0)
flags |= AUTH_MASTER_FLAG_NO_IDLE_TIMEOUT;
mail_storage_service_set_auth_conn(ctx,
auth_master_init(user_set->auth_socket_path, flags));
}
void mail_storage_service_all_init(struct mail_storage_service_ctx *ctx)
{
enum auth_master_flags flags = 0;
(void)mail_storage_service_all_iter_deinit(ctx);
mail_storage_service_init_settings(ctx, NULL);
/* create a new connection, because the iteration might take a while
and we might want to do USER lookups during it, which don't mix
well in the same connection. */
if (ctx->debug)
flags |= AUTH_MASTER_FLAG_DEBUG;
ctx->iter_conn = auth_master_init(auth_master_get_socket_path(ctx->conn),
flags);
ctx->auth_list = auth_master_user_list_init(ctx->iter_conn, "", NULL);
}
