static void cmd_proxy_list_header(const char *const *args)
{
struct {
const char *key;
const char *title;
} header_map[] = {
{ "service", "proto" },
{ "src-ip", "src ip" },
{ "dest-ip", "dest ip" },
{ "dest-port", "port" },
};
for (unsigned int i = 0; args[i] != NULL; i++) {
const char *arg = args[i];
if (strcmp(arg, "username") == 0 ||
strncmp(arg, "user_", 5) == 0) {
doveadm_print_header(arg, arg,
DOVEADM_PRINT_HEADER_FLAG_EXPAND);
continue;
}
const char *title = arg;
for (unsigned int j = 0; j < N_ELEMENTS(header_map); j++) {
if (strcmp(header_map[j].key, arg) == 0) {
title = header_map[j].title;
break;
}
}
doveadm_print_header(arg, title, 0);
}
}
static void cmd_mailbox_status_init(struct doveadm_mail_cmd_context *_ctx,
const char *const args[])
{
struct status_cmd_context *ctx = (struct status_cmd_context *)_ctx;
const char *fields = args[0];
if (fields == NULL || args[1] == NULL)
doveadm_mail_help_name("mailbox status");
status_parse_fields(ctx, t_strsplit_spaces(fields, " "));
ctx->search_args = doveadm_mail_mailbox_search_args_build(args+1);
if (!ctx->total_sum) {
doveadm_print_header("mailbox", "mailbox",
DOVEADM_PRINT_HEADER_FLAG_HIDE_TITLE);
}
if ((ctx->status_items & STATUS_MESSAGES) != 0)
doveadm_print_header_simple("messages");
if ((ctx->status_items & STATUS_RECENT) != 0)
doveadm_print_header_simple("recent");
if ((ctx->status_items & STATUS_UIDNEXT) != 0)
doveadm_print_header_simple("uidnext");
if ((ctx->status_items & STATUS_UIDVALIDITY) != 0)
doveadm_print_header_simple("uidvalidity");
if ((ctx->status_items & STATUS_UNSEEN) != 0)
doveadm_print_header_simple("unseen");
if ((ctx->status_items & STATUS_HIGHESTMODSEQ) != 0)
doveadm_print_header_simple("highestmodseq");
if ((ctx->metadata_items & MAILBOX_METADATA_VIRTUAL_SIZE) != 0)
doveadm_print_header_simple("vsize");
if ((ctx->metadata_items & MAILBOX_METADATA_GUID) != 0)
doveadm_print_header_simple("guid");
}
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 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_mailbox_metadata_list_init(struct doveadm_mail_cmd_context *_ctx,
const char *const args[])
{
struct metadata_cmd_context *ctx = (struct metadata_cmd_context *)_ctx;
const char *key = NULL;
if (args[0] == NULL)
doveadm_mail_help_name("mailbox metadata list");
if (args[1] != NULL)
cmd_mailbox_metadata_parse_key(args[1], &ctx->key_type, &key);
ctx->mailbox = p_strdup(_ctx->pool, args[0]);
ctx->key = key == NULL ? "" : p_strdup(_ctx->pool, key);
doveadm_print_header("key", "key",
DOVEADM_PRINT_HEADER_FLAG_HIDE_TITLE);
}
static void
cmd_mailbox_metadata_get_init(struct doveadm_mail_cmd_context *_ctx,
const char *const args[])
{
struct metadata_cmd_context *ctx = (struct metadata_cmd_context *)_ctx;
const char *key;
if (str_array_length(args) != 2)
doveadm_mail_help_name("mailbox metadata get");
cmd_mailbox_metadata_parse_key(args[1], &ctx->key_type, &key);
ctx->mailbox = p_strdup(_ctx->pool, args[0]);
ctx->key = p_strdup(_ctx->pool, key);
doveadm_print_header("value", "value",
DOVEADM_PRINT_HEADER_FLAG_HIDE_TITLE);
}
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 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 struct doveadm_mail_cmd_context *
doveadm_mail_cmd_server_parse(const char *cmd_name,
const struct doveadm_settings *set,
const struct mail_storage_service_input *input,
int argc, char *argv[])
{
struct doveadm_mail_cmd_context *ctx;
const struct doveadm_mail_cmd *cmd;
const char *getopt_args;
bool add_username_header = FALSE;
int c;
cmd = doveadm_mail_cmd_find(cmd_name);
if (cmd == NULL) {
i_error("doveadm: Client sent unknown command: %s", cmd_name);
return NULL;
}
ctx = doveadm_mail_cmd_init(cmd, set);
ctx->full_args = (const void *)(argv + 1);
ctx->proxying = TRUE;
ctx->service_flags |=
MAIL_STORAGE_SERVICE_FLAG_NO_LOG_INIT |
MAIL_STORAGE_SERVICE_FLAG_USERDB_LOOKUP;
if (doveadm_debug)
ctx->service_flags |= MAIL_STORAGE_SERVICE_FLAG_DEBUG;
getopt_args = t_strconcat("AS:u:", ctx->getopt_args, NULL);
while ((c = getopt(argc, argv, getopt_args)) > 0) {
switch (c) {
case 'A':
add_username_header = TRUE;
break;
case 'S':
/* ignore */
break;
case 'u':
if (strchr(optarg, '*') != NULL ||
strchr(optarg, '?') != NULL)
add_username_header = TRUE;
break;
default:
if ((ctx->v.parse_arg == NULL ||
!ctx->v.parse_arg(ctx, c))) {
i_error("doveadm %s: "
"Client sent unknown parameter: %c",
cmd->name, c);
ctx->v.deinit(ctx);
return NULL;
}
}
}
argv += optind;
optind = 1;
if (argv[0] != NULL && cmd->usage_args == NULL) {
i_error("doveadm %s: Client sent unknown parameter: %s",
cmd->name, argv[0]);
ctx->v.deinit(ctx);
return NULL;
}
ctx->args = (const void *)argv;
if (doveadm_print_is_initialized() && add_username_header) {
doveadm_print_header("username", "Username",
DOVEADM_PRINT_HEADER_FLAG_STICKY |
DOVEADM_PRINT_HEADER_FLAG_HIDE_TITLE);
doveadm_print_sticky("username", input->username);
}
return ctx;
}