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