static void main_init(void)
{
doveadm_server = TRUE;
doveadm_settings = master_service_settings_get_others(master_service)[0];
doveadm_settings = settings_dup(&doveadm_setting_parser_info,
doveadm_settings,
pool_datastack_create());
doveadm_cmds_init();
doveadm_dump_init();
doveadm_mail_init();
doveadm_load_modules();
doveadm_print_init(DOVEADM_PRINT_TYPE_SERVER);
doveadm_print_init(DOVEADM_PRINT_TYPE_JSON);
}
static void cmd_stats_top(int argc, char *argv[])
{
const char *path, *sort_type;
int c;
path = t_strconcat(doveadm_settings->base_dir, "/stats", NULL);
while ((c = getopt(argc, argv, "bs:")) > 0) {
switch (c) {
case 'b':
disk_input_field = "read_bytes";
disk_output_field = "write_bytes";
break;
case 's':
path = optarg;
break;
default:
help(&doveadm_cmd_stats_top);
}
}
argv += optind - 1;
if (argv[1] == NULL)
sort_type = "disk";
else if (argv[2] != NULL)
help(&doveadm_cmd_stats_top);
else
sort_type = argv[1];
doveadm_print_init(DOVEADM_PRINT_TYPE_TABLE);
stats_top(path, sort_type);
}
static void cmd_stats_dump(int argc, char *argv[])
{
const char *path, *cmd;
int c;
path = t_strconcat(doveadm_settings->base_dir, "/stats", NULL);
while ((c = getopt(argc, argv, "s:")) > 0) {
switch (c) {
case 's':
path = optarg;
break;
default:
help(&doveadm_cmd_stats_dump);
}
}
argv += optind - 1;
if (argv[1] == NULL)
help(&doveadm_cmd_stats_dump);
cmd = t_strdup_printf("EXPORT\t%s\n",
t_strarray_join((const void *)(argv+1), "\t"));
doveadm_print_init(DOVEADM_PRINT_TYPE_TAB);
stats_dump(path, cmd);
}
static void cmd_dict_iter(int argc, char *argv[])
{
struct dict *dict;
struct dict_iterate_context *iter;
enum dict_iterate_flags iter_flags = 0;
const char *key, *value;
dict = cmd_dict_init_full(&argc, &argv, 1, 0, cmd_dict_iter, &iter_flags);
doveadm_print_init(DOVEADM_PRINT_TYPE_TAB);
doveadm_print_header_simple("key");
if ((iter_flags & DICT_ITERATE_FLAG_NO_VALUE) == 0)
doveadm_print_header_simple("value");
iter = dict_iterate_init(dict, argv[0], iter_flags);
while (dict_iterate(iter, &key, &value)) {
doveadm_print(key);
if ((iter_flags & DICT_ITERATE_FLAG_NO_VALUE) == 0)
doveadm_print(value);
}
if (dict_iterate_deinit(&iter) < 0) {
i_error("dict_iterate_deinit(%s) failed", argv[0]);
doveadm_exit_code = EX_TEMPFAIL;
}
dict_deinit(&dict);
}
static void
doveadm_cmd_stats_dump(struct doveadm_cmd_context* cctx)
{
const char *path, *cmd;
const char *args[3] = {0};
if (!doveadm_cmd_param_str(cctx, "socket-path", &path))
path = t_strconcat(doveadm_settings->base_dir, "/stats", NULL);
if (!doveadm_cmd_param_str(cctx, "type", &args[0])) {
i_error("Missing type parameter");
doveadm_exit_code = EX_USAGE;
return;
}
/* purely optional */
if (!doveadm_cmd_param_str(cctx, "filter", &args[1]))
args[1] = NULL;
cmd = t_strdup_printf("EXPORT\t%s\n", t_strarray_join(args, "\t"));
doveadm_print_init(DOVEADM_PRINT_TYPE_TAB);
stats_dump(path, cmd);
return;
}
static struct doveadm_mail_cmd_context *cmd_mailbox_metadata_list_alloc(void)
{
struct metadata_cmd_context *ctx;
ctx = doveadm_mail_cmd_alloc(struct metadata_cmd_context);
ctx->ctx.v.init = cmd_mailbox_metadata_list_init;
ctx->ctx.v.run = cmd_mailbox_metadata_list_run;
doveadm_print_init(DOVEADM_PRINT_TYPE_FLOW);
return &ctx->ctx;
}
static struct doveadm_mail_cmd_context *
cmd_sieve_get_alloc(void)
{
struct doveadm_sieve_cmd_context *ctx;
ctx = doveadm_sieve_cmd_alloc(struct doveadm_sieve_cmd_context);
ctx->ctx.v.init = cmd_sieve_get_init;
ctx->v.run = cmd_sieve_get_run;
doveadm_print_init("pager");
return &ctx->ctx;
}
static struct doveadm_mail_cmd_context *cmd_copy_alloc(void)
{
struct copy_cmd_context *ctx;
ctx = doveadm_mail_cmd_alloc(struct copy_cmd_context);
ctx->ctx.v.init = cmd_copy_init;
ctx->ctx.v.deinit = cmd_copy_deinit;
ctx->ctx.v.run = cmd_copy_run;
doveadm_print_init(DOVEADM_PRINT_TYPE_FLOW);
return &ctx->ctx;
}
static void cmd_instance_list(int argc, char *argv[])
{
struct master_instance_list *list;
struct master_instance_list_iter *iter;
const struct master_instance *inst;
const char *instance_path, *pidfile_path;
bool show_config = FALSE;
int c;
while ((c = getopt(argc, argv, "c")) > 0) {
switch (c) {
case 'c':
show_config = TRUE;
break;
default:
help(&doveadm_cmd_instance[0]);
}
}
argv += optind;
if (!show_config) {
doveadm_print_init(DOVEADM_PRINT_TYPE_TABLE);
doveadm_print_header("path", "path", DOVEADM_PRINT_HEADER_FLAG_EXPAND);
doveadm_print_header_simple("name");
doveadm_print_header_simple("last used");
doveadm_print_header_simple("running");
}
instance_path = t_strconcat(service_set->state_dir,
"/"MASTER_INSTANCE_FNAME, NULL);
list = master_instance_list_init(instance_path);
iter = master_instance_list_iterate_init(list);
while ((inst = master_instance_iterate_list_next(iter)) != NULL) {
if (argv[0] != NULL && strcmp(argv[0], inst->name) != 0)
continue;
if (show_config) {
printf("%s\n", inst->config_path == NULL ? "" :
inst->config_path);
continue;
}
doveadm_print(inst->base_dir);
doveadm_print(inst->name);
doveadm_print(unixdate2str(inst->last_used));
pidfile_path = t_strconcat(inst->base_dir, "/master.pid", NULL);
if (pid_file_read(pidfile_path))
doveadm_print("yes");
else
doveadm_print("no");
}
master_instance_iterate_list_deinit(&iter);
master_instance_list_deinit(&list);
}
static struct doveadm_mail_cmd_context *cmd_mailbox_status_alloc(void)
{
struct status_cmd_context *ctx;
ctx = doveadm_mail_cmd_alloc(struct status_cmd_context);
ctx->ctx.getopt_args = "t";
ctx->ctx.v.parse_arg = cmd_mailbox_status_parse_arg;
ctx->ctx.v.init = cmd_mailbox_status_init;
ctx->ctx.v.deinit = cmd_mailbox_status_deinit;
ctx->ctx.v.run = cmd_mailbox_status_run;
doveadm_print_init(DOVEADM_PRINT_TYPE_FLOW);
return &ctx->ctx;
}
static void cmd_director_status(int argc, char *argv[])
{
struct director_context *ctx;
const char *line, *const *args;
ctx = cmd_director_init(argc, argv, "a:t:", cmd_director_status);
if (argv[optind] != NULL) {
cmd_director_status_user(ctx, argv+optind);
return;
}
doveadm_print_init(DOVEADM_PRINT_TYPE_TABLE);
doveadm_print_header_simple("mail server ip");
doveadm_print_header_simple("tag");
doveadm_print_header_simple("vhosts");
doveadm_print_header_simple("state");
doveadm_print_header("state-changed", "state changed", 0);
doveadm_print_header_simple("users");
director_send(ctx, "HOST-LIST\n");
while ((line = i_stream_read_next_line(ctx->input)) != NULL) {
if (*line == '\0')
break;
T_BEGIN {
unsigned int arg_count;
time_t ts;
args = t_strsplit_tab(line);
arg_count = str_array_length(args);
if (arg_count >= 6) {
/* ip vhosts users tag updown updown-ts */
doveadm_print(args[0]);
doveadm_print(args[3]);
doveadm_print(args[1]);
doveadm_print(args[4][0] == 'D' ? "down" : "up");
if (str_to_time(args[5], &ts) < 0 ||
ts <= 0)
doveadm_print("-");
else
doveadm_print(unixdate2str(ts));
doveadm_print(args[2]);
}
} T_END;
}
if (line == NULL) {
i_error("Director disconnected unexpectedly");
doveadm_exit_code = EX_TEMPFAIL;
}
director_disconnect(ctx);
}
static void stats_top_output(struct top_context *ctx)
{
static const char *names[] = {
"user", "service", "user_cpu", "sys_cpu",
"", ""
};
struct winsize ws;
struct top_line *const *lines;
unsigned int i, j, row, maxrow, count, indexes[N_ELEMENTS(names)];
names[4] = disk_input_field;
names[5] = disk_output_field;
/* ANSI clear screen and move cursor to top of screen */
printf("\x1b[2J\x1b[1;1H"); fflush(stdout);
doveadm_print_deinit();
doveadm_print_init(DOVEADM_PRINT_TYPE_TABLE);
doveadm_print_header("USER", "USER", DOVEADM_PRINT_HEADER_FLAG_EXPAND);
doveadm_print_header_simple("SERVICE");
doveadm_print_header_simple("%CPU");
doveadm_print_header_simple("%SYS");
doveadm_print_header_simple("DISKIN");
doveadm_print_header_simple("DISKOUT");
if (!stats_top_round(ctx)) {
/* no connections yet */
return;
}
for (i = 0; i < N_ELEMENTS(names); i++) {
if (!stats_header_find(ctx, names[i], &indexes[i]))
indexes[i] = UINT_MAX;
}
if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) < 0)
ws.ws_row = 24;
maxrow = ws.ws_row-1;
lines = array_get(&ctx->lines, &count);
for (i = 0, row = 1; row < maxrow && i < count; i++, row++) {
for (j = 0; j < N_ELEMENTS(names); j++) {
if (indexes[j] == UINT_MAX)
doveadm_print("?");
else
stats_top_output_diff(ctx, lines[i], indexes[j]);
}
}
}
static void cmd_proxy_list(int argc, char *argv[])
{
struct proxy_context *ctx;
bool seen_header = FALSE;
ctx = cmd_proxy_init(argc, argv, "a:", cmd_proxy_list);
doveadm_print_init(DOVEADM_PRINT_TYPE_TABLE);
io_loop_set_running(current_ioloop);
ipc_client_cmd(ctx->ipc, "proxy\t*\tLIST-FULL",
cmd_proxy_list_callback, &seen_header);
if (io_loop_is_running(current_ioloop))
io_loop_run(current_ioloop);
ipc_client_deinit(&ctx->ipc);
}
static void cmd_sis_find(int argc, char *argv[])
{
const char *rootdir, *path, *hash;
DIR *dir;
struct dirent *d;
struct stat st;
string_t *str;
unsigned int dir_len, hash_len;
if (argc < 3 || strlen(argv[2]) < 4)
help(&doveadm_cmd_sis_find);
rootdir = argv[1];
if (stat(rootdir, &st) < 0) {
if (errno == ENOENT)
i_fatal("Attachment dir doesn't exist: %s", rootdir);
i_fatal("stat(%s) failed: %m", rootdir);
}
hash = argv[2];
hash_len = strlen(hash);
path = sis_get_dir(rootdir, hash);
str = t_str_new(256);
str_append(str, path);
str_append_c(str, '/');
dir_len = str_len(str);
dir = opendir(path);
if (dir == NULL) {
if (errno == ENOENT)
return;
i_fatal("opendir(%s) failed: %m", path);
}
doveadm_print_init(DOVEADM_PRINT_TYPE_FLOW);
doveadm_print_header("path", "path",
DOVEADM_PRINT_HEADER_FLAG_HIDE_TITLE);
while ((d = readdir(dir)) != NULL) {
if (strncmp(d->d_name, hash, hash_len) == 0) {
str_truncate(str, dir_len);
str_append(str, d->d_name);
doveadm_print(str_c(str));
}
}
if (closedir(dir) < 0)
i_error("closedir(%s) failed: %m", path);
}
static struct doveadm_mail_cmd_context *cmd_dsync_alloc(void)
{
struct dsync_cmd_context *ctx;
ctx = doveadm_mail_cmd_alloc(struct dsync_cmd_context);
ctx->ctx.getopt_args = DSYNC_COMMON_GETOPT_ARGS;
ctx->ctx.v.parse_arg = cmd_mailbox_dsync_parse_arg;
ctx->ctx.v.preinit = cmd_dsync_preinit;
ctx->ctx.v.init = cmd_dsync_init;
ctx->ctx.v.prerun = cmd_dsync_prerun;
ctx->ctx.v.run = cmd_dsync_run;
ctx->sync_type = DSYNC_BRAIN_SYNC_TYPE_CHANGED;
doveadm_print_init(DOVEADM_PRINT_TYPE_FLOW);
doveadm_print_header("state", "state",
DOVEADM_PRINT_HEADER_FLAG_HIDE_TITLE);
p_array_init(&ctx->exclude_mailboxes, ctx->ctx.pool, 4);
return &ctx->ctx;
}
static int doveadm_cmd_handle(struct client_connection *conn,
const char *cmd_name,
const struct mail_storage_service_input *input,
int argc, char *argv[])
{
struct ioloop *ioloop, *prev_ioloop = current_ioloop;
const struct doveadm_cmd *cmd;
const struct doveadm_mail_cmd *mail_cmd;
struct doveadm_mail_cmd_context *ctx;
cmd = doveadm_cmd_find(cmd_name, &argc, &argv);
if (cmd == NULL) {
mail_cmd = doveadm_mail_cmd_find(cmd_name);
if (mail_cmd == NULL) {
i_error("doveadm: Client sent unknown command: %s", cmd_name);
return -1;
}
if (doveadm_mail_cmd_server_parse(mail_cmd, conn->set, input,
argc, argv, &ctx) < 0)
return -1;
}
/* some commands will want to call io_loop_run(), but we're already
running one and we can't call the original one recursively, so
create a new ioloop. */
ioloop = io_loop_create();
lib_signals_reset_ioloop();
if (cmd != NULL)
doveadm_cmd_server_run(conn, cmd, argc, argv);
else
doveadm_mail_cmd_server_run(conn, ctx, input);
io_loop_set_current(prev_ioloop);
lib_signals_reset_ioloop();
o_stream_switch_ioloop(conn->output);
io_loop_set_current(ioloop);
io_loop_destroy(&ioloop);
/* clear all headers */
doveadm_print_deinit();
doveadm_print_init(DOVEADM_PRINT_TYPE_SERVER);
return 0;
}
static void cmd_dict_get(int argc, char *argv[])
{
struct dict *dict;
const char *value;
int ret;
dict = cmd_dict_init(&argc, &argv, 1, 0, cmd_dict_get);
doveadm_print_init(DOVEADM_PRINT_TYPE_TABLE);
doveadm_print_header("value", "", DOVEADM_PRINT_HEADER_FLAG_HIDE_TITLE);
ret = dict_lookup(dict, pool_datastack_create(), argv[0], &value);
if (ret < 0) {
i_error("dict_lookup(%s) failed", argv[0]);
doveadm_exit_code = EX_TEMPFAIL;
} else if (ret == 0) {
i_error("%s doesn't exist", argv[0]);
doveadm_exit_code = DOVEADM_EX_NOTFOUND;
} else {
doveadm_print(value);
}
dict_deinit(&dict);
}
static void cmd_auth_cache_flush(int argc, char *argv[])
{
const char *master_socket_path = NULL;
struct auth_master_connection *conn;
unsigned int count;
int c;
while ((c = getopt(argc, argv, "a:")) > 0) {
switch (c) {
case 'a':
master_socket_path = optarg;
break;
default:
doveadm_exit_code = EX_USAGE;
return;
}
}
argv += optind;
if (master_socket_path == NULL) {
master_socket_path = t_strconcat(doveadm_settings->base_dir,
"/auth-master", NULL);
}
conn = doveadm_get_auth_master_conn(master_socket_path);
if (auth_master_cache_flush(conn, (void *)argv, &count) < 0) {
i_error("Cache flush failed");
doveadm_exit_code = EX_TEMPFAIL;
} else {
doveadm_print_init("formatted");
doveadm_print_formatted_set_format("%{entries} cache entries flushed\n");
doveadm_print_header_simple("entries");
doveadm_print_num(count);
}
auth_master_deinit(&conn);
}
static void
doveadm_mail_cmd_server_run(struct client_connection *conn,
struct doveadm_mail_cmd_context *ctx,
const struct mail_storage_service_input *input)
{
const char *error;
int ret;
ctx->conn = conn;
if (ctx->v.preinit != NULL)
ctx->v.preinit(ctx);
ret = doveadm_mail_single_user(ctx, input, &error);
doveadm_mail_server_flush();
ctx->v.deinit(ctx);
doveadm_print_flush();
mail_storage_service_deinit(&ctx->storage_service);
if (ret < 0) {
i_error("%s: %s", ctx->cmd->name, error);
o_stream_nsend(conn->output, "\n-\n", 3);
} else if (ret == 0) {
o_stream_nsend_str(conn->output, "\n-NOUSER\n");
} else if (ctx->exit_code != 0) {
/* maybe not an error, but not a full success either */
o_stream_nsend(conn->output, "\n-\n", 3);
} else {
o_stream_nsend(conn->output, "\n+\n", 3);
}
pool_unref(&ctx->pool);
/* clear all headers */
doveadm_print_deinit();
doveadm_print_init(DOVEADM_PRINT_TYPE_SERVER);
}
