[thirdparty/systemd.git] / src / import / import.c

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright 2014 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <getopt.h>

#include "sd-event.h"
#include "event-util.h"
#include "verbs.h"
#include "build.h"
#include "machine-image.h"
#include "import-tar.h"
#include "import-raw.h"
#include "import-dkr.h"
#include "import-util.h"

static bool arg_force = false;
static const char *arg_image_root = "/var/lib/machines";

static const char* arg_dkr_index_url = DEFAULT_DKR_INDEX_URL;

static void on_tar_finished(TarImport *import, int error, void *userdata) {
        sd_event *event = userdata;
        assert(import);

        if (error == 0)
                log_info("Operation completed successfully.");
        else
                log_error_errno(error, "Operation failed: %m");

        sd_event_exit(event, error);
}

static int strip_tar_suffixes(const char *name, char **ret) {
        const char *e;
        char *s;

        e = endswith(name, ".tar");
        if (!e)
                e = endswith(name, ".tar.gz");
        if (!e)
                e = endswith(name, ".tar.xz");
        if (!e)
                e = endswith(name, ".tgz");
        if (!e)
                e = strchr(name, 0);

        if (e <= name)
                return -EINVAL;

        s = strndup(name, e - name);
        if (!s)
                return -ENOMEM;

        *ret = s;
        return 0;
}

static int pull_tar(int argc, char *argv[], void *userdata) {
        _cleanup_(tar_import_unrefp) TarImport *import = NULL;
        _cleanup_event_unref_ sd_event *event = NULL;
        const char *url, *local;
        _cleanup_free_ char *l = NULL, *ll = NULL;
        int r;

        url = argv[1];
        if (!http_url_is_valid(url)) {
                log_error("URL '%s' is not valid.", url);
                return -EINVAL;
        }

        if (argc >= 3)
                local = argv[2];
        else {
                r = import_url_last_component(url, &l);
                if (r < 0)
                        return log_error_errno(r, "Failed get final component of URL: %m");

                local = l;
        }

        if (isempty(local) || streq(local, "-"))
                local = NULL;

        if (local) {
                r = strip_tar_suffixes(local, &ll);
                if (r < 0)
                        return log_oom();

                local = ll;

                if (!machine_name_is_valid(local)) {
                        log_error("Local image name '%s' is not valid.", local);
                        return -EINVAL;
                }

                if (!arg_force) {
                        r = image_find(local, NULL);
                        if (r < 0)
                                return log_error_errno(r, "Failed to check whether image '%s' exists: %m", local);
                        else if (r > 0) {
                                log_error_errno(EEXIST, "Image '%s' already exists.", local);
                                return -EEXIST;
                        }
                }

                log_info("Pulling '%s', saving as '%s'.", url, local);
        } else
                log_info("Pulling '%s'.", url);

        r = sd_event_default(&event);
        if (r < 0)
                return log_error_errno(r, "Failed to allocate event loop: %m");

        assert_se(sigprocmask_many(SIG_BLOCK, SIGTERM, SIGINT, -1) == 0);
        sd_event_add_signal(event, NULL, SIGTERM, NULL,  NULL);
        sd_event_add_signal(event, NULL, SIGINT, NULL, NULL);

        r = tar_import_new(&import, event, arg_image_root, on_tar_finished, event);
        if (r < 0)
                return log_error_errno(r, "Failed to allocate importer: %m");

        r = tar_import_pull(import, url, local, arg_force);
        if (r < 0)
                return log_error_errno(r, "Failed to pull image: %m");

        r = sd_event_loop(event);
        if (r < 0)
                return log_error_errno(r, "Failed to run event loop: %m");

        log_info("Exiting.");

        return 0;
}

static void on_raw_finished(RawImport *import, int error, void *userdata) {
        sd_event *event = userdata;
        assert(import);

        if (error == 0)
                log_info("Operation completed successfully.");
        else
                log_error_errno(error, "Operation failed: %m");

        sd_event_exit(event, error);
}

static int strip_raw_suffixes(const char *p, char **ret) {
        static const char suffixes[] =
                ".xz\0"
                ".raw\0"
                ".qcow2\0"
                ".img\0";

        _cleanup_free_ char *q = NULL;

        q = strdup(p);
        if (!q)
                return -ENOMEM;

        for (;;) {
                const char *sfx;
                bool changed = false;

                NULSTR_FOREACH(sfx, suffixes) {
                        char *e;

                        e = endswith(q, sfx);
                        if (e) {
                                *e = 0;
                                changed = true;
                        }
                }

                if (!changed)
                        break;
        }

        *ret = q;
        q = NULL;

        return 0;
}

static int pull_raw(int argc, char *argv[], void *userdata) {
        _cleanup_(raw_import_unrefp) RawImport *import = NULL;
        _cleanup_event_unref_ sd_event *event = NULL;
        const char *url, *local;
        _cleanup_free_ char *l = NULL, *ll = NULL;
        int r;

        url = argv[1];
        if (!http_url_is_valid(url)) {
                log_error("URL '%s' is not valid.", url);
                return -EINVAL;
        }

        if (argc >= 3)
                local = argv[2];
        else {
                r = import_url_last_component(url, &l);
                if (r < 0)
                        return log_error_errno(r, "Failed get final component of URL: %m");

                local = l;
        }

        if (isempty(local) || streq(local, "-"))
                local = NULL;

        if (local) {
                r = strip_raw_suffixes(local, &ll);
                if (r < 0)
                        return log_oom();

                local = ll;

                if (!machine_name_is_valid(local)) {
                        log_error("Local image name '%s' is not valid.", local);
                        return -EINVAL;
                }

                if (!arg_force) {
                        r = image_find(local, NULL);
                        if (r < 0)
                                return log_error_errno(r, "Failed to check whether image '%s' exists: %m", local);
                        else if (r > 0) {
                                log_error_errno(EEXIST, "Image '%s' already exists.", local);
                                return -EEXIST;
                        }
                }

                log_info("Pulling '%s', saving as '%s'.", url, local);
        } else
                log_info("Pulling '%s'.", url);

        r = sd_event_default(&event);
        if (r < 0)
                return log_error_errno(r, "Failed to allocate event loop: %m");

        assert_se(sigprocmask_many(SIG_BLOCK, SIGTERM, SIGINT, -1) == 0);
        sd_event_add_signal(event, NULL, SIGTERM, NULL,  NULL);
        sd_event_add_signal(event, NULL, SIGINT, NULL, NULL);

        r = raw_import_new(&import, event, arg_image_root, on_raw_finished, event);
        if (r < 0)
                return log_error_errno(r, "Failed to allocate importer: %m");

        r = raw_import_pull(import, url, local, arg_force);
        if (r < 0)
                return log_error_errno(r, "Failed to pull image: %m");

        r = sd_event_loop(event);
        if (r < 0)
                return log_error_errno(r, "Failed to run event loop: %m");

        log_info("Exiting.");

        return 0;
}

static void on_dkr_finished(DkrImport *import, int error, void *userdata) {
        sd_event *event = userdata;
        assert(import);

        if (error == 0)
                log_info("Operation completed successfully.");
        else
                log_error_errno(error, "Operation failed: %m");

        sd_event_exit(event, error);
}

static int pull_dkr(int argc, char *argv[], void *userdata) {
        _cleanup_(dkr_import_unrefp) DkrImport *import = NULL;
        _cleanup_event_unref_ sd_event *event = NULL;
        const char *name, *tag, *local;
        int r;

        if (!arg_dkr_index_url) {
                log_error("Please specify an index URL with --dkr-index-url=");
                return -EINVAL;
        }

        tag = strchr(argv[1], ':');
        if (tag) {
                name = strndupa(argv[1], tag - argv[1]);
                tag++;
        } else {
                name = argv[1];
                tag = "latest";
        }

        if (!dkr_name_is_valid(name)) {
                log_error("Remote name '%s' is not valid.", name);
                return -EINVAL;
        }

        if (!dkr_tag_is_valid(tag)) {
                log_error("Tag name '%s' is not valid.", tag);
                return -EINVAL;
        }

        if (argc >= 3)
                local = argv[2];
        else {
                local = strchr(name, '/');
                if (local)
                        local++;
                else
                        local = name;
        }

        if (isempty(local) || streq(local, "-"))
                local = NULL;

        if (local) {
                const char *p;

                if (!machine_name_is_valid(local)) {
                        log_error("Local image name '%s' is not valid.", local);
                        return -EINVAL;
                }

                p = strappenda(arg_image_root, "/", local);
                if (laccess(p, F_OK) >= 0) {
                        if (!arg_force) {
                                log_info("Image '%s' already exists.", local);
                                return 0;
                        }
                } else if (errno != ENOENT)
                        return log_error_errno(errno, "Can't check if image '%s' already exists: %m", local);

                log_info("Pulling '%s' with tag '%s', saving as '%s'.", name, tag, local);
        } else
                log_info("Pulling '%s' with tag '%s'.", name, tag);

        r = sd_event_default(&event);
        if (r < 0)
                return log_error_errno(r, "Failed to allocate event loop: %m");

        assert_se(sigprocmask_many(SIG_BLOCK, SIGTERM, SIGINT, -1) == 0);
        sd_event_add_signal(event, NULL, SIGTERM, NULL,  NULL);
        sd_event_add_signal(event, NULL, SIGINT, NULL, NULL);

        r = dkr_import_new(&import, event, arg_dkr_index_url, arg_image_root, on_dkr_finished, event);
        if (r < 0)
                return log_error_errno(r, "Failed to allocate importer: %m");

        r = dkr_import_pull(import, name, tag, local, arg_force);
        if (r < 0)
                return log_error_errno(r, "Failed to pull image: %m");

        r = sd_event_loop(event);
        if (r < 0)
                return log_error_errno(r, "Failed to run event loop: %m");

        log_info("Exiting.");

        return 0;
}

static int help(int argc, char *argv[], void *userdata) {

        printf("%s [OPTIONS...] {COMMAND} ...\n\n"
               "Import container or virtual machine image.\n\n"
               "  -h --help                   Show this help\n"
               "     --version                Show package version\n"
               "     --force                  Force creation of image\n"
               "     --image-root=            Image root directory\n"
               "     --dkr-index-url=URL      Specify index URL to use for downloads\n\n"
               "Commands:\n"
               "  pull-tar URL [NAME]         Download a TAR image\n"
               "  pull-raw URL [NAME]         Download a RAW image\n"
               "  pull-dkr REMOTE [NAME]      Download a DKR image\n",
               program_invocation_short_name);

        return 0;
}

static int parse_argv(int argc, char *argv[]) {

        enum {
                ARG_VERSION = 0x100,
                ARG_FORCE,
                ARG_DKR_INDEX_URL,
                ARG_IMAGE_ROOT,
        };

        static const struct option options[] = {
                { "help",            no_argument,       NULL, 'h'                 },
                { "version",         no_argument,       NULL, ARG_VERSION         },
                { "force",           no_argument,       NULL, ARG_FORCE           },
                { "dkr-index-url",   required_argument, NULL, ARG_DKR_INDEX_URL   },
                { "image-root",      required_argument, NULL, ARG_IMAGE_ROOT      },
                {}
        };

        int c;

        assert(argc >= 0);
        assert(argv);

        while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0)

                switch (c) {

                case 'h':
                        return help(0, NULL, NULL);

                case ARG_VERSION:
                        puts(PACKAGE_STRING);
                        puts(SYSTEMD_FEATURES);
                        return 0;

                case ARG_FORCE:
                        arg_force = true;
                        break;

                case ARG_DKR_INDEX_URL:
                        if (!dkr_url_is_valid(optarg)) {
                                log_error("Index URL is not valid: %s", optarg);
                                return -EINVAL;
                        }

                        arg_dkr_index_url = optarg;
                        break;

                case ARG_IMAGE_ROOT:
                        arg_image_root = optarg;
                        break;

                case '?':
                        return -EINVAL;

                default:
                        assert_not_reached("Unhandled option");
                }

        return 1;
}

static int import_main(int argc, char *argv[]) {

        static const Verb verbs[] = {
                { "help",     VERB_ANY, VERB_ANY, 0, help     },
                { "pull-tar", 2,        3,        0, pull_tar },
                { "pull-raw", 2,        3,        0, pull_raw },
                { "pull-dkr", 2,        3,        0, pull_dkr },
                {}
        };

        return dispatch_verb(argc, argv, verbs, NULL);
}

int main(int argc, char *argv[]) {
        int r;

        setlocale(LC_ALL, "");
        log_parse_environment();
        log_open();

        r = parse_argv(argc, argv);
        if (r <= 0)
                goto finish;

        r = import_main(argc, argv);

finish:
        return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
}
Commit	Line	Data
72648326 LP	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
	2
	3	/***
	4	This file is part of systemd.
	5
	6	Copyright 2014 Lennart Poettering
	7
	8	systemd is free software; you can redistribute it and/or modify it
	9	under the terms of the GNU Lesser General Public License as published by
	10	the Free Software Foundation; either version 2.1 of the License, or
	11	(at your option) any later version.
	12
	13	systemd is distributed in the hope that it will be useful, but
	14	WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	Lesser General Public License for more details.
	17
	18	You should have received a copy of the GNU Lesser General Public License
	19	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	20	***/
	21
	22	#include <getopt.h>
	23
	24	#include "sd-event.h"
	25	#include "event-util.h"
	26	#include "verbs.h"
	27	#include "build.h"
56ebfaf1 LP	28	#include "machine-image.h"
56ebfaf1 LP	29	#include "import-tar.h"
aceac2f0	30	#include "import-raw.h"
91f4347e	31	#include "import-dkr.h"
85dbc41d	32	#include "import-util.h"
72648326 LP	33
72648326 LP	34	static bool arg_force = false;
5f129649	35	static const char *arg_image_root = "/var/lib/machines";
72648326	36
91f4347e LP	37	static const char* arg_dkr_index_url = DEFAULT_DKR_INDEX_URL;
91f4347e LP	38
56ebfaf1 LP	39	static void on_tar_finished(TarImport import, int error, void userdata) {
	40	sd_event *event = userdata;
	41	assert(import);
	42
	43	if (error == 0)
	44	log_info("Operation completed successfully.");
	45	else
	46	log_error_errno(error, "Operation failed: %m");
	47
	48	sd_event_exit(event, error);
	49	}
	50
56ebfaf1 LP	51	static int strip_tar_suffixes(const char name, char *ret) {
	52	const char *e;
	53	char *s;
	54
	55	e = endswith(name, ".tar");
	56	if (!e)
	57	e = endswith(name, ".tar.gz");
	58	if (!e)
	59	e = endswith(name, ".tar.xz");
	60	if (!e)
	61	e = endswith(name, ".tgz");
	62	if (!e)
	63	e = strchr(name, 0);
	64
	65	if (e <= name)
	66	return -EINVAL;
	67
	68	s = strndup(name, e - name);
	69	if (!s)
	70	return -ENOMEM;
	71
	72	*ret = s;
	73	return 0;
	74	}
	75
	76	static int pull_tar(int argc, char argv[], void userdata) {
	77	_cleanup_(tar_import_unrefp) TarImport *import = NULL;
	78	_cleanup_event_unref_ sd_event *event = NULL;
	79	const char url, local;
	80	_cleanup_free_ char l = NULL, ll = NULL;
	81	int r;
	82
	83	url = argv[1];
	84	if (!http_url_is_valid(url)) {
	85	log_error("URL '%s' is not valid.", url);
	86	return -EINVAL;
	87	}
	88
	89	if (argc >= 3)
	90	local = argv[2];
	91	else {
85dbc41d	92	r = import_url_last_component(url, &l);
56ebfaf1 LP	93	if (r < 0)
	94	return log_error_errno(r, "Failed get final component of URL: %m");
	95
	96	local = l;
	97	}
	98
	99	if (isempty(local) \|\| streq(local, "-"))
	100	local = NULL;
	101
	102	if (local) {
	103	r = strip_tar_suffixes(local, &ll);
	104	if (r < 0)
	105	return log_oom();
	106
	107	local = ll;
	108
	109	if (!machine_name_is_valid(local)) {
	110	log_error("Local image name '%s' is not valid.", local);
	111	return -EINVAL;
	112	}
	113
	114	if (!arg_force) {
	115	r = image_find(local, NULL);
	116	if (r < 0)
	117	return log_error_errno(r, "Failed to check whether image '%s' exists: %m", local);
	118	else if (r > 0) {
	119	log_error_errno(EEXIST, "Image '%s' already exists.", local);
	120	return -EEXIST;
	121	}
	122	}
	123
	124	log_info("Pulling '%s', saving as '%s'.", url, local);
	125	} else
	126	log_info("Pulling '%s'.", url);
	127
	128	r = sd_event_default(&event);
	129	if (r < 0)
	130	return log_error_errno(r, "Failed to allocate event loop: %m");
	131
	132	assert_se(sigprocmask_many(SIG_BLOCK, SIGTERM, SIGINT, -1) == 0);
	133	sd_event_add_signal(event, NULL, SIGTERM, NULL, NULL);
	134	sd_event_add_signal(event, NULL, SIGINT, NULL, NULL);
	135
	136	r = tar_import_new(&import, event, arg_image_root, on_tar_finished, event);
	137	if (r < 0)
	138	return log_error_errno(r, "Failed to allocate importer: %m");
	139
	140	r = tar_import_pull(import, url, local, arg_force);
	141	if (r < 0)
	142	return log_error_errno(r, "Failed to pull image: %m");
	143
	144	r = sd_event_loop(event);
	145	if (r < 0)
	146	return log_error_errno(r, "Failed to run event loop: %m");
	147
	148	log_info("Exiting.");
	149
	150	return 0;
	151	}
	152
aceac2f0	153	static void on_raw_finished(RawImport import, int error, void userdata) {
90199220 LP	154	sd_event *event = userdata;
	155	assert(import);
	156
	157	if (error == 0)
	158	log_info("Operation completed successfully.");
	159	else
56ebfaf1	160	log_error_errno(error, "Operation failed: %m");
90199220 LP	161
	162	sd_event_exit(event, error);
	163	}
	164
edce2aed LP	165	static int strip_raw_suffixes(const char p, char *ret) {
	166	static const char suffixes[] =
	167	".xz\0"
	168	".raw\0"
	169	".qcow2\0"
	170	".img\0";
	171
	172	_cleanup_free_ char *q = NULL;
	173
	174	q = strdup(p);
	175	if (!q)
	176	return -ENOMEM;
	177
	178	for (;;) {
	179	const char *sfx;
	180	bool changed = false;
	181
	182	NULSTR_FOREACH(sfx, suffixes) {
	183	char *e;
	184
	185	e = endswith(q, sfx);
	186	if (e) {
	187	*e = 0;
	188	changed = true;
	189	}
	190	}
	191
	192	if (!changed)
	193	break;
	194	}
	195
	196	*ret = q;
	197	q = NULL;
	198
	199	return 0;
	200	}
	201
aceac2f0 LP	202	static int pull_raw(int argc, char argv[], void userdata) {
aceac2f0 LP	203	_cleanup_(raw_import_unrefp) RawImport *import = NULL;
90199220	204	_cleanup_event_unref_ sd_event *event = NULL;
edce2aed	205	const char url, local;
0d6e763b	206	_cleanup_free_ char l = NULL, ll = NULL;
90199220 LP	207	int r;
	208
	209	url = argv[1];
a2e03378	210	if (!http_url_is_valid(url)) {
90199220 LP	211	log_error("URL '%s' is not valid.", url);
	212	return -EINVAL;
	213	}
	214
8620a9a3 LP	215	if (argc >= 3)
	216	local = argv[2];
	217	else {
85dbc41d	218	r = import_url_last_component(url, &l);
0d6e763b LP	219	if (r < 0)
0d6e763b LP	220	return log_error_errno(r, "Failed get final component of URL: %m");
90199220	221
0d6e763b	222	local = l;
90199220 LP	223	}
90199220 LP	224
8620a9a3 LP	225	if (isempty(local) \|\| streq(local, "-"))
8620a9a3 LP	226	local = NULL;
90199220	227
8620a9a3	228	if (local) {
0d6e763b	229	r = strip_raw_suffixes(local, &ll);
edce2aed LP	230	if (r < 0)
	231	return log_oom();
	232
0d6e763b	233	local = ll;
8620a9a3 LP	234
	235	if (!machine_name_is_valid(local)) {
	236	log_error("Local image name '%s' is not valid.", local);
	237	return -EINVAL;
	238	}
	239
0d6e763b LP	240	if (!arg_force) {
	241	r = image_find(local, NULL);
	242	if (r < 0)
	243	return log_error_errno(r, "Failed to check whether image '%s' exists: %m", local);
	244	else if (r > 0) {
	245	log_error_errno(EEXIST, "Image '%s' already exists.", local);
	246	return -EEXIST;
8620a9a3	247	}
0d6e763b	248	}
90199220	249
8620a9a3 LP	250	log_info("Pulling '%s', saving as '%s'.", url, local);
	251	} else
	252	log_info("Pulling '%s'.", url);
90199220 LP	253
	254	r = sd_event_default(&event);
	255	if (r < 0)
	256	return log_error_errno(r, "Failed to allocate event loop: %m");
	257
	258	assert_se(sigprocmask_many(SIG_BLOCK, SIGTERM, SIGINT, -1) == 0);
	259	sd_event_add_signal(event, NULL, SIGTERM, NULL, NULL);
	260	sd_event_add_signal(event, NULL, SIGINT, NULL, NULL);
	261
aceac2f0	262	r = raw_import_new(&import, event, arg_image_root, on_raw_finished, event);
90199220 LP	263	if (r < 0)
	264	return log_error_errno(r, "Failed to allocate importer: %m");
	265
aceac2f0	266	r = raw_import_pull(import, url, local, arg_force);
90199220 LP	267	if (r < 0)
	268	return log_error_errno(r, "Failed to pull image: %m");
	269
	270	r = sd_event_loop(event);
	271	if (r < 0)
	272	return log_error_errno(r, "Failed to run event loop: %m");
	273
	274	log_info("Exiting.");
	275
	276	return 0;
	277	}
	278
	279	static void on_dkr_finished(DkrImport import, int error, void userdata) {
72648326 LP	280	sd_event *event = userdata;
	281	assert(import);
	282
	283	if (error == 0)
	284	log_info("Operation completed successfully.");
	285	else
56ebfaf1	286	log_error_errno(error, "Operation failed: %m");
72648326 LP	287
	288	sd_event_exit(event, error);
	289	}
	290
91f4347e LP	291	static int pull_dkr(int argc, char argv[], void userdata) {
91f4347e LP	292	_cleanup_(dkr_import_unrefp) DkrImport *import = NULL;
72648326 LP	293	_cleanup_event_unref_ sd_event *event = NULL;
	294	const char name, tag, *local;
	295	int r;
	296
91f4347e LP	297	if (!arg_dkr_index_url) {
	298	log_error("Please specify an index URL with --dkr-index-url=");
	299	return -EINVAL;
	300	}
	301
72648326 LP	302	tag = strchr(argv[1], ':');
	303	if (tag) {
	304	name = strndupa(argv[1], tag - argv[1]);
	305	tag++;
	306	} else {
	307	name = argv[1];
	308	tag = "latest";
	309	}
	310
8620a9a3 LP	311	if (!dkr_name_is_valid(name)) {
	312	log_error("Remote name '%s' is not valid.", name);
	313	return -EINVAL;
	314	}
	315
	316	if (!dkr_tag_is_valid(tag)) {
	317	log_error("Tag name '%s' is not valid.", tag);
	318	return -EINVAL;
	319	}
	320
72648326 LP	321	if (argc >= 3)
	322	local = argv[2];
	323	else {
	324	local = strchr(name, '/');
	325	if (local)
	326	local++;
	327	else
	328	local = name;
	329	}
	330
0c7bf33a	331	if (isempty(local) \|\| streq(local, "-"))
72648326 LP	332	local = NULL;
72648326 LP	333
72648326 LP	334	if (local) {
	335	const char *p;
	336
0c7bf33a	337	if (!machine_name_is_valid(local)) {
72648326 LP	338	log_error("Local image name '%s' is not valid.", local);
	339	return -EINVAL;
	340	}
	341
087682d1	342	p = strappenda(arg_image_root, "/", local);
72648326 LP	343	if (laccess(p, F_OK) >= 0) {
	344	if (!arg_force) {
	345	log_info("Image '%s' already exists.", local);
	346	return 0;
	347	}
	348	} else if (errno != ENOENT)
	349	return log_error_errno(errno, "Can't check if image '%s' already exists: %m", local);
	350
	351	log_info("Pulling '%s' with tag '%s', saving as '%s'.", name, tag, local);
	352	} else
	353	log_info("Pulling '%s' with tag '%s'.", name, tag);
	354
	355	r = sd_event_default(&event);
	356	if (r < 0)
	357	return log_error_errno(r, "Failed to allocate event loop: %m");
	358
	359	assert_se(sigprocmask_many(SIG_BLOCK, SIGTERM, SIGINT, -1) == 0);
	360	sd_event_add_signal(event, NULL, SIGTERM, NULL, NULL);
	361	sd_event_add_signal(event, NULL, SIGINT, NULL, NULL);
	362
087682d1	363	r = dkr_import_new(&import, event, arg_dkr_index_url, arg_image_root, on_dkr_finished, event);
72648326 LP	364	if (r < 0)
	365	return log_error_errno(r, "Failed to allocate importer: %m");
	366
ea1ae8c3	367	r = dkr_import_pull(import, name, tag, local, arg_force);
72648326 LP	368	if (r < 0)
	369	return log_error_errno(r, "Failed to pull image: %m");
	370
	371	r = sd_event_loop(event);
	372	if (r < 0)
	373	return log_error_errno(r, "Failed to run event loop: %m");
	374
	375	log_info("Exiting.");
	376
	377	return 0;
	378	}
	379
	380	static int help(int argc, char argv[], void userdata) {
	381
	382	printf("%s [OPTIONS...] {COMMAND} ...\n\n"
	383	"Import container or virtual machine image.\n\n"
	384	" -h --help Show this help\n"
	385	" --version Show package version\n"
91f4347e	386	" --force Force creation of image\n"
087682d1	387	" --image-root= Image root directory\n"
91f4347e	388	" --dkr-index-url=URL Specify index URL to use for downloads\n\n"
72648326	389	"Commands:\n"
0d6e763b	390	" pull-tar URL [NAME] Download a TAR image\n"
56ebfaf1 LP	391	" pull-raw URL [NAME] Download a RAW image\n"
56ebfaf1 LP	392	" pull-dkr REMOTE [NAME] Download a DKR image\n",
72648326 LP	393	program_invocation_short_name);
	394
	395	return 0;
	396	}
	397
	398	static int parse_argv(int argc, char *argv[]) {
	399
	400	enum {
	401	ARG_VERSION = 0x100,
	402	ARG_FORCE,
91f4347e	403	ARG_DKR_INDEX_URL,
087682d1	404	ARG_IMAGE_ROOT,
72648326 LP	405	};
	406
	407	static const struct option options[] = {
	408	{ "help", no_argument, NULL, 'h' },
	409	{ "version", no_argument, NULL, ARG_VERSION },
	410	{ "force", no_argument, NULL, ARG_FORCE },
91f4347e	411	{ "dkr-index-url", required_argument, NULL, ARG_DKR_INDEX_URL },
087682d1	412	{ "image-root", required_argument, NULL, ARG_IMAGE_ROOT },
72648326 LP	413	{}
	414	};
	415
	416	int c;
	417
	418	assert(argc >= 0);
	419	assert(argv);
	420
	421	while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0)
	422
	423	switch (c) {
	424
	425	case 'h':
7eeeb28e	426	return help(0, NULL, NULL);
72648326 LP	427
	428	case ARG_VERSION:
	429	puts(PACKAGE_STRING);
	430	puts(SYSTEMD_FEATURES);
	431	return 0;
	432
	433	case ARG_FORCE:
	434	arg_force = true;
	435	break;
	436
91f4347e LP	437	case ARG_DKR_INDEX_URL:
	438	if (!dkr_url_is_valid(optarg)) {
	439	log_error("Index URL is not valid: %s", optarg);
	440	return -EINVAL;
	441	}
	442
	443	arg_dkr_index_url = optarg;
	444	break;
	445
087682d1 LP	446	case ARG_IMAGE_ROOT:
	447	arg_image_root = optarg;
	448	break;
	449
72648326 LP	450	case '?':
	451	return -EINVAL;
	452
	453	default:
	454	assert_not_reached("Unhandled option");
	455	}
	456
	457	return 1;
	458	}
	459
	460	static int import_main(int argc, char *argv[]) {
	461
7eeeb28e	462	static const Verb verbs[] = {
72648326	463	{ "help", VERB_ANY, VERB_ANY, 0, help },
56ebfaf1	464	{ "pull-tar", 2, 3, 0, pull_tar },
aceac2f0	465	{ "pull-raw", 2, 3, 0, pull_raw },
56ebfaf1	466	{ "pull-dkr", 2, 3, 0, pull_dkr },
72648326 LP	467	{}
	468	};
	469
	470	return dispatch_verb(argc, argv, verbs, NULL);
	471	}
	472
	473	int main(int argc, char *argv[]) {
	474	int r;
	475
	476	setlocale(LC_ALL, "");
	477	log_parse_environment();
	478	log_open();
	479
	480	r = parse_argv(argc, argv);
	481	if (r <= 0)
	482	goto finish;
	483
	484	r = import_main(argc, argv);
	485
	486	finish:
	487	return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
	488	}