#include <stdio.h>
#include <unistd.h>
-static void fs_cmd_help(doveadm_command_t *cmd);
-static void cmd_fs_delete(int argc, char *argv[]);
-
-static void cmd_fs_getopt(int *argc, char **argv[])
-{
- if (getopt(*argc, *argv, "") == '?')
- i_fatal("fs_init: Add -- if you have - in arguments");
- *argc -= optind;
- *argv += optind;
-}
+static void fs_cmd_help(struct doveadm_cmd_context *cctx);
+static void cmd_fs_delete(struct doveadm_cmd_context *cctx);
static struct fs *
-cmd_fs_init(int *argc, char **argv[], int own_arg_count, doveadm_command_t *cmd)
+cmd_fs_init(struct doveadm_cmd_context *cctx)
{
struct ssl_iostream_settings ssl_set;
struct fs_settings fs_set;
struct fs *fs;
- const char *error;
+ const char *fs_driver, *fs_args, *error;
- if (own_arg_count > 0) {
- if (*argc != 2 + own_arg_count)
- fs_cmd_help(cmd);
- } else {
- if (*argc <= 2)
- fs_cmd_help(cmd);
- }
+ if (!doveadm_cmd_param_str(cctx, "fs-driver", &fs_driver) ||
+ !doveadm_cmd_param_str(cctx, "fs-args", &fs_args))
+ fs_cmd_help(cctx);
doveadm_get_ssl_settings(&ssl_set, pool_datastack_create());
ssl_set.verbose = doveadm_debug;
fs_set.base_dir = doveadm_settings->base_dir;
fs_set.debug = doveadm_debug;
- if (fs_init((*argv)[0], (*argv)[1], &fs_set, &fs, &error) < 0)
+ if (fs_init(fs_driver, fs_args, &fs_set, &fs, &error) < 0)
i_fatal("fs_init() failed: %s", error);
-
- *argc += 2;
- *argv += 2;
return fs;
}
-static void cmd_fs_get(int argc, char *argv[])
+static void cmd_fs_get(struct doveadm_cmd_context *cctx)
{
struct fs *fs;
struct fs_file *file;
struct istream *input;
+ const char *path;
const unsigned char *data;
size_t size;
ssize_t ret;
doveadm_print_init(DOVEADM_PRINT_TYPE_PAGER);
doveadm_print_header("content", "content", DOVEADM_PRINT_HEADER_FLAG_HIDE_TITLE);
- cmd_fs_getopt(&argc, &argv);
- fs = cmd_fs_init(&argc, &argv, 1, cmd_fs_get);
+ fs = cmd_fs_init(cctx);
+ if (!doveadm_cmd_param_str(cctx, "path", &path))
+ fs_cmd_help(cctx);
- file = fs_file_init(fs, argv[0], FS_OPEN_MODE_READONLY);
+ file = fs_file_init(fs, path, FS_OPEN_MODE_READONLY);
input = fs_read_stream(file, IO_BLOCK_SIZE);
while ((ret = i_stream_read_more(input, &data, &size)) > 0) {
doveadm_print_stream(data, size);
fs_deinit(&fs);
}
-static void cmd_fs_put(int argc, char *argv[])
+static void cmd_fs_put(struct doveadm_cmd_context *cctx)
{
struct fs *fs;
enum fs_properties props;
- const char *src_path, *dest_path;
+ const char *hash_str, *src_path, *dest_path;
struct fs_file *file;
struct istream *input;
struct ostream *output;
buffer_t *hash = NULL;
- int c;
-
- while ((c = getopt(argc, argv, "h:")) > 0) {
- switch (c) {
- case 'h':
- hash = t_buffer_create(32);
- if (hex_to_binary(optarg, hash) < 0)
- i_fatal("Invalid -h parameter: Hash not in hex");
- break;
- default:
- fs_cmd_help(cmd_fs_put);
- }
- }
- argc -= optind; argv += optind;
- fs = cmd_fs_init(&argc, &argv, 2, cmd_fs_put);
- src_path = argv[0];
- dest_path = argv[1];
+ fs = cmd_fs_init(cctx);
+ if (!doveadm_cmd_param_str(cctx, "input-path", &src_path) ||
+ !doveadm_cmd_param_str(cctx, "path", &dest_path))
+ fs_cmd_help(cctx);
+ if (doveadm_cmd_param_str(cctx, "hash", &hash_str)) {
+ hash = t_buffer_create(32);
+ if (hex_to_binary(optarg, hash) < 0)
+ i_fatal("Invalid -h parameter: Hash not in hex");
+ }
file = fs_file_init(fs, dest_path, FS_OPEN_MODE_REPLACE);
props = fs_get_properties(fs);
fs_deinit(&fs);
}
-static void cmd_fs_copy(int argc, char *argv[])
+static void cmd_fs_copy(struct doveadm_cmd_context *cctx)
{
struct fs *fs;
struct fs_file *src_file, *dest_file;
const char *src_path, *dest_path;
- cmd_fs_getopt(&argc, &argv);
- fs = cmd_fs_init(&argc, &argv, 2, cmd_fs_copy);
- src_path = argv[0];
- dest_path = argv[1];
+ fs = cmd_fs_init(cctx);
+ if (!doveadm_cmd_param_str(cctx, "source-path", &src_path) ||
+ !doveadm_cmd_param_str(cctx, "destination-path", &dest_path))
+ fs_cmd_help(cctx);
src_file = fs_file_init(fs, src_path, FS_OPEN_MODE_READONLY);
dest_file = fs_file_init(fs, dest_path, FS_OPEN_MODE_REPLACE);
fs_deinit(&fs);
}
-static void cmd_fs_stat(int argc, char *argv[])
+static void cmd_fs_stat(struct doveadm_cmd_context *cctx)
{
struct fs *fs;
struct fs_file *file;
struct stat st;
+ const char *path;
- cmd_fs_getopt(&argc, &argv);
- fs = cmd_fs_init(&argc, &argv, 1, cmd_fs_stat);
+ fs = cmd_fs_init(cctx);
+ if (!doveadm_cmd_param_str(cctx, "path", &path))
+ fs_cmd_help(cctx);
- file = fs_file_init(fs, argv[0], FS_OPEN_MODE_READONLY);
+ file = fs_file_init(fs, path, FS_OPEN_MODE_READONLY);
doveadm_print_init(DOVEADM_PRINT_TYPE_FORMATTED);
doveadm_print_formatted_set_format("%{path} size=%{size}");
fs_deinit(&fs);
}
-static void cmd_fs_metadata(int argc, char *argv[])
+static void cmd_fs_metadata(struct doveadm_cmd_context *cctx)
{
struct fs *fs;
struct fs_file *file;
const struct fs_metadata *m;
const ARRAY_TYPE(fs_metadata) *metadata;
+ const char *path;
- cmd_fs_getopt(&argc, &argv);
- fs = cmd_fs_init(&argc, &argv, 1, cmd_fs_metadata);
+ fs = cmd_fs_init(cctx);
+ if (!doveadm_cmd_param_str(cctx, "path", &path))
+ fs_cmd_help(cctx);
- file = fs_file_init(fs, argv[0], FS_OPEN_MODE_READONLY);
+ file = fs_file_init(fs, path, FS_OPEN_MODE_READONLY);
doveadm_print_init(DOVEADM_PRINT_TYPE_FORMATTED);
doveadm_print_formatted_set_format("%{key}=%{value}\n");
}
static void
-cmd_fs_delete_recursive(int argc, char *argv[], unsigned int async_count)
+cmd_fs_delete_recursive(struct doveadm_cmd_context *cctx,
+ unsigned int async_count)
{
struct fs *fs;
+ const char *const *paths;
unsigned int i;
- fs = cmd_fs_init(&argc, &argv, 0, cmd_fs_delete);
- for (i = 0; argv[i] != NULL; i++)
- cmd_fs_delete_recursive_path(fs, argv[i], async_count);
+ fs = cmd_fs_init(cctx);
+ if (!doveadm_cmd_param_array(cctx, "path", &paths))
+ fs_cmd_help(cctx);
+
+ for (i = 0; paths[i] != NULL; i++)
+ cmd_fs_delete_recursive_path(fs, paths[i], async_count);
fs_deinit(&fs);
}
-static void cmd_fs_delete_paths(int argc, char *argv[],
+static void cmd_fs_delete_paths(struct doveadm_cmd_context *cctx,
unsigned int async_count)
{
struct fs *fs;
struct fs_delete_ctx ctx;
+ const char *const *paths;
unsigned int i;
int ret;
- fs = cmd_fs_init(&argc, &argv, 0, cmd_fs_delete);
+ fs = cmd_fs_init(cctx);
+ if (!doveadm_cmd_param_array(cctx, "path", &paths))
+ fs_cmd_help(cctx);
i_zero(&ctx);
ctx.fs = fs;
ctx.files_count = I_MAX(async_count, 1);
ctx.files = t_new(struct fs_file *, ctx.files_count);
- for (i = 0; argv[i] != NULL; i++) {
+ for (i = 0; paths[i] != NULL; i++) {
T_BEGIN {
- ret = doveadm_fs_delete_async_fname(&ctx, argv[i]);
+ ret = doveadm_fs_delete_async_fname(&ctx, paths[i]);
} T_END;
if (ret < 0)
break;
fs_deinit(&fs);
}
-static void cmd_fs_delete(int argc, char *argv[])
+static void cmd_fs_delete(struct doveadm_cmd_context *cctx)
{
bool recursive = FALSE;
- unsigned int async_count = 0;
- int c;
+ int64_t async_count = 0;
- while ((c = getopt(argc, argv, "Rn:")) > 0) {
- switch (c) {
- case 'R':
- recursive = TRUE;
- break;
- case 'n':
- if (str_to_uint(optarg, &async_count) < 0)
- i_fatal("Invalid -n parameter: %s", optarg);
- break;
- default:
- fs_cmd_help(cmd_fs_delete);
- }
- }
- argc -= optind; argv += optind;
+ (void)doveadm_cmd_param_bool(cctx, "recursive", &recursive);
+ (void)doveadm_cmd_param_int64(cctx, "max-parallel", &async_count);
if (recursive)
- cmd_fs_delete_recursive(argc, argv, async_count);
+ cmd_fs_delete_recursive(cctx, async_count);
else
- cmd_fs_delete_paths(argc, argv, async_count);
+ cmd_fs_delete_paths(cctx, async_count);
}
-static void cmd_fs_iter_full(int argc, char *argv[], enum fs_iter_flags flags,
- doveadm_command_t *cmd)
+static void cmd_fs_iter_full(struct doveadm_cmd_context *cctx,
+ enum fs_iter_flags flags)
{
struct fs *fs;
struct fs_iter *iter;
- const char *fname, *error;
- int c;
+ const char *path, *fname, *error;
+ bool b;
- while ((c = getopt(argc, argv, "CO")) > 0) {
- switch (c) {
- case 'C':
- flags |= FS_ITER_FLAG_NOCACHE;
- break;
- case 'O':
- flags |= FS_ITER_FLAG_OBJECTIDS;
- break;
- default:
- fs_cmd_help(cmd);
- }
- }
- argc -= optind; argv += optind;
+ if (doveadm_cmd_param_bool(cctx, "no-cache", &b) && b)
+ flags |= FS_ITER_FLAG_NOCACHE;
+ if (doveadm_cmd_param_bool(cctx, "object-ids", &b) && b)
+ flags |= FS_ITER_FLAG_OBJECTIDS;
- fs = cmd_fs_init(&argc, &argv, 1, cmd);
+ fs = cmd_fs_init(cctx);
+ if (!doveadm_cmd_param_str(cctx, "path", &path))
+ fs_cmd_help(cctx);
doveadm_print_init(DOVEADM_PRINT_TYPE_FORMATTED);
doveadm_print_formatted_set_format("%{path}\n");
doveadm_print_header_simple("path");
- iter = fs_iter_init(fs, argv[0], flags);
+ iter = fs_iter_init(fs, path, flags);
while ((fname = fs_iter_next(iter)) != NULL) {
doveadm_print(fname);
}
if (fs_iter_deinit(&iter, &error) < 0) {
- i_error("fs_iter_deinit(%s) failed: %s",
- argv[0], error);
+ i_error("fs_iter_deinit(%s) failed: %s", path, error);
doveadm_exit_code = EX_TEMPFAIL;
}
fs_deinit(&fs);
}
-static void cmd_fs_iter(int argc, char *argv[])
+static void cmd_fs_iter(struct doveadm_cmd_context *cctx)
{
- cmd_fs_iter_full(argc, argv, 0, cmd_fs_iter);
+ cmd_fs_iter_full(cctx, 0);
}
-static void cmd_fs_iter_dirs(int argc, char *argv[])
+static void cmd_fs_iter_dirs(struct doveadm_cmd_context *cctx)
{
- cmd_fs_iter_full(argc, argv, FS_ITER_FLAG_DIRS, cmd_fs_iter_dirs);
+ cmd_fs_iter_full(cctx, FS_ITER_FLAG_DIRS);
}
struct doveadm_cmd_ver2 doveadm_cmd_fs[] = {
{
.name = "fs get",
- .old_cmd = cmd_fs_get,
+ .cmd = cmd_fs_get,
.usage = "<fs-driver> <fs-args> <path>",
DOVEADM_CMD_PARAMS_START
DOVEADM_CMD_PARAM('\0', "fs-driver", CMD_PARAM_STR, CMD_PARAM_FLAG_POSITIONAL)
},
{
.name = "fs put",
- .old_cmd = cmd_fs_put,
+ .cmd = cmd_fs_put,
.usage = "[-h <hash>] <fs-driver> <fs-args> <input path> <path>",
DOVEADM_CMD_PARAMS_START
DOVEADM_CMD_PARAM('h', "hash", CMD_PARAM_STR, 0)
},
{
.name = "fs copy",
- .old_cmd = cmd_fs_copy,
+ .cmd = cmd_fs_copy,
.usage = "<fs-driver> <fs-args> <source path> <dest path>",
DOVEADM_CMD_PARAMS_START
DOVEADM_CMD_PARAM('\0', "fs-driver", CMD_PARAM_STR, CMD_PARAM_FLAG_POSITIONAL)
},
{
.name = "fs stat",
- .old_cmd = cmd_fs_stat,
+ .cmd = cmd_fs_stat,
.usage = "<fs-driver> <fs-args> <path>",
DOVEADM_CMD_PARAMS_START
DOVEADM_CMD_PARAM('\0', "fs-driver", CMD_PARAM_STR, CMD_PARAM_FLAG_POSITIONAL)
},
{
.name = "fs metadata",
- .old_cmd = cmd_fs_metadata,
+ .cmd = cmd_fs_metadata,
.usage = "<fs-driver> <fs-args> <path>",
DOVEADM_CMD_PARAMS_START
DOVEADM_CMD_PARAM('\0', "fs-driver", CMD_PARAM_STR, CMD_PARAM_FLAG_POSITIONAL)
},
{
.name = "fs delete",
- .old_cmd = cmd_fs_delete,
+ .cmd = cmd_fs_delete,
.usage = "[-R] [-n <count>] <fs-driver> <fs-args> <path> [<path> ...]",
DOVEADM_CMD_PARAMS_START
DOVEADM_CMD_PARAM('R', "recursive", CMD_PARAM_BOOL, 0)
},
{
.name = "fs iter",
- .old_cmd = cmd_fs_iter,
+ .cmd = cmd_fs_iter,
.usage = "[--no-cache] [--object-ids] <fs-driver> <fs-args> <path>",
DOVEADM_CMD_PARAMS_START
DOVEADM_CMD_PARAM('C', "no-cache", CMD_PARAM_BOOL, 0)
},
{
.name = "fs iter-dirs",
- .old_cmd = cmd_fs_iter_dirs,
+ .cmd = cmd_fs_iter_dirs,
.usage = "<fs-driver> <fs-args> <path>",
DOVEADM_CMD_PARAMS_START
DOVEADM_CMD_PARAM('\0', "fs-driver", CMD_PARAM_STR, CMD_PARAM_FLAG_POSITIONAL)
}
};
-static void fs_cmd_help(doveadm_command_t *cmd)
+static void fs_cmd_help(struct doveadm_cmd_context *cctx)
{
unsigned int i;
for (i = 0; i < N_ELEMENTS(doveadm_cmd_fs); i++) {
- if (doveadm_cmd_fs[i].old_cmd == cmd)
+ if (doveadm_cmd_fs[i].cmd == cctx->cmd->cmd)
help_ver2(&doveadm_cmd_fs[i]);
}
i_unreached();
projects / thirdparty / dovecot / core.git / commitdiff
