chiark / gitweb /
201c5ab35688907a8cdf0045b350680ce6c5a746
[elogind.git] / src / import / export.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4   This file is part of systemd.
5
6   Copyright 2015 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"
28 #include "machine-image.h"
29 #include "import-util.h"
30 #include "export-tar.h"
31 #include "export-raw.h"
32
33 static ImportCompressType arg_compress = IMPORT_COMPRESS_UNKNOWN;
34
35 static void determine_compression_from_filename(const char *p) {
36
37         if (arg_compress != IMPORT_COMPRESS_UNKNOWN)
38                 return;
39
40         if (!p) {
41                 arg_compress = IMPORT_COMPRESS_UNCOMPRESSED;
42                 return;
43         }
44
45         if (endswith(p, ".xz"))
46                 arg_compress = IMPORT_COMPRESS_XZ;
47         else if (endswith(p, ".gz"))
48                 arg_compress = IMPORT_COMPRESS_GZIP;
49         else if (endswith(p, ".bz2"))
50                 arg_compress = IMPORT_COMPRESS_BZIP2;
51         else
52                 arg_compress = IMPORT_COMPRESS_UNCOMPRESSED;
53 }
54
55 static int interrupt_signal_handler(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
56         log_notice("Transfer aborted.");
57         sd_event_exit(sd_event_source_get_event(s), EINTR);
58         return 0;
59 }
60
61 static void on_tar_finished(TarExport *export, int error, void *userdata) {
62         sd_event *event = userdata;
63         assert(export);
64
65         if (error == 0)
66                 log_info("Operation completed successfully.");
67
68         sd_event_exit(event, abs(error));
69 }
70
71 static int export_tar(int argc, char *argv[], void *userdata) {
72         _cleanup_(tar_export_unrefp) TarExport *export = NULL;
73         _cleanup_event_unref_ sd_event *event = NULL;
74         _cleanup_(image_unrefp) Image *image = NULL;
75         const char *path = NULL, *local = NULL;
76         _cleanup_close_ int open_fd = -1;
77         int r, fd;
78
79         if (machine_name_is_valid(argv[1])) {
80                 r = image_find(argv[1], &image);
81                 if (r < 0)
82                         return log_error_errno(r, "Failed to look for machine %s: %m", argv[1]);
83                 if (r == 0) {
84                         log_error("Machine image %s not found.", argv[1]);
85                         return -ENOENT;
86                 }
87
88                 local = image->path;
89         } else
90                 local = argv[1];
91
92         if (argc >= 3)
93                 path = argv[2];
94         if (isempty(path) || streq(path, "-"))
95                 path = NULL;
96
97         determine_compression_from_filename(path);
98
99         if (path) {
100                 open_fd = open(path, O_WRONLY|O_CREAT|O_TRUNC|O_CLOEXEC|O_NOCTTY, 0666);
101                 if (open_fd < 0)
102                         return log_error_errno(errno, "Failed to open tar image for export: %m");
103
104                 fd = open_fd;
105
106                 log_info("Exporting '%s', saving to '%s' with compression '%s'.", local, path, import_compress_type_to_string(arg_compress));
107         } else {
108                 _cleanup_free_ char *pretty = NULL;
109
110                 fd = STDOUT_FILENO;
111
112                 (void) readlink_malloc("/proc/self/fd/1", &pretty);
113                 log_info("Exporting '%s', saving to '%s' with compression '%s'.", local, strna(pretty), import_compress_type_to_string(arg_compress));
114         }
115
116         r = sd_event_default(&event);
117         if (r < 0)
118                 return log_error_errno(r, "Failed to allocate event loop: %m");
119
120         assert_se(sigprocmask_many(SIG_BLOCK, SIGTERM, SIGINT, -1) == 0);
121         sd_event_add_signal(event, NULL, SIGTERM, interrupt_signal_handler,  NULL);
122         sd_event_add_signal(event, NULL, SIGINT, interrupt_signal_handler, NULL);
123
124         r = tar_export_new(&export, event, on_tar_finished, event);
125         if (r < 0)
126                 return log_error_errno(r, "Failed to allocate exporter: %m");
127
128         r = tar_export_start(export, local, fd, arg_compress);
129         if (r < 0)
130                 return log_error_errno(r, "Failed to export image: %m");
131
132         r = sd_event_loop(event);
133         if (r < 0)
134                 return log_error_errno(r, "Failed to run event loop: %m");
135
136         log_info("Exiting.");
137         return -r;
138 }
139
140 static void on_raw_finished(RawExport *export, int error, void *userdata) {
141         sd_event *event = userdata;
142         assert(export);
143
144         if (error == 0)
145                 log_info("Operation completed successfully.");
146
147         sd_event_exit(event, abs(error));
148 }
149
150 static int export_raw(int argc, char *argv[], void *userdata) {
151         _cleanup_(raw_export_unrefp) RawExport *export = NULL;
152         _cleanup_event_unref_ sd_event *event = NULL;
153         _cleanup_(image_unrefp) Image *image = NULL;
154         const char *path = NULL, *local = NULL;
155         _cleanup_close_ int open_fd = -1;
156         int r, fd;
157
158         if (machine_name_is_valid(argv[1])) {
159                 r = image_find(argv[1], &image);
160                 if (r < 0)
161                         return log_error_errno(r, "Failed to look for machine %s: %m", argv[1]);
162                 if (r == 0) {
163                         log_error("Machine image %s not found.", argv[1]);
164                         return -ENOENT;
165                 }
166
167                 local = image->path;
168         } else
169                 local = argv[1];
170
171         if (argc >= 3)
172                 path = argv[2];
173         if (isempty(path) || streq(path, "-"))
174                 path = NULL;
175
176         determine_compression_from_filename(path);
177
178         if (path) {
179                 open_fd = open(path, O_WRONLY|O_CREAT|O_TRUNC|O_CLOEXEC|O_NOCTTY, 0666);
180                 if (open_fd < 0)
181                         return log_error_errno(errno, "Failed to open raw image for export: %m");
182
183                 fd = open_fd;
184
185                 log_info("Exporting '%s', saving to '%s' with compression '%s'.", local, path, import_compress_type_to_string(arg_compress));
186         } else {
187                 _cleanup_free_ char *pretty = NULL;
188
189                 fd = STDOUT_FILENO;
190
191                 (void) readlink_malloc("/proc/self/fd/1", &pretty);
192                 log_info("Exporting '%s', saving to '%s' with compression '%s'.", local, strna(pretty), import_compress_type_to_string(arg_compress));
193         }
194
195         r = sd_event_default(&event);
196         if (r < 0)
197                 return log_error_errno(r, "Failed to allocate event loop: %m");
198
199         assert_se(sigprocmask_many(SIG_BLOCK, SIGTERM, SIGINT, -1) == 0);
200         sd_event_add_signal(event, NULL, SIGTERM, interrupt_signal_handler,  NULL);
201         sd_event_add_signal(event, NULL, SIGINT, interrupt_signal_handler, NULL);
202
203         r = raw_export_new(&export, event, on_raw_finished, event);
204         if (r < 0)
205                 return log_error_errno(r, "Failed to allocate exporter: %m");
206
207         r = raw_export_start(export, local, fd, arg_compress);
208         if (r < 0)
209                 return log_error_errno(r, "Failed to export image: %m");
210
211         r = sd_event_loop(event);
212         if (r < 0)
213                 return log_error_errno(r, "Failed to run event loop: %m");
214
215         log_info("Exiting.");
216         return -r;
217 }
218
219 static int help(int argc, char *argv[], void *userdata) {
220
221         printf("%s [OPTIONS...] {COMMAND} ...\n\n"
222                "Export container or virtual machine images.\n\n"
223                "  -h --help                    Show this help\n"
224                "     --version                 Show package version\n"
225                "     --format=FORMAT           Select format\n\n"
226                "Commands:\n"
227                "  tar NAME [FILE]              Export a TAR image\n"
228                "  raw NAME [FILE]              Export a RAW image\n",
229                program_invocation_short_name);
230
231         return 0;
232 }
233
234 static int parse_argv(int argc, char *argv[]) {
235
236         enum {
237                 ARG_VERSION = 0x100,
238                 ARG_FORMAT,
239         };
240
241         static const struct option options[] = {
242                 { "help",    no_argument,       NULL, 'h'         },
243                 { "version", no_argument,       NULL, ARG_VERSION },
244                 { "format",  required_argument, NULL, ARG_FORMAT  },
245                 {}
246         };
247
248         int c;
249
250         assert(argc >= 0);
251         assert(argv);
252
253         while ((c = getopt_long(argc, argv, "h", options, NULL)) >= 0)
254
255                 switch (c) {
256
257                 case 'h':
258                         return help(0, NULL, NULL);
259
260                 case ARG_VERSION:
261                         puts(PACKAGE_STRING);
262                         puts(SYSTEMD_FEATURES);
263                         return 0;
264
265                 case ARG_FORMAT:
266                         if (streq(optarg, "uncompressed"))
267                                 arg_compress = IMPORT_COMPRESS_UNCOMPRESSED;
268                         else if (streq(optarg, "xz"))
269                                 arg_compress = IMPORT_COMPRESS_XZ;
270                         else if (streq(optarg, "gzip"))
271                                 arg_compress = IMPORT_COMPRESS_GZIP;
272                         else if (streq(optarg, "bzip2"))
273                                 arg_compress = IMPORT_COMPRESS_BZIP2;
274                         else {
275                                 log_error("Unknown format: %s", optarg);
276                                 return -EINVAL;
277                         }
278                         break;
279
280                 case '?':
281                         return -EINVAL;
282
283                 default:
284                         assert_not_reached("Unhandled option");
285                 }
286
287         return 1;
288 }
289
290 static int export_main(int argc, char *argv[]) {
291
292         static const Verb verbs[] = {
293                 { "help", VERB_ANY, VERB_ANY, 0, help       },
294                 { "tar",  2,        3,        0, export_tar },
295                 { "raw",  2,        3,        0, export_raw },
296                 {}
297         };
298
299         return dispatch_verb(argc, argv, verbs, NULL);
300 }
301
302 int main(int argc, char *argv[]) {
303         int r;
304
305         setlocale(LC_ALL, "");
306         log_parse_environment();
307         log_open();
308
309         r = parse_argv(argc, argv);
310         if (r <= 0)
311                 goto finish;
312
313         ignore_signals(SIGPIPE, -1);
314
315         r = export_main(argc, argv);
316
317 finish:
318         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
319 }