]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/machine/machinectl.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
man: document "machinectl export-tar" and "export-raw"
[thirdparty/systemd.git] / src / machine / machinectl.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4 This file is part of systemd.
5
6 Copyright 2013 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 <sys/socket.h>
23 #include <unistd.h>
24 #include <errno.h>
25 #include <string.h>
26 #include <getopt.h>
27 #include <locale.h>
28 #include <fcntl.h>
29 #include <netinet/in.h>
30 #include <arpa/inet.h>
31 #include <net/if.h>
32 #include <sys/mount.h>
33
34 #include "sd-bus.h"
35 #include "log.h"
36 #include "util.h"
37 #include "macro.h"
38 #include "pager.h"
39 #include "spawn-polkit-agent.h"
40 #include "bus-util.h"
41 #include "bus-error.h"
42 #include "build.h"
43 #include "strv.h"
44 #include "unit-name.h"
45 #include "cgroup-show.h"
46 #include "logs-show.h"
47 #include "cgroup-util.h"
48 #include "ptyfwd.h"
49 #include "event-util.h"
50 #include "path-util.h"
51 #include "mkdir.h"
52 #include "copy.h"
53 #include "verbs.h"
54 #include "import-util.h"
55
56 static char **arg_property = NULL;
57 static bool arg_all = false;
58 static bool arg_full = false;
59 static bool arg_no_pager = false;
60 static bool arg_legend = true;
61 static const char *arg_kill_who = NULL;
62 static int arg_signal = SIGTERM;
63 static BusTransport arg_transport = BUS_TRANSPORT_LOCAL;
64 static char *arg_host = NULL;
65 static bool arg_read_only = false;
66 static bool arg_mkdir = false;
67 static bool arg_quiet = false;
68 static bool arg_ask_password = true;
69 static unsigned arg_lines = 10;
70 static OutputMode arg_output = OUTPUT_SHORT;
71 static bool arg_force = false;
72 static ImportVerify arg_verify = IMPORT_VERIFY_SIGNATURE;
73 static const char* arg_dkr_index_url = NULL;
74 static const char* arg_format = NULL;
75
76 static void pager_open_if_enabled(void) {
77
78 if (arg_no_pager)
79 return;
80
81 pager_open(false);
82 }
83
84 static void polkit_agent_open_if_enabled(void) {
85
86 /* Open the polkit agent as a child process if necessary */
87
88 if (!arg_ask_password)
89 return;
90
91 if (arg_transport != BUS_TRANSPORT_LOCAL)
92 return;
93
94 polkit_agent_open();
95 }
96
97 static OutputFlags get_output_flags(void) {
98 return
99 arg_all * OUTPUT_SHOW_ALL |
100 arg_full * OUTPUT_FULL_WIDTH |
101 (!on_tty() || pager_have()) * OUTPUT_FULL_WIDTH |
102 on_tty() * OUTPUT_COLOR |
103 !arg_quiet * OUTPUT_WARN_CUTOFF;
104 }
105
106 typedef struct MachineInfo {
107 const char *name;
108 const char *class;
109 const char *service;
110 } MachineInfo;
111
112 static int compare_machine_info(const void *a, const void *b) {
113 const MachineInfo *x = a, *y = b;
114
115 return strcmp(x->name, y->name);
116 }
117
118 static int list_machines(int argc, char *argv[], void *userdata) {
119
120 size_t max_name = strlen("MACHINE"), max_class = strlen("CLASS"), max_service = strlen("SERVICE");
121 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
122 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
123 _cleanup_free_ MachineInfo *machines = NULL;
124 const char *name, *class, *service, *object;
125 size_t n_machines = 0, n_allocated = 0, j;
126 sd_bus *bus = userdata;
127 int r;
128
129 assert(bus);
130
131 pager_open_if_enabled();
132
133 r = sd_bus_call_method(
134 bus,
135 "org.freedesktop.machine1",
136 "/org/freedesktop/machine1",
137 "org.freedesktop.machine1.Manager",
138 "ListMachines",
139 &error,
140 &reply,
141 NULL);
142 if (r < 0) {
143 log_error("Could not get machines: %s", bus_error_message(&error, -r));
144 return r;
145 }
146
147 r = sd_bus_message_enter_container(reply, 'a', "(ssso)");
148 if (r < 0)
149 return bus_log_parse_error(r);
150
151 while ((r = sd_bus_message_read(reply, "(ssso)", &name, &class, &service, &object)) > 0) {
152 size_t l;
153
154 if (!GREEDY_REALLOC(machines, n_allocated, n_machines + 1))
155 return log_oom();
156
157 machines[n_machines].name = name;
158 machines[n_machines].class = class;
159 machines[n_machines].service = service;
160
161 l = strlen(name);
162 if (l > max_name)
163 max_name = l;
164
165 l = strlen(class);
166 if (l > max_class)
167 max_class = l;
168
169 l = strlen(service);
170 if (l > max_service)
171 max_service = l;
172
173 n_machines ++;
174 }
175 if (r < 0)
176 return bus_log_parse_error(r);
177
178 r = sd_bus_message_exit_container(reply);
179 if (r < 0)
180 return bus_log_parse_error(r);
181
182 qsort_safe(machines, n_machines, sizeof(MachineInfo), compare_machine_info);
183
184 if (arg_legend)
185 printf("%-*s %-*s %-*s\n",
186 (int) max_name, "MACHINE",
187 (int) max_class, "CLASS",
188 (int) max_service, "SERVICE");
189
190 for (j = 0; j < n_machines; j++)
191 printf("%-*s %-*s %-*s\n",
192 (int) max_name, machines[j].name,
193 (int) max_class, machines[j].class,
194 (int) max_service, machines[j].service);
195
196 if (arg_legend)
197 printf("\n%zu machines listed.\n", n_machines);
198
199 return 0;
200 }
201
202 typedef struct ImageInfo {
203 const char *name;
204 const char *type;
205 bool read_only;
206 usec_t crtime;
207 usec_t mtime;
208 uint64_t size;
209 } ImageInfo;
210
211 static int compare_image_info(const void *a, const void *b) {
212 const ImageInfo *x = a, *y = b;
213
214 return strcmp(x->name, y->name);
215 }
216
217 static int list_images(int argc, char *argv[], void *userdata) {
218
219 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
220 size_t max_name = strlen("NAME"), max_type = strlen("TYPE"), max_size = strlen("USAGE"), max_crtime = strlen("CREATED"), max_mtime = strlen("MODIFIED");
221 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
222 _cleanup_free_ ImageInfo *images = NULL;
223 size_t n_images = 0, n_allocated = 0, j;
224 const char *name, *type, *object;
225 sd_bus *bus = userdata;
226 uint64_t crtime, mtime, size;
227 int read_only, r;
228
229 assert(bus);
230
231 pager_open_if_enabled();
232
233 r = sd_bus_call_method(
234 bus,
235 "org.freedesktop.machine1",
236 "/org/freedesktop/machine1",
237 "org.freedesktop.machine1.Manager",
238 "ListImages",
239 &error,
240 &reply,
241 "");
242 if (r < 0) {
243 log_error("Could not get images: %s", bus_error_message(&error, -r));
244 return r;
245 }
246
247 r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ssbttto)");
248 if (r < 0)
249 return bus_log_parse_error(r);
250
251 while ((r = sd_bus_message_read(reply, "(ssbttto)", &name, &type, &read_only, &crtime, &mtime, &size, &object)) > 0) {
252 char buf[MAX(FORMAT_TIMESTAMP_MAX, FORMAT_BYTES_MAX)];
253 size_t l;
254
255 if (name[0] == '.' && !arg_all)
256 continue;
257
258 if (!GREEDY_REALLOC(images, n_allocated, n_images + 1))
259 return log_oom();
260
261 images[n_images].name = name;
262 images[n_images].type = type;
263 images[n_images].read_only = read_only;
264 images[n_images].crtime = crtime;
265 images[n_images].mtime = mtime;
266 images[n_images].size = size;
267
268 l = strlen(name);
269 if (l > max_name)
270 max_name = l;
271
272 l = strlen(type);
273 if (l > max_type)
274 max_type = l;
275
276 if (crtime != 0) {
277 l = strlen(strna(format_timestamp(buf, sizeof(buf), crtime)));
278 if (l > max_crtime)
279 max_crtime = l;
280 }
281
282 if (mtime != 0) {
283 l = strlen(strna(format_timestamp(buf, sizeof(buf), mtime)));
284 if (l > max_mtime)
285 max_mtime = l;
286 }
287
288 if (size != (uint64_t) -1) {
289 l = strlen(strna(format_bytes(buf, sizeof(buf), size)));
290 if (l > max_size)
291 max_size = l;
292 }
293
294 n_images++;
295 }
296 if (r < 0)
297 return bus_log_parse_error(r);
298
299 r = sd_bus_message_exit_container(reply);
300 if (r < 0)
301 return bus_log_parse_error(r);
302
303 qsort_safe(images, n_images, sizeof(ImageInfo), compare_image_info);
304
305 if (arg_legend)
306 printf("%-*s %-*s %-3s %-*s %-*s %-*s\n",
307 (int) max_name, "NAME",
308 (int) max_type, "TYPE",
309 "RO",
310 (int) max_size, "USAGE",
311 (int) max_crtime, "CREATED",
312 (int) max_mtime, "MODIFIED");
313
314 for (j = 0; j < n_images; j++) {
315 char crtime_buf[FORMAT_TIMESTAMP_MAX], mtime_buf[FORMAT_TIMESTAMP_MAX], size_buf[FORMAT_BYTES_MAX];
316
317 printf("%-*s %-*s %s%-3s%s %-*s %-*s %-*s\n",
318 (int) max_name, images[j].name,
319 (int) max_type, images[j].type,
320 images[j].read_only ? ansi_highlight_red() : "", yes_no(images[j].read_only), images[j].read_only ? ansi_highlight_off() : "",
321 (int) max_size, strna(format_bytes(size_buf, sizeof(size_buf), images[j].size)),
322 (int) max_crtime, strna(format_timestamp(crtime_buf, sizeof(crtime_buf), images[j].crtime)),
323 (int) max_mtime, strna(format_timestamp(mtime_buf, sizeof(mtime_buf), images[j].mtime)));
324 }
325
326 if (arg_legend)
327 printf("\n%zu images listed.\n", n_images);
328
329 return 0;
330 }
331
332 static int show_unit_cgroup(sd_bus *bus, const char *unit, pid_t leader) {
333 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
334 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
335 _cleanup_free_ char *path = NULL;
336 const char *cgroup;
337 int r;
338 unsigned c;
339
340 assert(bus);
341 assert(unit);
342
343 if (arg_transport == BUS_TRANSPORT_REMOTE)
344 return 0;
345
346 path = unit_dbus_path_from_name(unit);
347 if (!path)
348 return log_oom();
349
350 r = sd_bus_get_property(
351 bus,
352 "org.freedesktop.systemd1",
353 path,
354 endswith(unit, ".scope") ? "org.freedesktop.systemd1.Scope" : "org.freedesktop.systemd1.Service",
355 "ControlGroup",
356 &error,
357 &reply,
358 "s");
359 if (r < 0) {
360 log_error("Failed to query ControlGroup: %s", bus_error_message(&error, -r));
361 return r;
362 }
363
364 r = sd_bus_message_read(reply, "s", &cgroup);
365 if (r < 0)
366 return bus_log_parse_error(r);
367
368 if (isempty(cgroup))
369 return 0;
370
371 if (cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, cgroup, false) != 0 && leader <= 0)
372 return 0;
373
374 c = columns();
375 if (c > 18)
376 c -= 18;
377 else
378 c = 0;
379
380 show_cgroup_and_extra(SYSTEMD_CGROUP_CONTROLLER, cgroup, "\t\t ", c, false, &leader, leader > 0, get_output_flags());
381 return 0;
382 }
383
384 static int print_addresses(sd_bus *bus, const char *name, int ifi, const char *prefix, const char *prefix2) {
385 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
386 int r;
387
388 assert(bus);
389 assert(name);
390 assert(prefix);
391 assert(prefix2);
392
393 r = sd_bus_call_method(bus,
394 "org.freedesktop.machine1",
395 "/org/freedesktop/machine1",
396 "org.freedesktop.machine1.Manager",
397 "GetMachineAddresses",
398 NULL,
399 &reply,
400 "s", name);
401 if (r < 0)
402 return r;
403
404 r = sd_bus_message_enter_container(reply, 'a', "(iay)");
405 if (r < 0)
406 return bus_log_parse_error(r);
407
408 while ((r = sd_bus_message_enter_container(reply, 'r', "iay")) > 0) {
409 int family;
410 const void *a;
411 size_t sz;
412 char buffer[MAX(INET6_ADDRSTRLEN, INET_ADDRSTRLEN)];
413
414 r = sd_bus_message_read(reply, "i", &family);
415 if (r < 0)
416 return bus_log_parse_error(r);
417
418 r = sd_bus_message_read_array(reply, 'y', &a, &sz);
419 if (r < 0)
420 return bus_log_parse_error(r);
421
422 fputs(prefix, stdout);
423 fputs(inet_ntop(family, a, buffer, sizeof(buffer)), stdout);
424 if (family == AF_INET6 && ifi > 0)
425 printf("%%%i", ifi);
426 fputc('\n', stdout);
427
428 r = sd_bus_message_exit_container(reply);
429 if (r < 0)
430 return bus_log_parse_error(r);
431
432 if (prefix != prefix2)
433 prefix = prefix2;
434 }
435 if (r < 0)
436 return bus_log_parse_error(r);
437
438 r = sd_bus_message_exit_container(reply);
439 if (r < 0)
440 return bus_log_parse_error(r);
441
442 return 0;
443 }
444
445 static int print_os_release(sd_bus *bus, const char *name, const char *prefix) {
446 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
447 const char *k, *v, *pretty = NULL;
448 int r;
449
450 assert(bus);
451 assert(name);
452 assert(prefix);
453
454 r = sd_bus_call_method(bus,
455 "org.freedesktop.machine1",
456 "/org/freedesktop/machine1",
457 "org.freedesktop.machine1.Manager",
458 "GetMachineOSRelease",
459 NULL,
460 &reply,
461 "s", name);
462 if (r < 0)
463 return r;
464
465 r = sd_bus_message_enter_container(reply, 'a', "{ss}");
466 if (r < 0)
467 return bus_log_parse_error(r);
468
469 while ((r = sd_bus_message_read(reply, "{ss}", &k, &v)) > 0) {
470 if (streq(k, "PRETTY_NAME"))
471 pretty = v;
472
473 }
474 if (r < 0)
475 return bus_log_parse_error(r);
476
477 r = sd_bus_message_exit_container(reply);
478 if (r < 0)
479 return bus_log_parse_error(r);
480
481 if (pretty)
482 printf("%s%s\n", prefix, pretty);
483
484 return 0;
485 }
486
487 typedef struct MachineStatusInfo {
488 char *name;
489 sd_id128_t id;
490 char *class;
491 char *service;
492 char *unit;
493 char *root_directory;
494 pid_t leader;
495 struct dual_timestamp timestamp;
496 int *netif;
497 unsigned n_netif;
498 } MachineStatusInfo;
499
500 static void print_machine_status_info(sd_bus *bus, MachineStatusInfo *i) {
501 char since1[FORMAT_TIMESTAMP_RELATIVE_MAX], *s1;
502 char since2[FORMAT_TIMESTAMP_MAX], *s2;
503 int ifi = -1;
504
505 assert(bus);
506 assert(i);
507
508 fputs(strna(i->name), stdout);
509
510 if (!sd_id128_equal(i->id, SD_ID128_NULL))
511 printf("(" SD_ID128_FORMAT_STR ")\n", SD_ID128_FORMAT_VAL(i->id));
512 else
513 putchar('\n');
514
515 s1 = format_timestamp_relative(since1, sizeof(since1), i->timestamp.realtime);
516 s2 = format_timestamp(since2, sizeof(since2), i->timestamp.realtime);
517
518 if (s1)
519 printf("\t Since: %s; %s\n", s2, s1);
520 else if (s2)
521 printf("\t Since: %s\n", s2);
522
523 if (i->leader > 0) {
524 _cleanup_free_ char *t = NULL;
525
526 printf("\t Leader: %u", (unsigned) i->leader);
527
528 get_process_comm(i->leader, &t);
529 if (t)
530 printf(" (%s)", t);
531
532 putchar('\n');
533 }
534
535 if (i->service) {
536 printf("\t Service: %s", i->service);
537
538 if (i->class)
539 printf("; class %s", i->class);
540
541 putchar('\n');
542 } else if (i->class)
543 printf("\t Class: %s\n", i->class);
544
545 if (i->root_directory)
546 printf("\t Root: %s\n", i->root_directory);
547
548 if (i->n_netif > 0) {
549 unsigned c;
550
551 fputs("\t Iface:", stdout);
552
553 for (c = 0; c < i->n_netif; c++) {
554 char name[IF_NAMESIZE+1] = "";
555
556 if (if_indextoname(i->netif[c], name)) {
557 fputc(' ', stdout);
558 fputs(name, stdout);
559
560 if (ifi < 0)
561 ifi = i->netif[c];
562 else
563 ifi = 0;
564 } else
565 printf(" %i", i->netif[c]);
566 }
567
568 fputc('\n', stdout);
569 }
570
571 print_addresses(bus, i->name, ifi,
572 "\t Address: ",
573 "\t ");
574
575 print_os_release(bus, i->name, "\t OS: ");
576
577 if (i->unit) {
578 printf("\t Unit: %s\n", i->unit);
579 show_unit_cgroup(bus, i->unit, i->leader);
580
581 if (arg_transport == BUS_TRANSPORT_LOCAL) {
582
583 show_journal_by_unit(
584 stdout,
585 i->unit,
586 arg_output,
587 0,
588 i->timestamp.monotonic,
589 arg_lines,
590 0,
591 get_output_flags() | OUTPUT_BEGIN_NEWLINE,
592 SD_JOURNAL_LOCAL_ONLY,
593 true,
594 NULL);
595 }
596 }
597 }
598
599 static int map_netif(sd_bus *bus, const char *member, sd_bus_message *m, sd_bus_error *error, void *userdata) {
600 MachineStatusInfo *i = userdata;
601 size_t l;
602 const void *v;
603 int r;
604
605 assert_cc(sizeof(int32_t) == sizeof(int));
606 r = sd_bus_message_read_array(m, SD_BUS_TYPE_INT32, &v, &l);
607 if (r < 0)
608 return r;
609 if (r == 0)
610 return -EBADMSG;
611
612 i->n_netif = l / sizeof(int32_t);
613 i->netif = memdup(v, l);
614 if (!i->netif)
615 return -ENOMEM;
616
617 return 0;
618 }
619
620 static int show_machine_info(const char *verb, sd_bus *bus, const char *path, bool *new_line) {
621
622 static const struct bus_properties_map map[] = {
623 { "Name", "s", NULL, offsetof(MachineStatusInfo, name) },
624 { "Class", "s", NULL, offsetof(MachineStatusInfo, class) },
625 { "Service", "s", NULL, offsetof(MachineStatusInfo, service) },
626 { "Unit", "s", NULL, offsetof(MachineStatusInfo, unit) },
627 { "RootDirectory", "s", NULL, offsetof(MachineStatusInfo, root_directory) },
628 { "Leader", "u", NULL, offsetof(MachineStatusInfo, leader) },
629 { "Timestamp", "t", NULL, offsetof(MachineStatusInfo, timestamp.realtime) },
630 { "TimestampMonotonic", "t", NULL, offsetof(MachineStatusInfo, timestamp.monotonic) },
631 { "Id", "ay", bus_map_id128, offsetof(MachineStatusInfo, id) },
632 { "NetworkInterfaces", "ai", map_netif, 0 },
633 {}
634 };
635
636 MachineStatusInfo info = {};
637 int r;
638
639 assert(verb);
640 assert(bus);
641 assert(path);
642 assert(new_line);
643
644 r = bus_map_all_properties(bus,
645 "org.freedesktop.machine1",
646 path,
647 map,
648 &info);
649 if (r < 0)
650 return log_error_errno(r, "Could not get properties: %m");
651
652 if (*new_line)
653 printf("\n");
654 *new_line = true;
655
656 print_machine_status_info(bus, &info);
657
658 free(info.name);
659 free(info.class);
660 free(info.service);
661 free(info.unit);
662 free(info.root_directory);
663 free(info.netif);
664
665 return r;
666 }
667
668 static int show_machine_properties(sd_bus *bus, const char *path, bool *new_line) {
669 int r;
670
671 assert(bus);
672 assert(path);
673 assert(new_line);
674
675 if (*new_line)
676 printf("\n");
677
678 *new_line = true;
679
680 r = bus_print_all_properties(bus, "org.freedesktop.machine1", path, arg_property, arg_all);
681 if (r < 0)
682 log_error_errno(r, "Could not get properties: %m");
683
684 return r;
685 }
686
687 static int show_machine(int argc, char *argv[], void *userdata) {
688
689 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
690 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
691 bool properties, new_line = false;
692 sd_bus *bus = userdata;
693 int r = 0, i;
694
695 assert(bus);
696
697 properties = !strstr(argv[0], "status");
698
699 pager_open_if_enabled();
700
701 if (properties && argc <= 1) {
702
703 /* If no argument is specified, inspect the manager
704 * itself */
705 r = show_machine_properties(bus, "/org/freedesktop/machine1", &new_line);
706 if (r < 0)
707 return r;
708 }
709
710 for (i = 1; i < argc; i++) {
711 const char *path = NULL;
712
713 r = sd_bus_call_method(
714 bus,
715 "org.freedesktop.machine1",
716 "/org/freedesktop/machine1",
717 "org.freedesktop.machine1.Manager",
718 "GetMachine",
719 &error,
720 &reply,
721 "s", argv[i]);
722 if (r < 0) {
723 log_error("Could not get path to machine: %s", bus_error_message(&error, -r));
724 return r;
725 }
726
727 r = sd_bus_message_read(reply, "o", &path);
728 if (r < 0)
729 return bus_log_parse_error(r);
730
731 if (properties)
732 r = show_machine_properties(bus, path, &new_line);
733 else
734 r = show_machine_info(argv[0], bus, path, &new_line);
735 }
736
737 return r;
738 }
739
740 typedef struct ImageStatusInfo {
741 char *name;
742 char *path;
743 char *type;
744 int read_only;
745 usec_t crtime;
746 usec_t mtime;
747 uint64_t usage;
748 uint64_t limit;
749 uint64_t usage_exclusive;
750 uint64_t limit_exclusive;
751 } ImageStatusInfo;
752
753 static void print_image_status_info(sd_bus *bus, ImageStatusInfo *i) {
754 char ts_relative[FORMAT_TIMESTAMP_RELATIVE_MAX], *s1;
755 char ts_absolute[FORMAT_TIMESTAMP_MAX], *s2;
756 char bs[FORMAT_BYTES_MAX], *s3;
757 char bs_exclusive[FORMAT_BYTES_MAX], *s4;
758
759 assert(bus);
760 assert(i);
761
762 if (i->name) {
763 fputs(i->name, stdout);
764 putchar('\n');
765 }
766
767 if (i->type)
768 printf("\t Type: %s\n", i->type);
769
770 if (i->path)
771 printf("\t Path: %s\n", i->path);
772
773 printf("\t RO: %s%s%s\n",
774 i->read_only ? ansi_highlight_red() : "",
775 i->read_only ? "read-only" : "writable",
776 i->read_only ? ansi_highlight_off() : "");
777
778 s1 = format_timestamp_relative(ts_relative, sizeof(ts_relative), i->crtime);
779 s2 = format_timestamp(ts_absolute, sizeof(ts_absolute), i->crtime);
780 if (s1 && s2)
781 printf("\t Created: %s; %s\n", s2, s1);
782 else if (s2)
783 printf("\t Created: %s\n", s2);
784
785 s1 = format_timestamp_relative(ts_relative, sizeof(ts_relative), i->mtime);
786 s2 = format_timestamp(ts_absolute, sizeof(ts_absolute), i->mtime);
787 if (s1 && s2)
788 printf("\tModified: %s; %s\n", s2, s1);
789 else if (s2)
790 printf("\tModified: %s\n", s2);
791
792 s3 = format_bytes(bs, sizeof(bs), i->usage);
793 s4 = i->usage_exclusive != i->usage ? format_bytes(bs_exclusive, sizeof(bs_exclusive), i->usage_exclusive) : NULL;
794 if (s3 && s4)
795 printf("\t Usage: %s (exclusive: %s)\n", s3, s4);
796 else if (s3)
797 printf("\t Usage: %s\n", s3);
798
799 s3 = format_bytes(bs, sizeof(bs), i->limit);
800 s4 = i->limit_exclusive != i->limit ? format_bytes(bs_exclusive, sizeof(bs_exclusive), i->limit_exclusive) : NULL;
801 if (s3 && s4)
802 printf("\t Limit: %s (exclusive: %s)\n", s3, s4);
803 else if (s3)
804 printf("\t Limit: %s\n", s3);
805 }
806
807 static int show_image_info(sd_bus *bus, const char *path, bool *new_line) {
808
809 static const struct bus_properties_map map[] = {
810 { "Name", "s", NULL, offsetof(ImageStatusInfo, name) },
811 { "Path", "s", NULL, offsetof(ImageStatusInfo, path) },
812 { "Type", "s", NULL, offsetof(ImageStatusInfo, type) },
813 { "ReadOnly", "b", NULL, offsetof(ImageStatusInfo, read_only) },
814 { "CreationTimestamp", "t", NULL, offsetof(ImageStatusInfo, crtime) },
815 { "ModificationTimestamp", "t", NULL, offsetof(ImageStatusInfo, mtime) },
816 { "Usage", "t", NULL, offsetof(ImageStatusInfo, usage) },
817 { "Limit", "t", NULL, offsetof(ImageStatusInfo, limit) },
818 { "UsageExclusive", "t", NULL, offsetof(ImageStatusInfo, usage_exclusive) },
819 { "LimitExclusive", "t", NULL, offsetof(ImageStatusInfo, limit_exclusive) },
820 {}
821 };
822
823 ImageStatusInfo info = {};
824 int r;
825
826 assert(bus);
827 assert(path);
828 assert(new_line);
829
830 r = bus_map_all_properties(bus,
831 "org.freedesktop.machine1",
832 path,
833 map,
834 &info);
835 if (r < 0)
836 return log_error_errno(r, "Could not get properties: %m");
837
838 if (*new_line)
839 printf("\n");
840 *new_line = true;
841
842 print_image_status_info(bus, &info);
843
844 free(info.name);
845 free(info.path);
846 free(info.type);
847
848 return r;
849 }
850
851 typedef struct PoolStatusInfo {
852 char *path;
853 uint64_t usage;
854 uint64_t limit;
855 } PoolStatusInfo;
856
857 static void print_pool_status_info(sd_bus *bus, PoolStatusInfo *i) {
858 char bs[FORMAT_BYTES_MAX], *s;
859
860 if (i->path)
861 printf("\t Path: %s\n", i->path);
862
863 s = format_bytes(bs, sizeof(bs), i->usage);
864 if (s)
865 printf("\t Usage: %s\n", s);
866
867 s = format_bytes(bs, sizeof(bs), i->limit);
868 if (s)
869 printf("\t Limit: %s\n", s);
870 }
871
872 static int show_pool_info(sd_bus *bus) {
873
874 static const struct bus_properties_map map[] = {
875 { "PoolPath", "s", NULL, offsetof(PoolStatusInfo, path) },
876 { "PoolUsage", "t", NULL, offsetof(PoolStatusInfo, usage) },
877 { "PoolLimit", "t", NULL, offsetof(PoolStatusInfo, limit) },
878 {}
879 };
880
881 PoolStatusInfo info = {
882 .usage = (uint64_t) -1,
883 .limit = (uint64_t) -1,
884 };
885 int r;
886
887 assert(bus);
888
889 r = bus_map_all_properties(bus,
890 "org.freedesktop.machine1",
891 "/org/freedesktop/machine1",
892 map,
893 &info);
894 if (r < 0)
895 return log_error_errno(r, "Could not get properties: %m");
896
897 print_pool_status_info(bus, &info);
898
899 free(info.path);
900 return 0;
901 }
902
903
904 static int show_image_properties(sd_bus *bus, const char *path, bool *new_line) {
905 int r;
906
907 assert(bus);
908 assert(path);
909 assert(new_line);
910
911 if (*new_line)
912 printf("\n");
913
914 *new_line = true;
915
916 r = bus_print_all_properties(bus, "org.freedesktop.machine1", path, arg_property, arg_all);
917 if (r < 0)
918 log_error_errno(r, "Could not get properties: %m");
919
920 return r;
921 }
922
923 static int show_image(int argc, char *argv[], void *userdata) {
924
925 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
926 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
927 bool properties, new_line = false;
928 sd_bus *bus = userdata;
929 int r = 0, i;
930
931 assert(bus);
932
933 properties = !strstr(argv[0], "status");
934
935 pager_open_if_enabled();
936
937 if (argc <= 1) {
938
939 /* If no argument is specified, inspect the manager
940 * itself */
941
942 if (properties)
943 r = show_image_properties(bus, "/org/freedesktop/machine1", &new_line);
944 else
945 r = show_pool_info(bus);
946 if (r < 0)
947 return r;
948 }
949
950 for (i = 1; i < argc; i++) {
951 const char *path = NULL;
952
953 r = sd_bus_call_method(
954 bus,
955 "org.freedesktop.machine1",
956 "/org/freedesktop/machine1",
957 "org.freedesktop.machine1.Manager",
958 "GetImage",
959 &error,
960 &reply,
961 "s", argv[i]);
962 if (r < 0) {
963 log_error("Could not get path to image: %s", bus_error_message(&error, -r));
964 return r;
965 }
966
967 r = sd_bus_message_read(reply, "o", &path);
968 if (r < 0)
969 return bus_log_parse_error(r);
970
971 if (properties)
972 r = show_image_properties(bus, path, &new_line);
973 else
974 r = show_image_info(bus, path, &new_line);
975 }
976
977 return r;
978 }
979
980 static int kill_machine(int argc, char *argv[], void *userdata) {
981 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
982 sd_bus *bus = userdata;
983 int r, i;
984
985 assert(bus);
986
987 polkit_agent_open_if_enabled();
988
989 if (!arg_kill_who)
990 arg_kill_who = "all";
991
992 for (i = 1; i < argc; i++) {
993 r = sd_bus_call_method(
994 bus,
995 "org.freedesktop.machine1",
996 "/org/freedesktop/machine1",
997 "org.freedesktop.machine1.Manager",
998 "KillMachine",
999 &error,
1000 NULL,
1001 "ssi", argv[i], arg_kill_who, arg_signal);
1002 if (r < 0) {
1003 log_error("Could not kill machine: %s", bus_error_message(&error, -r));
1004 return r;
1005 }
1006 }
1007
1008 return 0;
1009 }
1010
1011 static int reboot_machine(int argc, char *argv[], void *userdata) {
1012 arg_kill_who = "leader";
1013 arg_signal = SIGINT; /* sysvinit + systemd */
1014
1015 return kill_machine(argc, argv, userdata);
1016 }
1017
1018 static int poweroff_machine(int argc, char *argv[], void *userdata) {
1019 arg_kill_who = "leader";
1020 arg_signal = SIGRTMIN+4; /* only systemd */
1021
1022 return kill_machine(argc, argv, userdata);
1023 }
1024
1025 static int terminate_machine(int argc, char *argv[], void *userdata) {
1026 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1027 sd_bus *bus = userdata;
1028 int r, i;
1029
1030 assert(bus);
1031
1032 polkit_agent_open_if_enabled();
1033
1034 for (i = 1; i < argc; i++) {
1035 r = sd_bus_call_method(
1036 bus,
1037 "org.freedesktop.machine1",
1038 "/org/freedesktop/machine1",
1039 "org.freedesktop.machine1.Manager",
1040 "TerminateMachine",
1041 &error,
1042 NULL,
1043 "s", argv[i]);
1044 if (r < 0) {
1045 log_error("Could not terminate machine: %s", bus_error_message(&error, -r));
1046 return r;
1047 }
1048 }
1049
1050 return 0;
1051 }
1052
1053 static int copy_files(int argc, char *argv[], void *userdata) {
1054 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1055 sd_bus *bus = userdata;
1056 bool copy_from;
1057 int r;
1058
1059 assert(bus);
1060
1061 polkit_agent_open_if_enabled();
1062
1063 copy_from = streq(argv[0], "copy-from");
1064
1065 r = sd_bus_call_method(
1066 bus,
1067 "org.freedesktop.machine1",
1068 "/org/freedesktop/machine1",
1069 "org.freedesktop.machine1.Manager",
1070 copy_from ? "CopyFromMachine" : "CopyToMachine",
1071 &error,
1072 NULL,
1073 "sss",
1074 argv[1],
1075 argv[2],
1076 argv[3]);
1077 if (r < 0) {
1078 log_error("Failed to copy: %s", bus_error_message(&error, -r));
1079 return r;
1080 }
1081
1082 return 0;
1083 }
1084
1085 static int bind_mount(int argc, char *argv[], void *userdata) {
1086 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1087 sd_bus *bus = userdata;
1088 int r;
1089
1090 assert(bus);
1091
1092 polkit_agent_open_if_enabled();
1093
1094 r = sd_bus_call_method(
1095 bus,
1096 "org.freedesktop.machine1",
1097 "/org/freedesktop/machine1",
1098 "org.freedesktop.machine1.Manager",
1099 "BindMountMachine",
1100 &error,
1101 NULL,
1102 "sssbb",
1103 argv[1],
1104 argv[2],
1105 argv[3],
1106 arg_read_only,
1107 arg_mkdir);
1108 if (r < 0) {
1109 log_error("Failed to bind mount: %s", bus_error_message(&error, -r));
1110 return r;
1111 }
1112
1113 return 0;
1114 }
1115
1116 static int on_machine_removed(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *ret_error) {
1117 PTYForward ** forward = (PTYForward**) userdata;
1118 int r;
1119
1120 assert(bus);
1121 assert(m);
1122 assert(forward);
1123
1124 if (*forward) {
1125 /* If the forwarder is already initialized, tell it to
1126 * exit on the next vhangup(), so that we still flush
1127 * out what might be queued and exit then. */
1128
1129 r = pty_forward_set_ignore_vhangup(*forward, false);
1130 if (r >= 0)
1131 return 0;
1132
1133 log_error_errno(r, "Failed to set ignore_vhangup flag: %m");
1134 }
1135
1136 /* On error, or when the forwarder is not initialized yet, quit immediately */
1137 sd_event_exit(sd_bus_get_event(bus), EXIT_FAILURE);
1138 return 0;
1139 }
1140
1141 static int login_machine(int argc, char *argv[], void *userdata) {
1142 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1143 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1144 _cleanup_bus_slot_unref_ sd_bus_slot *slot = NULL;
1145 _cleanup_(pty_forward_freep) PTYForward *forward = NULL;
1146 _cleanup_event_unref_ sd_event *event = NULL;
1147 int master = -1, r, ret = 0;
1148 sd_bus *bus = userdata;
1149 const char *pty, *match;
1150 char last_char = 0;
1151 bool machine_died;
1152
1153 assert(bus);
1154
1155 if (arg_transport != BUS_TRANSPORT_LOCAL &&
1156 arg_transport != BUS_TRANSPORT_MACHINE) {
1157 log_error("Login only supported on local machines.");
1158 return -ENOTSUP;
1159 }
1160
1161 polkit_agent_open_if_enabled();
1162
1163 r = sd_event_default(&event);
1164 if (r < 0)
1165 return log_error_errno(r, "Failed to get event loop: %m");
1166
1167 r = sd_bus_attach_event(bus, event, 0);
1168 if (r < 0)
1169 return log_error_errno(r, "Failed to attach bus to event loop: %m");
1170
1171 match = strjoina("type='signal',"
1172 "sender='org.freedesktop.machine1',"
1173 "path='/org/freedesktop/machine1',",
1174 "interface='org.freedesktop.machine1.Manager',"
1175 "member='MachineRemoved',"
1176 "arg0='",
1177 argv[1],
1178 "'");
1179
1180 r = sd_bus_add_match(bus, &slot, match, on_machine_removed, &forward);
1181 if (r < 0)
1182 return log_error_errno(r, "Failed to add machine removal match: %m");
1183
1184 r = sd_bus_call_method(
1185 bus,
1186 "org.freedesktop.machine1",
1187 "/org/freedesktop/machine1",
1188 "org.freedesktop.machine1.Manager",
1189 "OpenMachineLogin",
1190 &error,
1191 &reply,
1192 "s", argv[1]);
1193 if (r < 0) {
1194 log_error("Failed to get machine PTY: %s", bus_error_message(&error, -r));
1195 return r;
1196 }
1197
1198 r = sd_bus_message_read(reply, "hs", &master, &pty);
1199 if (r < 0)
1200 return bus_log_parse_error(r);
1201
1202 sigprocmask_many(SIG_BLOCK, SIGWINCH, SIGTERM, SIGINT, -1);
1203
1204 log_info("Connected to machine %s. Press ^] three times within 1s to exit session.", argv[1]);
1205
1206 sd_event_add_signal(event, NULL, SIGINT, NULL, NULL);
1207 sd_event_add_signal(event, NULL, SIGTERM, NULL, NULL);
1208
1209 r = pty_forward_new(event, master, true, false, &forward);
1210 if (r < 0)
1211 return log_error_errno(r, "Failed to create PTY forwarder: %m");
1212
1213 r = sd_event_loop(event);
1214 if (r < 0)
1215 return log_error_errno(r, "Failed to run event loop: %m");
1216
1217 pty_forward_get_last_char(forward, &last_char);
1218 machine_died = pty_forward_get_ignore_vhangup(forward) == 0;
1219
1220 forward = pty_forward_free(forward);
1221
1222 if (last_char != '\n')
1223 fputc('\n', stdout);
1224
1225 if (machine_died)
1226 log_info("Machine %s terminated.", argv[1]);
1227 else
1228 log_info("Connection to machine %s terminated.", argv[1]);
1229
1230 sd_event_get_exit_code(event, &ret);
1231 return ret;
1232 }
1233
1234 static int remove_image(int argc, char *argv[], void *userdata) {
1235 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1236 sd_bus *bus = userdata;
1237 int r, i;
1238
1239 assert(bus);
1240
1241 polkit_agent_open_if_enabled();
1242
1243 for (i = 1; i < argc; i++) {
1244 r = sd_bus_call_method(
1245 bus,
1246 "org.freedesktop.machine1",
1247 "/org/freedesktop/machine1",
1248 "org.freedesktop.machine1.Manager",
1249 "RemoveImage",
1250 &error,
1251 NULL,
1252 "s", argv[i]);
1253 if (r < 0) {
1254 log_error("Could not remove image: %s", bus_error_message(&error, -r));
1255 return r;
1256 }
1257 }
1258
1259 return 0;
1260 }
1261
1262 static int rename_image(int argc, char *argv[], void *userdata) {
1263 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1264 sd_bus *bus = userdata;
1265 int r;
1266
1267 polkit_agent_open_if_enabled();
1268
1269 r = sd_bus_call_method(
1270 bus,
1271 "org.freedesktop.machine1",
1272 "/org/freedesktop/machine1",
1273 "org.freedesktop.machine1.Manager",
1274 "RenameImage",
1275 &error,
1276 NULL,
1277 "ss", argv[1], argv[2]);
1278 if (r < 0) {
1279 log_error("Could not rename image: %s", bus_error_message(&error, -r));
1280 return r;
1281 }
1282
1283 return 0;
1284 }
1285
1286 static int clone_image(int argc, char *argv[], void *userdata) {
1287 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1288 sd_bus *bus = userdata;
1289 int r;
1290
1291 polkit_agent_open_if_enabled();
1292
1293 r = sd_bus_call_method(
1294 bus,
1295 "org.freedesktop.machine1",
1296 "/org/freedesktop/machine1",
1297 "org.freedesktop.machine1.Manager",
1298 "CloneImage",
1299 &error,
1300 NULL,
1301 "ssb", argv[1], argv[2], arg_read_only);
1302 if (r < 0) {
1303 log_error("Could not clone image: %s", bus_error_message(&error, -r));
1304 return r;
1305 }
1306
1307 return 0;
1308 }
1309
1310 static int read_only_image(int argc, char *argv[], void *userdata) {
1311 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1312 sd_bus *bus = userdata;
1313 int b = true, r;
1314
1315 if (argc > 2) {
1316 b = parse_boolean(argv[2]);
1317 if (b < 0) {
1318 log_error("Failed to parse boolean argument: %s", argv[2]);
1319 return -EINVAL;
1320 }
1321 }
1322
1323 polkit_agent_open_if_enabled();
1324
1325 r = sd_bus_call_method(
1326 bus,
1327 "org.freedesktop.machine1",
1328 "/org/freedesktop/machine1",
1329 "org.freedesktop.machine1.Manager",
1330 "MarkImageReadOnly",
1331 &error,
1332 NULL,
1333 "sb", argv[1], b);
1334 if (r < 0) {
1335 log_error("Could not mark image read-only: %s", bus_error_message(&error, -r));
1336 return r;
1337 }
1338
1339 return 0;
1340 }
1341
1342 static int start_machine(int argc, char *argv[], void *userdata) {
1343 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1344 _cleanup_(bus_wait_for_jobs_freep) BusWaitForJobs *w = NULL;
1345 sd_bus *bus = userdata;
1346 int r, i;
1347
1348 assert(bus);
1349
1350 polkit_agent_open_if_enabled();
1351
1352 r = bus_wait_for_jobs_new(bus, &w);
1353 if (r < 0)
1354 return log_oom();
1355
1356 for (i = 1; i < argc; i++) {
1357 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1358 _cleanup_free_ char *e = NULL, *unit = NULL;
1359 const char *object;
1360
1361 if (!machine_name_is_valid(argv[i])) {
1362 log_error("Invalid machine name %s.", argv[i]);
1363 return -EINVAL;
1364 }
1365
1366 e = unit_name_escape(argv[i]);
1367 if (!e)
1368 return log_oom();
1369
1370 unit = unit_name_build("systemd-nspawn", e, ".service");
1371 if (!unit)
1372 return log_oom();
1373
1374 r = sd_bus_call_method(
1375 bus,
1376 "org.freedesktop.systemd1",
1377 "/org/freedesktop/systemd1",
1378 "org.freedesktop.systemd1.Manager",
1379 "StartUnit",
1380 &error,
1381 &reply,
1382 "ss", unit, "fail");
1383 if (r < 0) {
1384 log_error("Failed to start unit: %s", bus_error_message(&error, -r));
1385 return r;
1386 }
1387
1388 r = sd_bus_message_read(reply, "o", &object);
1389 if (r < 0)
1390 return bus_log_parse_error(r);
1391
1392 r = bus_wait_for_jobs_add(w, object);
1393 if (r < 0)
1394 return log_oom();
1395 }
1396
1397 r = bus_wait_for_jobs(w, arg_quiet);
1398 if (r < 0)
1399 return r;
1400
1401 return 0;
1402 }
1403
1404 static int enable_machine(int argc, char *argv[], void *userdata) {
1405 _cleanup_bus_message_unref_ sd_bus_message *m = NULL, *reply = NULL;
1406 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1407 int carries_install_info = 0;
1408 const char *method = NULL;
1409 sd_bus *bus = userdata;
1410 int r, i;
1411
1412 assert(bus);
1413
1414 polkit_agent_open_if_enabled();
1415
1416 method = streq(argv[0], "enable") ? "EnableUnitFiles" : "DisableUnitFiles";
1417
1418 r = sd_bus_message_new_method_call(
1419 bus,
1420 &m,
1421 "org.freedesktop.systemd1",
1422 "/org/freedesktop/systemd1",
1423 "org.freedesktop.systemd1.Manager",
1424 method);
1425 if (r < 0)
1426 return bus_log_create_error(r);
1427
1428 r = sd_bus_message_open_container(m, 'a', "s");
1429 if (r < 0)
1430 return bus_log_create_error(r);
1431
1432 for (i = 1; i < argc; i++) {
1433 _cleanup_free_ char *e = NULL, *unit = NULL;
1434
1435 if (!machine_name_is_valid(argv[i])) {
1436 log_error("Invalid machine name %s.", argv[i]);
1437 return -EINVAL;
1438 }
1439
1440 e = unit_name_escape(argv[i]);
1441 if (!e)
1442 return log_oom();
1443
1444 unit = unit_name_build("systemd-nspawn", e, ".service");
1445 if (!unit)
1446 return log_oom();
1447
1448 r = sd_bus_message_append(m, "s", unit);
1449 if (r < 0)
1450 return bus_log_create_error(r);
1451 }
1452
1453 r = sd_bus_message_close_container(m);
1454 if (r < 0)
1455 return bus_log_create_error(r);
1456
1457 if (streq(argv[0], "enable"))
1458 r = sd_bus_message_append(m, "bb", false, false);
1459 else
1460 r = sd_bus_message_append(m, "b", false);
1461 if (r < 0)
1462 return bus_log_create_error(r);
1463
1464 r = sd_bus_call(bus, m, 0, &error, &reply);
1465 if (r < 0) {
1466 log_error("Failed to enable or disable unit: %s", bus_error_message(&error, -r));
1467 return r;
1468 }
1469
1470 if (streq(argv[0], "enable")) {
1471 r = sd_bus_message_read(reply, "b", carries_install_info);
1472 if (r < 0)
1473 return bus_log_parse_error(r);
1474 }
1475
1476 r = bus_deserialize_and_dump_unit_file_changes(reply, arg_quiet);
1477 if (r < 0)
1478 return r;
1479
1480 r = sd_bus_call_method(
1481 bus,
1482 "org.freedesktop.systemd1",
1483 "/org/freedesktop/systemd1",
1484 "org.freedesktop.systemd1.Manager",
1485 "Reload",
1486 &error,
1487 NULL,
1488 NULL);
1489 if (r < 0) {
1490 log_error("Failed to reload daemon: %s", bus_error_message(&error, -r));
1491 return r;
1492 }
1493
1494 return 0;
1495 }
1496
1497 static int match_log_message(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *error) {
1498 const char **our_path = userdata, *line;
1499 unsigned priority;
1500 int r;
1501
1502 assert(bus);
1503 assert(m);
1504 assert(our_path);
1505
1506 r = sd_bus_message_read(m, "us", &priority, &line);
1507 if (r < 0) {
1508 bus_log_parse_error(r);
1509 return 0;
1510 }
1511
1512 if (!streq_ptr(*our_path, sd_bus_message_get_path(m)))
1513 return 0;
1514
1515 if (arg_quiet && LOG_PRI(priority) >= LOG_INFO)
1516 return 0;
1517
1518 log_full(priority, "%s", line);
1519 return 0;
1520 }
1521
1522 static int match_transfer_removed(sd_bus *bus, sd_bus_message *m, void *userdata, sd_bus_error *error) {
1523 const char **our_path = userdata, *path, *result;
1524 uint32_t id;
1525 int r;
1526
1527 assert(bus);
1528 assert(m);
1529 assert(our_path);
1530
1531 r = sd_bus_message_read(m, "uos", &id, &path, &result);
1532 if (r < 0) {
1533 bus_log_parse_error(r);
1534 return 0;
1535 }
1536
1537 if (!streq_ptr(*our_path, path))
1538 return 0;
1539
1540 sd_event_exit(sd_bus_get_event(bus), !streq_ptr(result, "done"));
1541 return 0;
1542 }
1543
1544 static int transfer_signal_handler(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
1545 assert(s);
1546 assert(si);
1547
1548 if (!arg_quiet)
1549 log_info("Continuing download in the background. Use \"machinectl cancel-transfer %" PRIu32 "\" to abort transfer.", PTR_TO_UINT32(userdata));
1550
1551 sd_event_exit(sd_event_source_get_event(s), EINTR);
1552 return 0;
1553 }
1554
1555 static int transfer_image_common(sd_bus *bus, sd_bus_message *m) {
1556 _cleanup_bus_slot_unref_ sd_bus_slot *slot_job_removed = NULL, *slot_log_message = NULL;
1557 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1558 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1559 _cleanup_event_unref_ sd_event* event = NULL;
1560 const char *path = NULL;
1561 uint32_t id;
1562 int r;
1563
1564 assert(bus);
1565 assert(m);
1566
1567 polkit_agent_open_if_enabled();
1568
1569 r = sd_event_default(&event);
1570 if (r < 0)
1571 return log_error_errno(r, "Failed to get event loop: %m");
1572
1573 r = sd_bus_attach_event(bus, event, 0);
1574 if (r < 0)
1575 return log_error_errno(r, "Failed to attach bus to event loop: %m");
1576
1577 r = sd_bus_add_match(
1578 bus,
1579 &slot_job_removed,
1580 "type='signal',"
1581 "sender='org.freedesktop.import1',"
1582 "interface='org.freedesktop.import1.Manager',"
1583 "member='TransferRemoved',"
1584 "path='/org/freedesktop/import1'",
1585 match_transfer_removed, &path);
1586 if (r < 0)
1587 return log_error_errno(r, "Failed to install match: %m");
1588
1589 r = sd_bus_add_match(
1590 bus,
1591 &slot_log_message,
1592 "type='signal',"
1593 "sender='org.freedesktop.import1',"
1594 "interface='org.freedesktop.import1.Transfer',"
1595 "member='LogMessage'",
1596 match_log_message, &path);
1597 if (r < 0)
1598 return log_error_errno(r, "Failed to install match: %m");
1599
1600 r = sd_bus_call(bus, m, 0, &error, &reply);
1601 if (r < 0) {
1602 log_error("Failed transfer image: %s", bus_error_message(&error, -r));
1603 return r;
1604 }
1605
1606 r = sd_bus_message_read(reply, "uo", &id, &path);
1607 if (r < 0)
1608 return bus_log_parse_error(r);
1609
1610 sigprocmask_many(SIG_BLOCK, SIGTERM, SIGINT, -1);
1611
1612 if (!arg_quiet)
1613 log_info("Enqueued transfer job %u. Press C-c to continue download in background.", id);
1614
1615 sd_event_add_signal(event, NULL, SIGINT, transfer_signal_handler, UINT32_TO_PTR(id));
1616 sd_event_add_signal(event, NULL, SIGTERM, transfer_signal_handler, UINT32_TO_PTR(id));
1617
1618 r = sd_event_loop(event);
1619 if (r < 0)
1620 return log_error_errno(r, "Failed to run event loop: %m");
1621
1622 return -r;
1623 }
1624
1625 static int import_tar(int argc, char *argv[], void *userdata) {
1626 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1627 _cleanup_free_ char *ll = NULL;
1628 _cleanup_close_ int fd = -1;
1629 const char *local = NULL, *path = NULL;
1630 sd_bus *bus = userdata;
1631 int r;
1632
1633 assert(bus);
1634
1635 if (argc >= 2)
1636 path = argv[1];
1637 if (isempty(path) || streq(path, "-"))
1638 path = NULL;
1639
1640 if (argc >= 3)
1641 local = argv[2];
1642 else if (path)
1643 local = basename(path);
1644 if (isempty(local) || streq(local, "-"))
1645 local = NULL;
1646
1647 if (!local) {
1648 log_error("Need either path or local name.");
1649 return -EINVAL;
1650 }
1651
1652 r = tar_strip_suffixes(local, &ll);
1653 if (r < 0)
1654 return log_oom();
1655
1656 local = ll;
1657
1658 if (!machine_name_is_valid(local)) {
1659 log_error("Local name %s is not a suitable machine name.", local);
1660 return -EINVAL;
1661 }
1662
1663 if (path) {
1664 fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY);
1665 if (fd < 0)
1666 return log_error_errno(errno, "Failed to open %s: %m", path);
1667 }
1668
1669 r = sd_bus_message_new_method_call(
1670 bus,
1671 &m,
1672 "org.freedesktop.import1",
1673 "/org/freedesktop/import1",
1674 "org.freedesktop.import1.Manager",
1675 "ImportTar");
1676 if (r < 0)
1677 return bus_log_create_error(r);
1678
1679 r = sd_bus_message_append(
1680 m,
1681 "hsbb",
1682 fd >= 0 ? fd : STDIN_FILENO,
1683 local,
1684 arg_force,
1685 arg_read_only);
1686 if (r < 0)
1687 return bus_log_create_error(r);
1688
1689 return transfer_image_common(bus, m);
1690 }
1691
1692 static int import_raw(int argc, char *argv[], void *userdata) {
1693 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1694 _cleanup_free_ char *ll = NULL;
1695 _cleanup_close_ int fd = -1;
1696 const char *local = NULL, *path = NULL;
1697 sd_bus *bus = userdata;
1698 int r;
1699
1700 assert(bus);
1701
1702 if (argc >= 2)
1703 path = argv[1];
1704 if (isempty(path) || streq(path, "-"))
1705 path = NULL;
1706
1707 if (argc >= 3)
1708 local = argv[2];
1709 else if (path)
1710 local = basename(path);
1711 if (isempty(local) || streq(local, "-"))
1712 local = NULL;
1713
1714 if (!local) {
1715 log_error("Need either path or local name.");
1716 return -EINVAL;
1717 }
1718
1719 r = raw_strip_suffixes(local, &ll);
1720 if (r < 0)
1721 return log_oom();
1722
1723 local = ll;
1724
1725 if (!machine_name_is_valid(local)) {
1726 log_error("Local name %s is not a suitable machine name.", local);
1727 return -EINVAL;
1728 }
1729
1730 if (path) {
1731 fd = open(path, O_RDONLY|O_CLOEXEC|O_NOCTTY);
1732 if (fd < 0)
1733 return log_error_errno(errno, "Failed to open %s: %m", path);
1734 }
1735
1736 r = sd_bus_message_new_method_call(
1737 bus,
1738 &m,
1739 "org.freedesktop.import1",
1740 "/org/freedesktop/import1",
1741 "org.freedesktop.import1.Manager",
1742 "ImportRaw");
1743 if (r < 0)
1744 return bus_log_create_error(r);
1745
1746 r = sd_bus_message_append(
1747 m,
1748 "hsbb",
1749 fd >= 0 ? fd : STDIN_FILENO,
1750 local,
1751 arg_force,
1752 arg_read_only);
1753 if (r < 0)
1754 return bus_log_create_error(r);
1755
1756 return transfer_image_common(bus, m);
1757 }
1758
1759 static void determine_compression_from_filename(const char *p) {
1760 if (arg_format)
1761 return;
1762
1763 if (!p)
1764 return;
1765
1766 if (endswith(p, ".xz"))
1767 arg_format = "xz";
1768 else if (endswith(p, ".gz"))
1769 arg_format = "gzip";
1770 else if (endswith(p, ".bz2"))
1771 arg_format = "bzip2";
1772 }
1773
1774 static int export_tar(int argc, char *argv[], void *userdata) {
1775 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1776 _cleanup_close_ int fd = -1;
1777 const char *local = NULL, *path = NULL;
1778 sd_bus *bus = userdata;
1779 int r;
1780
1781 assert(bus);
1782
1783 local = argv[1];
1784 if (!machine_name_is_valid(local)) {
1785 log_error("Machine name %s is not valid.", local);
1786 return -EINVAL;
1787 }
1788
1789 if (argc >= 3)
1790 path = argv[2];
1791 if (isempty(path) || streq(path, "-"))
1792 path = NULL;
1793
1794 if (path) {
1795 determine_compression_from_filename(path);
1796
1797 fd = open(path, O_WRONLY|O_CREAT|O_TRUNC|O_CLOEXEC|O_NOCTTY, 0666);
1798 if (fd < 0)
1799 return log_error_errno(errno, "Failed to open %s: %m", path);
1800 }
1801
1802 r = sd_bus_message_new_method_call(
1803 bus,
1804 &m,
1805 "org.freedesktop.import1",
1806 "/org/freedesktop/import1",
1807 "org.freedesktop.import1.Manager",
1808 "ExportTar");
1809 if (r < 0)
1810 return bus_log_create_error(r);
1811
1812 r = sd_bus_message_append(
1813 m,
1814 "shs",
1815 local,
1816 fd >= 0 ? fd : STDOUT_FILENO,
1817 arg_format);
1818 if (r < 0)
1819 return bus_log_create_error(r);
1820
1821 return transfer_image_common(bus, m);
1822 }
1823
1824 static int export_raw(int argc, char *argv[], void *userdata) {
1825 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1826 _cleanup_close_ int fd = -1;
1827 const char *local = NULL, *path = NULL;
1828 sd_bus *bus = userdata;
1829 int r;
1830
1831 assert(bus);
1832
1833 local = argv[1];
1834 if (!machine_name_is_valid(local)) {
1835 log_error("Machine name %s is not valid.", local);
1836 return -EINVAL;
1837 }
1838
1839 if (argc >= 3)
1840 path = argv[2];
1841 if (isempty(path) || streq(path, "-"))
1842 path = NULL;
1843
1844 if (path) {
1845 determine_compression_from_filename(path);
1846
1847 fd = open(path, O_WRONLY|O_CREAT|O_TRUNC|O_CLOEXEC|O_NOCTTY, 0666);
1848 if (fd < 0)
1849 return log_error_errno(errno, "Failed to open %s: %m", path);
1850 }
1851
1852 r = sd_bus_message_new_method_call(
1853 bus,
1854 &m,
1855 "org.freedesktop.import1",
1856 "/org/freedesktop/import1",
1857 "org.freedesktop.import1.Manager",
1858 "ExportRaw");
1859 if (r < 0)
1860 return bus_log_create_error(r);
1861
1862 r = sd_bus_message_append(
1863 m,
1864 "shs",
1865 local,
1866 fd >= 0 ? fd : STDOUT_FILENO,
1867 arg_format);
1868 if (r < 0)
1869 return bus_log_create_error(r);
1870
1871 return transfer_image_common(bus, m);
1872 }
1873
1874 static int pull_tar(int argc, char *argv[], void *userdata) {
1875 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1876 _cleanup_free_ char *l = NULL, *ll = NULL;
1877 const char *local, *remote;
1878 sd_bus *bus = userdata;
1879 int r;
1880
1881 assert(bus);
1882
1883 remote = argv[1];
1884 if (!http_url_is_valid(remote)) {
1885 log_error("URL '%s' is not valid.", remote);
1886 return -EINVAL;
1887 }
1888
1889 if (argc >= 3)
1890 local = argv[2];
1891 else {
1892 r = import_url_last_component(remote, &l);
1893 if (r < 0)
1894 return log_error_errno(r, "Failed to get final component of URL: %m");
1895
1896 local = l;
1897 }
1898
1899 if (isempty(local) || streq(local, "-"))
1900 local = NULL;
1901
1902 if (local) {
1903 r = tar_strip_suffixes(local, &ll);
1904 if (r < 0)
1905 return log_oom();
1906
1907 local = ll;
1908
1909 if (!machine_name_is_valid(local)) {
1910 log_error("Local name %s is not a suitable machine name.", local);
1911 return -EINVAL;
1912 }
1913 }
1914
1915 r = sd_bus_message_new_method_call(
1916 bus,
1917 &m,
1918 "org.freedesktop.import1",
1919 "/org/freedesktop/import1",
1920 "org.freedesktop.import1.Manager",
1921 "PullTar");
1922 if (r < 0)
1923 return bus_log_create_error(r);
1924
1925 r = sd_bus_message_append(
1926 m,
1927 "sssb",
1928 remote,
1929 local,
1930 import_verify_to_string(arg_verify),
1931 arg_force);
1932 if (r < 0)
1933 return bus_log_create_error(r);
1934
1935 return transfer_image_common(bus, m);
1936 }
1937
1938 static int pull_raw(int argc, char *argv[], void *userdata) {
1939 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
1940 _cleanup_free_ char *l = NULL, *ll = NULL;
1941 const char *local, *remote;
1942 sd_bus *bus = userdata;
1943 int r;
1944
1945 assert(bus);
1946
1947 remote = argv[1];
1948 if (!http_url_is_valid(remote)) {
1949 log_error("URL '%s' is not valid.", remote);
1950 return -EINVAL;
1951 }
1952
1953 if (argc >= 3)
1954 local = argv[2];
1955 else {
1956 r = import_url_last_component(remote, &l);
1957 if (r < 0)
1958 return log_error_errno(r, "Failed to get final component of URL: %m");
1959
1960 local = l;
1961 }
1962
1963 if (isempty(local) || streq(local, "-"))
1964 local = NULL;
1965
1966 if (local) {
1967 r = raw_strip_suffixes(local, &ll);
1968 if (r < 0)
1969 return log_oom();
1970
1971 local = ll;
1972
1973 if (!machine_name_is_valid(local)) {
1974 log_error("Local name %s is not a suitable machine name.", local);
1975 return -EINVAL;
1976 }
1977 }
1978
1979 r = sd_bus_message_new_method_call(
1980 bus,
1981 &m,
1982 "org.freedesktop.import1",
1983 "/org/freedesktop/import1",
1984 "org.freedesktop.import1.Manager",
1985 "PullRaw");
1986 if (r < 0)
1987 return bus_log_create_error(r);
1988
1989 r = sd_bus_message_append(
1990 m,
1991 "sssb",
1992 remote,
1993 local,
1994 import_verify_to_string(arg_verify),
1995 arg_force);
1996 if (r < 0)
1997 return bus_log_create_error(r);
1998
1999 return transfer_image_common(bus, m);
2000 }
2001
2002 static int pull_dkr(int argc, char *argv[], void *userdata) {
2003 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
2004 const char *local, *remote, *tag;
2005 sd_bus *bus = userdata;
2006 int r;
2007
2008 if (arg_verify != IMPORT_VERIFY_NO) {
2009 log_error("Imports from DKR do not support image verification, please pass --verify=no.");
2010 return -EINVAL;
2011 }
2012
2013 remote = argv[1];
2014 tag = strchr(remote, ':');
2015 if (tag) {
2016 remote = strndupa(remote, tag - remote);
2017 tag++;
2018 }
2019
2020 if (!dkr_name_is_valid(remote)) {
2021 log_error("DKR name '%s' is invalid.", remote);
2022 return -EINVAL;
2023 }
2024 if (tag && !dkr_tag_is_valid(tag)) {
2025 log_error("DKR tag '%s' is invalid.", remote);
2026 return -EINVAL;
2027 }
2028
2029 if (argc >= 3)
2030 local = argv[2];
2031 else {
2032 local = strchr(remote, '/');
2033 if (local)
2034 local++;
2035 else
2036 local = remote;
2037 }
2038
2039 if (isempty(local) || streq(local, "-"))
2040 local = NULL;
2041
2042 if (local) {
2043 if (!machine_name_is_valid(local)) {
2044 log_error("Local name %s is not a suitable machine name.", local);
2045 return -EINVAL;
2046 }
2047 }
2048
2049 r = sd_bus_message_new_method_call(
2050 bus,
2051 &m,
2052 "org.freedesktop.import1",
2053 "/org/freedesktop/import1",
2054 "org.freedesktop.import1.Manager",
2055 "PullDkr");
2056 if (r < 0)
2057 return bus_log_create_error(r);
2058
2059 r = sd_bus_message_append(
2060 m,
2061 "sssssb",
2062 arg_dkr_index_url,
2063 remote,
2064 tag,
2065 local,
2066 import_verify_to_string(arg_verify),
2067 arg_force);
2068 if (r < 0)
2069 return bus_log_create_error(r);
2070
2071 return transfer_image_common(bus, m);
2072 }
2073
2074 typedef struct TransferInfo {
2075 uint32_t id;
2076 const char *type;
2077 const char *remote;
2078 const char *local;
2079 double progress;
2080 } TransferInfo;
2081
2082 static int compare_transfer_info(const void *a, const void *b) {
2083 const TransferInfo *x = a, *y = b;
2084
2085 return strcmp(x->local, y->local);
2086 }
2087
2088 static int list_transfers(int argc, char *argv[], void *userdata) {
2089 size_t max_type = strlen("TYPE"), max_local = strlen("LOCAL"), max_remote = strlen("REMOTE");
2090 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2091 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2092 _cleanup_free_ TransferInfo *transfers = NULL;
2093 size_t n_transfers = 0, n_allocated = 0, j;
2094 const char *type, *remote, *local, *object;
2095 sd_bus *bus = userdata;
2096 uint32_t id, max_id = 0;
2097 double progress;
2098 int r;
2099
2100 pager_open_if_enabled();
2101
2102 r = sd_bus_call_method(
2103 bus,
2104 "org.freedesktop.import1",
2105 "/org/freedesktop/import1",
2106 "org.freedesktop.import1.Manager",
2107 "ListTransfers",
2108 &error,
2109 &reply,
2110 NULL);
2111 if (r < 0) {
2112 log_error("Could not get transfers: %s", bus_error_message(&error, -r));
2113 return r;
2114 }
2115
2116 r = sd_bus_message_enter_container(reply, 'a', "(usssdo)");
2117 if (r < 0)
2118 return bus_log_parse_error(r);
2119
2120 while ((r = sd_bus_message_read(reply, "(usssdo)", &id, &type, &remote, &local, &progress, &object)) > 0) {
2121 size_t l;
2122
2123 if (!GREEDY_REALLOC(transfers, n_allocated, n_transfers + 1))
2124 return log_oom();
2125
2126 transfers[n_transfers].id = id;
2127 transfers[n_transfers].type = type;
2128 transfers[n_transfers].remote = remote;
2129 transfers[n_transfers].local = local;
2130 transfers[n_transfers].progress = progress;
2131
2132 l = strlen(type);
2133 if (l > max_type)
2134 max_type = l;
2135
2136 l = strlen(remote);
2137 if (l > max_remote)
2138 max_remote = l;
2139
2140 l = strlen(local);
2141 if (l > max_local)
2142 max_local = l;
2143
2144 if (id > max_id)
2145 max_id = id;
2146
2147 n_transfers ++;
2148 }
2149 if (r < 0)
2150 return bus_log_parse_error(r);
2151
2152 r = sd_bus_message_exit_container(reply);
2153 if (r < 0)
2154 return bus_log_parse_error(r);
2155
2156 qsort_safe(transfers, n_transfers, sizeof(TransferInfo), compare_transfer_info);
2157
2158 if (arg_legend)
2159 printf("%-*s %-*s %-*s %-*s %-*s\n",
2160 (int) MAX(2U, DECIMAL_STR_WIDTH(max_id)), "ID",
2161 (int) 7, "PERCENT",
2162 (int) max_type, "TYPE",
2163 (int) max_local, "LOCAL",
2164 (int) max_remote, "REMOTE");
2165
2166 for (j = 0; j < n_transfers; j++)
2167 printf("%*" PRIu32 " %*u%% %-*s %-*s %-*s\n",
2168 (int) MAX(2U, DECIMAL_STR_WIDTH(max_id)), transfers[j].id,
2169 (int) 6, (unsigned) (transfers[j].progress * 100),
2170 (int) max_type, transfers[j].type,
2171 (int) max_local, transfers[j].local,
2172 (int) max_remote, transfers[j].remote);
2173
2174 if (arg_legend)
2175 printf("\n%zu transfers listed.\n", n_transfers);
2176
2177 return 0;
2178 }
2179
2180 static int cancel_transfer(int argc, char *argv[], void *userdata) {
2181 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2182 sd_bus *bus = userdata;
2183 int r, i;
2184
2185 assert(bus);
2186
2187 polkit_agent_open_if_enabled();
2188
2189 for (i = 1; i < argc; i++) {
2190 uint32_t id;
2191
2192 r = safe_atou32(argv[i], &id);
2193 if (r < 0)
2194 return log_error_errno(r, "Failed to parse transfer id: %s", argv[i]);
2195
2196 r = sd_bus_call_method(
2197 bus,
2198 "org.freedesktop.import1",
2199 "/org/freedesktop/import1",
2200 "org.freedesktop.import1.Manager",
2201 "CancelTransfer",
2202 &error,
2203 NULL,
2204 "u", id);
2205 if (r < 0) {
2206 log_error("Could not cancel transfer: %s", bus_error_message(&error, -r));
2207 return r;
2208 }
2209 }
2210
2211 return 0;
2212 }
2213
2214 static int set_limit(int argc, char *argv[], void *userdata) {
2215 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2216 sd_bus *bus = userdata;
2217 uint64_t limit;
2218 int r;
2219
2220 if (streq(argv[argc-1], "-"))
2221 limit = (uint64_t) -1;
2222 else {
2223 off_t off;
2224
2225 r = parse_size(argv[argc-1], 1024, &off);
2226 if (r < 0)
2227 return log_error("Failed to parse size: %s", argv[argc-1]);
2228
2229 limit = (uint64_t) off;
2230 }
2231
2232 if (argc > 2)
2233 /* With two arguments changes the quota limit of the
2234 * specified image */
2235 r = sd_bus_call_method(
2236 bus,
2237 "org.freedesktop.machine1",
2238 "/org/freedesktop/machine1",
2239 "org.freedesktop.machine1.Manager",
2240 "SetImageLimit",
2241 &error,
2242 NULL,
2243 "st", argv[1], limit);
2244 else
2245 /* With one argument changes the pool quota limit */
2246 r = sd_bus_call_method(
2247 bus,
2248 "org.freedesktop.machine1",
2249 "/org/freedesktop/machine1",
2250 "org.freedesktop.machine1.Manager",
2251 "SetPoolLimit",
2252 &error,
2253 NULL,
2254 "t", limit);
2255
2256 if (r < 0) {
2257 log_error("Could not set limit: %s", bus_error_message(&error, -r));
2258 return r;
2259 }
2260
2261 return 0;
2262 }
2263
2264 static int help(int argc, char *argv[], void *userdata) {
2265
2266 printf("%s [OPTIONS...] {COMMAND} ...\n\n"
2267 "Send control commands to or query the virtual machine and container\n"
2268 "registration manager.\n\n"
2269 " -h --help Show this help\n"
2270 " --version Show package version\n"
2271 " --no-pager Do not pipe output into a pager\n"
2272 " --no-legend Do not show the headers and footers\n"
2273 " --no-ask-password Do not ask for system passwords\n"
2274 " -H --host=[USER@]HOST Operate on remote host\n"
2275 " -M --machine=CONTAINER Operate on local container\n"
2276 " -p --property=NAME Show only properties by this name\n"
2277 " -q --quiet Suppress output\n"
2278 " -a --all Show all properties, including empty ones\n"
2279 " -l --full Do not ellipsize output\n"
2280 " --kill-who=WHO Who to send signal to\n"
2281 " -s --signal=SIGNAL Which signal to send\n"
2282 " --read-only Create read-only bind mount\n"
2283 " --mkdir Create directory before bind mounting, if missing\n"
2284 " -n --lines=INTEGER Number of journal entries to show\n"
2285 " -o --output=STRING Change journal output mode (short,\n"
2286 " short-monotonic, verbose, export, json,\n"
2287 " json-pretty, json-sse, cat)\n"
2288 " --verify=MODE Verification mode for downloaded images (no,\n"
2289 " checksum, signature)\n"
2290 " --force Download image even if already exists\n"
2291 " --dkr-index-url=URL Specify the index URL to use for DKR image\n"
2292 " downloads\n\n"
2293 "Machine Commands:\n"
2294 " list List running VMs and containers\n"
2295 " status NAME... Show VM/container details\n"
2296 " show NAME... Show properties of one or more VMs/containers\n"
2297 " start NAME... Start container as a service\n"
2298 " login NAME Get a login prompt on a container\n"
2299 " enable NAME... Enable automatic container start at boot\n"
2300 " disable NAME... Disable automatic container start at boot\n"
2301 " poweroff NAME... Power off one or more containers\n"
2302 " reboot NAME... Reboot one or more containers\n"
2303 " terminate NAME... Terminate one or more VMs/containers\n"
2304 " kill NAME... Send signal to processes of a VM/container\n"
2305 " copy-to NAME PATH [PATH] Copy files from the host to a container\n"
2306 " copy-from NAME PATH [PATH] Copy files from a container to the host\n"
2307 " bind NAME PATH [PATH] Bind mount a path from the host into a container\n\n"
2308 "Image Commands:\n"
2309 " list-images Show available container and VM images\n"
2310 " image-status NAME... Show image details\n"
2311 " show-image NAME... Show properties of image\n"
2312 " clone NAME NAME Clone an image\n"
2313 " rename NAME NAME Rename an image\n"
2314 " read-only NAME [BOOL] Mark or unmark image read-only\n"
2315 " remove NAME... Remove an image\n"
2316 " set-limit [NAME] BYTES Set image or pool size limit (disk quota)\n\n"
2317 "Image Transfer Commands:\n"
2318 " pull-tar URL [NAME] Download a TAR container image\n"
2319 " pull-raw URL [NAME] Download a RAW container or VM image\n"
2320 " pull-dkr REMOTE [NAME] Download a DKR container image\n"
2321 " import-tar FILE [NAME] Import a local TAR container image\n"
2322 " import-raw FILE [NAME] Import a local RAW container or VM image\n"
2323 " export-tar NAME [FILE] Export a TAR container image locally\n"
2324 " export-raw NAME [FILE] Export a RAW container or VM image locally\n"
2325 " list-transfers Show list of downloads in progress\n"
2326 " cancel-transfer Cancel a download\n"
2327 , program_invocation_short_name);
2328
2329 return 0;
2330 }
2331
2332 static int parse_argv(int argc, char *argv[]) {
2333
2334 enum {
2335 ARG_VERSION = 0x100,
2336 ARG_NO_PAGER,
2337 ARG_NO_LEGEND,
2338 ARG_KILL_WHO,
2339 ARG_READ_ONLY,
2340 ARG_MKDIR,
2341 ARG_NO_ASK_PASSWORD,
2342 ARG_VERIFY,
2343 ARG_FORCE,
2344 ARG_DKR_INDEX_URL,
2345 ARG_FORMAT,
2346 };
2347
2348 static const struct option options[] = {
2349 { "help", no_argument, NULL, 'h' },
2350 { "version", no_argument, NULL, ARG_VERSION },
2351 { "property", required_argument, NULL, 'p' },
2352 { "all", no_argument, NULL, 'a' },
2353 { "full", no_argument, NULL, 'l' },
2354 { "no-pager", no_argument, NULL, ARG_NO_PAGER },
2355 { "no-legend", no_argument, NULL, ARG_NO_LEGEND },
2356 { "kill-who", required_argument, NULL, ARG_KILL_WHO },
2357 { "signal", required_argument, NULL, 's' },
2358 { "host", required_argument, NULL, 'H' },
2359 { "machine", required_argument, NULL, 'M' },
2360 { "read-only", no_argument, NULL, ARG_READ_ONLY },
2361 { "mkdir", no_argument, NULL, ARG_MKDIR },
2362 { "quiet", no_argument, NULL, 'q' },
2363 { "lines", required_argument, NULL, 'n' },
2364 { "output", required_argument, NULL, 'o' },
2365 { "no-ask-password", no_argument, NULL, ARG_NO_ASK_PASSWORD },
2366 { "verify", required_argument, NULL, ARG_VERIFY },
2367 { "force", no_argument, NULL, ARG_FORCE },
2368 { "dkr-index-url", required_argument, NULL, ARG_DKR_INDEX_URL },
2369 { "format", required_argument, NULL, ARG_FORMAT },
2370 {}
2371 };
2372
2373 int c, r;
2374
2375 assert(argc >= 0);
2376 assert(argv);
2377
2378 while ((c = getopt_long(argc, argv, "hp:als:H:M:qn:o:", options, NULL)) >= 0)
2379
2380 switch (c) {
2381
2382 case 'h':
2383 return help(0, NULL, NULL);
2384
2385 case ARG_VERSION:
2386 puts(PACKAGE_STRING);
2387 puts(SYSTEMD_FEATURES);
2388 return 0;
2389
2390 case 'p':
2391 r = strv_extend(&arg_property, optarg);
2392 if (r < 0)
2393 return log_oom();
2394
2395 /* If the user asked for a particular
2396 * property, show it to him, even if it is
2397 * empty. */
2398 arg_all = true;
2399 break;
2400
2401 case 'a':
2402 arg_all = true;
2403 break;
2404
2405 case 'l':
2406 arg_full = true;
2407 break;
2408
2409 case 'n':
2410 if (safe_atou(optarg, &arg_lines) < 0) {
2411 log_error("Failed to parse lines '%s'", optarg);
2412 return -EINVAL;
2413 }
2414 break;
2415
2416 case 'o':
2417 arg_output = output_mode_from_string(optarg);
2418 if (arg_output < 0) {
2419 log_error("Unknown output '%s'.", optarg);
2420 return -EINVAL;
2421 }
2422 break;
2423
2424 case ARG_NO_PAGER:
2425 arg_no_pager = true;
2426 break;
2427
2428 case ARG_NO_LEGEND:
2429 arg_legend = false;
2430 break;
2431
2432 case ARG_KILL_WHO:
2433 arg_kill_who = optarg;
2434 break;
2435
2436 case 's':
2437 arg_signal = signal_from_string_try_harder(optarg);
2438 if (arg_signal < 0) {
2439 log_error("Failed to parse signal string %s.", optarg);
2440 return -EINVAL;
2441 }
2442 break;
2443
2444 case ARG_NO_ASK_PASSWORD:
2445 arg_ask_password = false;
2446 break;
2447
2448 case 'H':
2449 arg_transport = BUS_TRANSPORT_REMOTE;
2450 arg_host = optarg;
2451 break;
2452
2453 case 'M':
2454 arg_transport = BUS_TRANSPORT_MACHINE;
2455 arg_host = optarg;
2456 break;
2457
2458 case ARG_READ_ONLY:
2459 arg_read_only = true;
2460 break;
2461
2462 case ARG_MKDIR:
2463 arg_mkdir = true;
2464 break;
2465
2466 case 'q':
2467 arg_quiet = true;
2468 break;
2469
2470 case ARG_VERIFY:
2471 arg_verify = import_verify_from_string(optarg);
2472 if (arg_verify < 0) {
2473 log_error("Failed to parse --verify= setting: %s", optarg);
2474 return -EINVAL;
2475 }
2476 break;
2477
2478 case ARG_FORCE:
2479 arg_force = true;
2480 break;
2481
2482 case ARG_DKR_INDEX_URL:
2483 if (!http_url_is_valid(optarg)) {
2484 log_error("Index URL is invalid: %s", optarg);
2485 return -EINVAL;
2486 }
2487
2488 arg_dkr_index_url = optarg;
2489 break;
2490
2491 case ARG_FORMAT:
2492 if (!STR_IN_SET(optarg, "uncompressed", "xz", "gzip", "bzip2")) {
2493 log_error("Unknown format: %s", optarg);
2494 return -EINVAL;
2495 }
2496
2497 arg_format = optarg;
2498 break;
2499
2500 case '?':
2501 return -EINVAL;
2502
2503 default:
2504 assert_not_reached("Unhandled option");
2505 }
2506
2507 return 1;
2508 }
2509
2510 static int machinectl_main(int argc, char *argv[], sd_bus *bus) {
2511
2512 static const Verb verbs[] = {
2513 { "help", VERB_ANY, VERB_ANY, 0, help },
2514 { "list", VERB_ANY, 1, VERB_DEFAULT, list_machines },
2515 { "list-images", VERB_ANY, 1, 0, list_images },
2516 { "status", 2, VERB_ANY, 0, show_machine },
2517 { "image-status", VERB_ANY, VERB_ANY, 0, show_image },
2518 { "show", VERB_ANY, VERB_ANY, 0, show_machine },
2519 { "show-image", VERB_ANY, VERB_ANY, 0, show_image },
2520 { "terminate", 2, VERB_ANY, 0, terminate_machine },
2521 { "reboot", 2, VERB_ANY, 0, reboot_machine },
2522 { "poweroff", 2, VERB_ANY, 0, poweroff_machine },
2523 { "kill", 2, VERB_ANY, 0, kill_machine },
2524 { "login", 2, 2, 0, login_machine },
2525 { "bind", 3, 4, 0, bind_mount },
2526 { "copy-to", 3, 4, 0, copy_files },
2527 { "copy-from", 3, 4, 0, copy_files },
2528 { "remove", 2, VERB_ANY, 0, remove_image },
2529 { "rename", 3, 3, 0, rename_image },
2530 { "clone", 3, 3, 0, clone_image },
2531 { "read-only", 2, 3, 0, read_only_image },
2532 { "start", 2, VERB_ANY, 0, start_machine },
2533 { "enable", 2, VERB_ANY, 0, enable_machine },
2534 { "disable", 2, VERB_ANY, 0, enable_machine },
2535 { "import-tar", 2, 3, 0, import_tar },
2536 { "import-raw", 2, 3, 0, import_raw },
2537 { "export-tar", 2, 3, 0, export_tar },
2538 { "export-raw", 2, 3, 0, export_raw },
2539 { "pull-tar", 2, 3, 0, pull_tar },
2540 { "pull-raw", 2, 3, 0, pull_raw },
2541 { "pull-dkr", 2, 3, 0, pull_dkr },
2542 { "list-transfers", VERB_ANY, 1, 0, list_transfers },
2543 { "cancel-transfer", 2, VERB_ANY, 0, cancel_transfer },
2544 { "set-limit", 2, 3, 0, set_limit },
2545 {}
2546 };
2547
2548 return dispatch_verb(argc, argv, verbs, bus);
2549 }
2550
2551 int main(int argc, char*argv[]) {
2552 _cleanup_bus_close_unref_ sd_bus *bus = NULL;
2553 int r;
2554
2555 setlocale(LC_ALL, "");
2556 log_parse_environment();
2557 log_open();
2558
2559 r = parse_argv(argc, argv);
2560 if (r <= 0)
2561 goto finish;
2562
2563 r = bus_open_transport(arg_transport, arg_host, false, &bus);
2564 if (r < 0) {
2565 log_error_errno(r, "Failed to create bus connection: %m");
2566 goto finish;
2567 }
2568
2569 sd_bus_set_allow_interactive_authorization(bus, arg_ask_password);
2570
2571 r = machinectl_main(argc, argv, bus);
2572
2573 finish:
2574 pager_close();
2575 polkit_agent_close();
2576
2577 strv_free(arg_property);
2578
2579 return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
2580 }
Unnamed repository; edit this file 'description' to name the repository.