]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/login/loginctl.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
loginctl: use bus_method_call_with_reply() where posible
[thirdparty/systemd.git] / src / login / loginctl.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4 This file is part of systemd.
5
6 Copyright 2010 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 <dbus/dbus.h>
23 #include <unistd.h>
24 #include <errno.h>
25 #include <string.h>
26 #include <getopt.h>
27 #include <pwd.h>
28
29 #include "log.h"
30 #include "util.h"
31 #include "macro.h"
32 #include "pager.h"
33 #include "dbus-common.h"
34 #include "build.h"
35 #include "strv.h"
36 #include "cgroup-show.h"
37 #include "sysfs-show.h"
38 #include "spawn-polkit-agent.h"
39
40 static char **arg_property = NULL;
41 static bool arg_all = false;
42 static bool arg_no_pager = false;
43 static const char *arg_kill_who = NULL;
44 static int arg_signal = SIGTERM;
45 static enum transport {
46 TRANSPORT_NORMAL,
47 TRANSPORT_SSH,
48 TRANSPORT_POLKIT
49 } arg_transport = TRANSPORT_NORMAL;
50 static bool arg_ask_password = true;
51 static const char *arg_host = NULL;
52
53 static bool on_tty(void) {
54 static int t = -1;
55
56 /* Note that this is invoked relatively early, before we start
57 * the pager. That means the value we return reflects whether
58 * we originally were started on a tty, not if we currently
59 * are. But this is intended, since we want colour and so on
60 * when run in our own pager. */
61
62 if (_unlikely_(t < 0))
63 t = isatty(STDOUT_FILENO) > 0;
64
65 return t;
66 }
67
68 static void pager_open_if_enabled(void) {
69
70 /* Cache result before we open the pager */
71 on_tty();
72
73 if (arg_no_pager)
74 return;
75
76 pager_open();
77 }
78
79 static void polkit_agent_open_if_enabled(void) {
80
81 /* Open the polkit agent as a child process if necessary */
82
83 if (!arg_ask_password)
84 return;
85
86 polkit_agent_open();
87 }
88
89 static int list_sessions(DBusConnection *bus, char **args, unsigned n) {
90 DBusMessage *reply = NULL;
91 int r;
92 DBusMessageIter iter, sub, sub2;
93 unsigned k = 0;
94
95 pager_open_if_enabled();
96
97 r = bus_method_call_with_reply (
98 bus,
99 "org.freedesktop.login1",
100 "/org/freedesktop/login1",
101 "org.freedesktop.login1.Manager",
102 "ListSessions",
103 &reply,
104 NULL,
105 DBUS_TYPE_INVALID);
106 if (r)
107 goto finish;
108
109 if (!dbus_message_iter_init(reply, &iter) ||
110 dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
111 dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT) {
112 log_error("Failed to parse reply.");
113 r = -EIO;
114 goto finish;
115 }
116
117 dbus_message_iter_recurse(&iter, &sub);
118
119 if (on_tty())
120 printf("%10s %10s %-16s %-16s\n", "SESSION", "UID", "USER", "SEAT");
121
122 while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
123 const char *id, *user, *seat, *object;
124 uint32_t uid;
125
126 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {
127 log_error("Failed to parse reply.");
128 r = -EIO;
129 goto finish;
130 }
131
132 dbus_message_iter_recurse(&sub, &sub2);
133
134 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &id, true) < 0 ||
135 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &uid, true) < 0 ||
136 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &user, true) < 0 ||
137 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &seat, true) < 0 ||
138 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &object, false) < 0) {
139 log_error("Failed to parse reply.");
140 r = -EIO;
141 goto finish;
142 }
143
144 printf("%10s %10u %-16s %-16s\n", id, (unsigned) uid, user, seat);
145
146 k++;
147
148 dbus_message_iter_next(&sub);
149 }
150
151 if (on_tty())
152 printf("\n%u sessions listed.\n", k);
153
154 r = 0;
155
156 finish:
157 if (reply)
158 dbus_message_unref(reply);
159
160 return r;
161 }
162
163 static int list_users(DBusConnection *bus, char **args, unsigned n) {
164 DBusMessage *reply = NULL;
165 int r;
166 DBusMessageIter iter, sub, sub2;
167 unsigned k = 0;
168
169 pager_open_if_enabled();
170
171 r = bus_method_call_with_reply (
172 bus,
173 "org.freedesktop.login1",
174 "/org/freedesktop/login1",
175 "org.freedesktop.login1.Manager",
176 "ListUsers",
177 &reply,
178 NULL,
179 DBUS_TYPE_INVALID);
180 if (r)
181 goto finish;
182
183 if (!dbus_message_iter_init(reply, &iter) ||
184 dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
185 dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT) {
186 log_error("Failed to parse reply.");
187 r = -EIO;
188 goto finish;
189 }
190
191 dbus_message_iter_recurse(&iter, &sub);
192
193 if (on_tty())
194 printf("%10s %-16s\n", "UID", "USER");
195
196 while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
197 const char *user, *object;
198 uint32_t uid;
199
200 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {
201 log_error("Failed to parse reply.");
202 r = -EIO;
203 goto finish;
204 }
205
206 dbus_message_iter_recurse(&sub, &sub2);
207
208 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &uid, true) < 0 ||
209 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &user, true) < 0 ||
210 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &object, false) < 0) {
211 log_error("Failed to parse reply.");
212 r = -EIO;
213 goto finish;
214 }
215
216 printf("%10u %-16s\n", (unsigned) uid, user);
217
218 k++;
219
220 dbus_message_iter_next(&sub);
221 }
222
223 if (on_tty())
224 printf("\n%u users listed.\n", k);
225
226 r = 0;
227
228 finish:
229 if (reply)
230 dbus_message_unref(reply);
231
232 return r;
233 }
234
235 static int list_seats(DBusConnection *bus, char **args, unsigned n) {
236 DBusMessage *reply = NULL;
237 int r;
238 DBusMessageIter iter, sub, sub2;
239 unsigned k = 0;
240
241 pager_open_if_enabled();
242
243 r = bus_method_call_with_reply (
244 bus,
245 "org.freedesktop.login1",
246 "/org/freedesktop/login1",
247 "org.freedesktop.login1.Manager",
248 "ListSeats",
249 &reply,
250 NULL,
251 DBUS_TYPE_INVALID);
252 if (r)
253 goto finish;
254
255 if (!dbus_message_iter_init(reply, &iter) ||
256 dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
257 dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT) {
258 log_error("Failed to parse reply.");
259 r = -EIO;
260 goto finish;
261 }
262
263 dbus_message_iter_recurse(&iter, &sub);
264
265 if (on_tty())
266 printf("%-16s\n", "SEAT");
267
268 while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
269 const char *seat, *object;
270
271 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {
272 log_error("Failed to parse reply.");
273 r = -EIO;
274 goto finish;
275 }
276
277 dbus_message_iter_recurse(&sub, &sub2);
278
279 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &seat, true) < 0 ||
280 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &object, false) < 0) {
281 log_error("Failed to parse reply.");
282 r = -EIO;
283 goto finish;
284 }
285
286 printf("%-16s\n", seat);
287
288 k++;
289
290 dbus_message_iter_next(&sub);
291 }
292
293 if (on_tty())
294 printf("\n%u seats listed.\n", k);
295
296 r = 0;
297
298 finish:
299 if (reply)
300 dbus_message_unref(reply);
301
302 return r;
303 }
304
305 typedef struct SessionStatusInfo {
306 const char *id;
307 uid_t uid;
308 const char *name;
309 usec_t timestamp;
310 const char *default_control_group;
311 int vtnr;
312 const char *seat;
313 const char *tty;
314 const char *display;
315 bool remote;
316 const char *remote_host;
317 const char *remote_user;
318 const char *service;
319 pid_t leader;
320 const char *type;
321 const char *class;
322 const char *state;
323 } SessionStatusInfo;
324
325 typedef struct UserStatusInfo {
326 uid_t uid;
327 const char *name;
328 usec_t timestamp;
329 const char *default_control_group;
330 const char *state;
331 char **sessions;
332 const char *display;
333 } UserStatusInfo;
334
335 typedef struct SeatStatusInfo {
336 const char *id;
337 const char *active_session;
338 char **sessions;
339 } SeatStatusInfo;
340
341 static void print_session_status_info(SessionStatusInfo *i) {
342 char since1[FORMAT_TIMESTAMP_PRETTY_MAX], *s1;
343 char since2[FORMAT_TIMESTAMP_MAX], *s2;
344 assert(i);
345
346 printf("%s - ", strna(i->id));
347
348 if (i->name)
349 printf("%s (%u)\n", i->name, (unsigned) i->uid);
350 else
351 printf("%u\n", (unsigned) i->uid);
352
353 s1 = format_timestamp_pretty(since1, sizeof(since1), i->timestamp);
354 s2 = format_timestamp(since2, sizeof(since2), i->timestamp);
355
356 if (s1)
357 printf("\t Since: %s; %s\n", s2, s1);
358 else if (s2)
359 printf("\t Since: %s\n", s2);
360
361 if (i->leader > 0) {
362 char *t = NULL;
363
364 printf("\t Leader: %u", (unsigned) i->leader);
365
366 get_process_comm(i->leader, &t);
367 if (t) {
368 printf(" (%s)", t);
369 free(t);
370 }
371
372 printf("\n");
373 }
374
375 if (i->seat) {
376 printf("\t Seat: %s", i->seat);
377
378 if (i->vtnr > 0)
379 printf("; vc%i", i->vtnr);
380
381 printf("\n");
382 }
383
384 if (i->tty)
385 printf("\t TTY: %s\n", i->tty);
386 else if (i->display)
387 printf("\t Display: %s\n", i->display);
388
389 if (i->remote_host && i->remote_user)
390 printf("\t Remote: %s@%s\n", i->remote_user, i->remote_host);
391 else if (i->remote_host)
392 printf("\t Remote: %s\n", i->remote_host);
393 else if (i->remote_user)
394 printf("\t Remote: user %s\n", i->remote_user);
395 else if (i->remote)
396 printf("\t Remote: Yes\n");
397
398 if (i->service) {
399 printf("\t Service: %s", i->service);
400
401 if (i->type)
402 printf("; type %s", i->type);
403
404 if (i->class)
405 printf("; class %s", i->class);
406
407 printf("\n");
408 } else if (i->type) {
409 printf("\t Type: %s\n", i->type);
410
411 if (i->class)
412 printf("; class %s", i->class);
413 } else if (i->class)
414 printf("\t Class: %s\n", i->class);
415
416 if (i->state)
417 printf("\t State: %s\n", i->state);
418
419 if (i->default_control_group) {
420 unsigned c;
421
422 printf("\t CGroup: %s\n", i->default_control_group);
423
424 if (arg_transport != TRANSPORT_SSH) {
425 c = columns();
426 if (c > 18)
427 c -= 18;
428 else
429 c = 0;
430
431 show_cgroup_and_extra_by_spec(i->default_control_group, "\t\t ", c, false, arg_all, &i->leader, i->leader > 0 ? 1 : 0);
432 }
433 }
434 }
435
436 static void print_user_status_info(UserStatusInfo *i) {
437 char since1[FORMAT_TIMESTAMP_PRETTY_MAX], *s1;
438 char since2[FORMAT_TIMESTAMP_MAX], *s2;
439 assert(i);
440
441 if (i->name)
442 printf("%s (%u)\n", i->name, (unsigned) i->uid);
443 else
444 printf("%u\n", (unsigned) i->uid);
445
446 s1 = format_timestamp_pretty(since1, sizeof(since1), i->timestamp);
447 s2 = format_timestamp(since2, sizeof(since2), i->timestamp);
448
449 if (s1)
450 printf("\t Since: %s; %s\n", s2, s1);
451 else if (s2)
452 printf("\t Since: %s\n", s2);
453
454 if (!isempty(i->state))
455 printf("\t State: %s\n", i->state);
456
457 if (!strv_isempty(i->sessions)) {
458 char **l;
459 printf("\tSessions:");
460
461 STRV_FOREACH(l, i->sessions) {
462 if (streq_ptr(*l, i->display))
463 printf(" *%s", *l);
464 else
465 printf(" %s", *l);
466 }
467
468 printf("\n");
469 }
470
471 if (i->default_control_group) {
472 unsigned c;
473
474 printf("\t CGroup: %s\n", i->default_control_group);
475
476 if (arg_transport != TRANSPORT_SSH) {
477 c = columns();
478 if (c > 18)
479 c -= 18;
480 else
481 c = 0;
482
483 show_cgroup_by_path(i->default_control_group, "\t\t ", c, false, arg_all);
484 }
485 }
486 }
487
488 static void print_seat_status_info(SeatStatusInfo *i) {
489 assert(i);
490
491 printf("%s\n", strna(i->id));
492
493 if (!strv_isempty(i->sessions)) {
494 char **l;
495 printf("\tSessions:");
496
497 STRV_FOREACH(l, i->sessions) {
498 if (streq_ptr(*l, i->active_session))
499 printf(" *%s", *l);
500 else
501 printf(" %s", *l);
502 }
503
504 printf("\n");
505 }
506
507 if (arg_transport != TRANSPORT_SSH) {
508 unsigned c;
509
510 c = columns();
511 if (c > 21)
512 c -= 21;
513 else
514 c = 0;
515
516 printf("\t Devices:\n");
517
518 show_sysfs(i->id, "\t\t ", c);
519 }
520 }
521
522 static int status_property_session(const char *name, DBusMessageIter *iter, SessionStatusInfo *i) {
523 assert(name);
524 assert(iter);
525 assert(i);
526
527 switch (dbus_message_iter_get_arg_type(iter)) {
528
529 case DBUS_TYPE_STRING: {
530 const char *s;
531
532 dbus_message_iter_get_basic(iter, &s);
533
534 if (!isempty(s)) {
535 if (streq(name, "Id"))
536 i->id = s;
537 else if (streq(name, "Name"))
538 i->name = s;
539 else if (streq(name, "DefaultControlGroup"))
540 i->default_control_group = s;
541 else if (streq(name, "TTY"))
542 i->tty = s;
543 else if (streq(name, "Display"))
544 i->display = s;
545 else if (streq(name, "RemoteHost"))
546 i->remote_host = s;
547 else if (streq(name, "RemoteUser"))
548 i->remote_user = s;
549 else if (streq(name, "Service"))
550 i->service = s;
551 else if (streq(name, "Type"))
552 i->type = s;
553 else if (streq(name, "Class"))
554 i->class = s;
555 else if (streq(name, "State"))
556 i->state = s;
557 }
558 break;
559 }
560
561 case DBUS_TYPE_UINT32: {
562 uint32_t u;
563
564 dbus_message_iter_get_basic(iter, &u);
565
566 if (streq(name, "VTNr"))
567 i->vtnr = (int) u;
568 else if (streq(name, "Leader"))
569 i->leader = (pid_t) u;
570
571 break;
572 }
573
574 case DBUS_TYPE_BOOLEAN: {
575 dbus_bool_t b;
576
577 dbus_message_iter_get_basic(iter, &b);
578
579 if (streq(name, "Remote"))
580 i->remote = b;
581
582 break;
583 }
584
585 case DBUS_TYPE_UINT64: {
586 uint64_t u;
587
588 dbus_message_iter_get_basic(iter, &u);
589
590 if (streq(name, "Timestamp"))
591 i->timestamp = (usec_t) u;
592
593 break;
594 }
595
596 case DBUS_TYPE_STRUCT: {
597 DBusMessageIter sub;
598
599 dbus_message_iter_recurse(iter, &sub);
600
601 if (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_UINT32 && streq(name, "User")) {
602 uint32_t u;
603
604 dbus_message_iter_get_basic(&sub, &u);
605 i->uid = (uid_t) u;
606
607 } else if (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING && streq(name, "Seat")) {
608 const char *s;
609
610 dbus_message_iter_get_basic(&sub, &s);
611
612 if (!isempty(s))
613 i->seat = s;
614 }
615
616 break;
617 }
618 }
619
620 return 0;
621 }
622
623 static int status_property_user(const char *name, DBusMessageIter *iter, UserStatusInfo *i) {
624 assert(name);
625 assert(iter);
626 assert(i);
627
628 switch (dbus_message_iter_get_arg_type(iter)) {
629
630 case DBUS_TYPE_STRING: {
631 const char *s;
632
633 dbus_message_iter_get_basic(iter, &s);
634
635 if (!isempty(s)) {
636 if (streq(name, "Name"))
637 i->name = s;
638 else if (streq(name, "DefaultControlGroup"))
639 i->default_control_group = s;
640 else if (streq(name, "State"))
641 i->state = s;
642 }
643 break;
644 }
645
646 case DBUS_TYPE_UINT32: {
647 uint32_t u;
648
649 dbus_message_iter_get_basic(iter, &u);
650
651 if (streq(name, "UID"))
652 i->uid = (uid_t) u;
653
654 break;
655 }
656
657 case DBUS_TYPE_UINT64: {
658 uint64_t u;
659
660 dbus_message_iter_get_basic(iter, &u);
661
662 if (streq(name, "Timestamp"))
663 i->timestamp = (usec_t) u;
664
665 break;
666 }
667
668 case DBUS_TYPE_STRUCT: {
669 DBusMessageIter sub;
670
671 dbus_message_iter_recurse(iter, &sub);
672
673 if (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING && streq(name, "Display")) {
674 const char *s;
675
676 dbus_message_iter_get_basic(&sub, &s);
677
678 if (!isempty(s))
679 i->display = s;
680 }
681
682 break;
683 }
684
685 case DBUS_TYPE_ARRAY: {
686
687 if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && streq(name, "Sessions")) {
688 DBusMessageIter sub, sub2;
689
690 dbus_message_iter_recurse(iter, &sub);
691 while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
692 const char *id;
693 const char *path;
694
695 dbus_message_iter_recurse(&sub, &sub2);
696
697 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &id, true) >= 0 &&
698 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &path, false) >= 0) {
699 char **l;
700
701 l = strv_append(i->sessions, id);
702 if (!l)
703 return -ENOMEM;
704
705 strv_free(i->sessions);
706 i->sessions = l;
707 }
708
709 dbus_message_iter_next(&sub);
710 }
711
712 return 0;
713 }
714 }
715 }
716
717 return 0;
718 }
719
720 static int status_property_seat(const char *name, DBusMessageIter *iter, SeatStatusInfo *i) {
721 assert(name);
722 assert(iter);
723 assert(i);
724
725 switch (dbus_message_iter_get_arg_type(iter)) {
726
727 case DBUS_TYPE_STRING: {
728 const char *s;
729
730 dbus_message_iter_get_basic(iter, &s);
731
732 if (!isempty(s)) {
733 if (streq(name, "Id"))
734 i->id = s;
735 }
736 break;
737 }
738
739 case DBUS_TYPE_STRUCT: {
740 DBusMessageIter sub;
741
742 dbus_message_iter_recurse(iter, &sub);
743
744 if (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING && streq(name, "ActiveSession")) {
745 const char *s;
746
747 dbus_message_iter_get_basic(&sub, &s);
748
749 if (!isempty(s))
750 i->active_session = s;
751 }
752
753 break;
754 }
755
756 case DBUS_TYPE_ARRAY: {
757
758 if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && streq(name, "Sessions")) {
759 DBusMessageIter sub, sub2;
760
761 dbus_message_iter_recurse(iter, &sub);
762 while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
763 const char *id;
764 const char *path;
765
766 dbus_message_iter_recurse(&sub, &sub2);
767
768 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &id, true) >= 0 &&
769 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &path, false) >= 0) {
770 char **l;
771
772 l = strv_append(i->sessions, id);
773 if (!l)
774 return -ENOMEM;
775
776 strv_free(i->sessions);
777 i->sessions = l;
778 }
779
780 dbus_message_iter_next(&sub);
781 }
782
783 return 0;
784 }
785 }
786 }
787
788 return 0;
789 }
790
791 static int print_property(const char *name, DBusMessageIter *iter) {
792 assert(name);
793 assert(iter);
794
795 if (arg_property && !strv_find(arg_property, name))
796 return 0;
797
798 switch (dbus_message_iter_get_arg_type(iter)) {
799
800 case DBUS_TYPE_STRUCT: {
801 DBusMessageIter sub;
802
803 dbus_message_iter_recurse(iter, &sub);
804
805 if (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING &&
806 (streq(name, "Display") || streq(name, "ActiveSession"))) {
807 const char *s;
808
809 dbus_message_iter_get_basic(&sub, &s);
810
811 if (arg_all || !isempty(s))
812 printf("%s=%s\n", name, s);
813 return 0;
814 }
815 break;
816 }
817
818 case DBUS_TYPE_ARRAY:
819
820 if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && streq(name, "Sessions")) {
821 DBusMessageIter sub, sub2;
822 bool found = false;
823
824 dbus_message_iter_recurse(iter, &sub);
825 while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
826 const char *id;
827 const char *path;
828
829 dbus_message_iter_recurse(&sub, &sub2);
830
831 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &id, true) >= 0 &&
832 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &path, false) >= 0) {
833 if (found)
834 printf(" %s", id);
835 else {
836 printf("%s=%s", name, id);
837 found = true;
838 }
839 }
840
841 dbus_message_iter_next(&sub);
842 }
843
844 if (!found && arg_all)
845 printf("%s=\n", name);
846 else if (found)
847 printf("\n");
848
849 return 0;
850 }
851
852 break;
853 }
854
855 if (generic_print_property(name, iter, arg_all) > 0)
856 return 0;
857
858 if (arg_all)
859 printf("%s=[unprintable]\n", name);
860
861 return 0;
862 }
863
864 static int show_one(const char *verb, DBusConnection *bus, const char *path, bool show_properties, bool *new_line) {
865 DBusMessage *reply = NULL;
866 const char *interface = "";
867 int r;
868 DBusMessageIter iter, sub, sub2, sub3;
869 SessionStatusInfo session_info;
870 UserStatusInfo user_info;
871 SeatStatusInfo seat_info;
872
873 assert(path);
874 assert(new_line);
875
876 zero(session_info);
877 zero(user_info);
878 zero(seat_info);
879
880 r = bus_method_call_with_reply (
881 bus,
882 "org.freedesktop.login1",
883 path,
884 "org.freedesktop.DBus.Properties",
885 "GetAll",
886 &reply,
887 NULL,
888 DBUS_TYPE_STRING, &interface,
889 DBUS_TYPE_INVALID);
890 if (r)
891 goto finish;
892
893 if (!dbus_message_iter_init(reply, &iter) ||
894 dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
895 dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_DICT_ENTRY) {
896 log_error("Failed to parse reply.");
897 r = -EIO;
898 goto finish;
899 }
900
901 dbus_message_iter_recurse(&iter, &sub);
902
903 if (*new_line)
904 printf("\n");
905
906 *new_line = true;
907
908 while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
909 const char *name;
910
911 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_DICT_ENTRY) {
912 log_error("Failed to parse reply.");
913 r = -EIO;
914 goto finish;
915 }
916
917 dbus_message_iter_recurse(&sub, &sub2);
918
919 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &name, true) < 0) {
920 log_error("Failed to parse reply.");
921 r = -EIO;
922 goto finish;
923 }
924
925 if (dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_VARIANT) {
926 log_error("Failed to parse reply.");
927 r = -EIO;
928 goto finish;
929 }
930
931 dbus_message_iter_recurse(&sub2, &sub3);
932
933 if (show_properties)
934 r = print_property(name, &sub3);
935 else if (strstr(verb, "session"))
936 r = status_property_session(name, &sub3, &session_info);
937 else if (strstr(verb, "user"))
938 r = status_property_user(name, &sub3, &user_info);
939 else
940 r = status_property_seat(name, &sub3, &seat_info);
941
942 if (r < 0) {
943 log_error("Failed to parse reply.");
944 r = -EIO;
945 goto finish;
946 }
947
948 dbus_message_iter_next(&sub);
949 }
950
951 if (!show_properties) {
952 if (strstr(verb, "session"))
953 print_session_status_info(&session_info);
954 else if (strstr(verb, "user"))
955 print_user_status_info(&user_info);
956 else
957 print_seat_status_info(&seat_info);
958 }
959
960 strv_free(seat_info.sessions);
961 strv_free(user_info.sessions);
962
963 r = 0;
964
965 finish:
966 if (reply)
967 dbus_message_unref(reply);
968
969 return r;
970 }
971
972 static int show(DBusConnection *bus, char **args, unsigned n) {
973 DBusMessage *reply = NULL;
974 int r, ret = 0;
975 DBusError error;
976 unsigned i;
977 bool show_properties, new_line = false;
978
979 assert(bus);
980 assert(args);
981
982 dbus_error_init(&error);
983
984 show_properties = !strstr(args[0], "status");
985
986 if (show_properties)
987 pager_open_if_enabled();
988
989 if (show_properties && n <= 1) {
990 /* If not argument is specified inspect the manager
991 * itself */
992
993 ret = show_one(args[0], bus, "/org/freedesktop/login1", show_properties, &new_line);
994 goto finish;
995 }
996
997 for (i = 1; i < n; i++) {
998 const char *path = NULL;
999
1000 if (strstr(args[0], "session")) {
1001
1002 ret = bus_method_call_with_reply (
1003 bus,
1004 "org.freedesktop.login1",
1005 "/org/freedesktop/login1",
1006 "org.freedesktop.login1.Manager",
1007 "GetSession",
1008 &reply,
1009 NULL,
1010 DBUS_TYPE_STRING, &args[i],
1011 DBUS_TYPE_INVALID);
1012
1013 } else if (strstr(args[0], "user")) {
1014 uid_t uid;
1015 uint32_t u;
1016
1017 ret = get_user_creds((const char**) (args+i), &uid, NULL, NULL, NULL);
1018 if (ret < 0) {
1019 log_error("User %s unknown.", args[i]);
1020 goto finish;
1021 }
1022
1023 u = (uint32_t) uid;
1024 ret = bus_method_call_with_reply (
1025 bus,
1026 "org.freedesktop.login1",
1027 "/org/freedesktop/login1",
1028 "org.freedesktop.login1.Manager",
1029 "GetUser",
1030 &reply,
1031 NULL,
1032 DBUS_TYPE_UINT32, &u,
1033 DBUS_TYPE_INVALID);
1034 } else {
1035
1036 ret = bus_method_call_with_reply (
1037 bus,
1038 "org.freedesktop.login1",
1039 "/org/freedesktop/login1",
1040 "org.freedesktop.login1.Manager",
1041 "GetSeat",
1042 &reply,
1043 NULL,
1044 DBUS_TYPE_STRING, &args[i],
1045 DBUS_TYPE_INVALID);
1046 }
1047 if (ret)
1048 goto finish;
1049
1050 if (!dbus_message_get_args(reply, &error,
1051 DBUS_TYPE_OBJECT_PATH, &path,
1052 DBUS_TYPE_INVALID)) {
1053 log_error("Failed to parse reply: %s", bus_error_message(&error));
1054 ret = -EIO;
1055 goto finish;
1056 }
1057
1058 r = show_one(args[0], bus, path, show_properties, &new_line);
1059 if (r != 0)
1060 ret = r;
1061
1062 dbus_message_unref(reply);
1063 reply = NULL;
1064 }
1065
1066 finish:
1067 if (reply)
1068 dbus_message_unref(reply);
1069
1070 dbus_error_free(&error);
1071
1072 return ret;
1073 }
1074
1075 static int activate(DBusConnection *bus, char **args, unsigned n) {
1076 int ret = 0;
1077 unsigned i;
1078
1079 assert(args);
1080
1081 for (i = 1; i < n; i++) {
1082
1083 ret = bus_method_call_with_reply (
1084 bus,
1085 "org.freedesktop.login1",
1086 "/org/freedesktop/login1",
1087 "org.freedesktop.login1.Manager",
1088 streq(args[0], "lock-session") ? "LockSession" :
1089 streq(args[0], "unlock-session") ? "UnlockSession" :
1090 streq(args[0], "terminate-session") ? "TerminateSession" :
1091 "ActivateSession",
1092 NULL,
1093 NULL,
1094 DBUS_TYPE_STRING, &args[i],
1095 DBUS_TYPE_INVALID);
1096 if (ret)
1097 goto finish;
1098 }
1099
1100 finish:
1101 return ret;
1102 }
1103
1104 static int kill_session(DBusConnection *bus, char **args, unsigned n) {
1105 int ret = 0;
1106 unsigned i;
1107
1108 assert(args);
1109
1110 if (!arg_kill_who)
1111 arg_kill_who = "all";
1112
1113 for (i = 1; i < n; i++) {
1114 ret = bus_method_call_with_reply (
1115 bus,
1116 "org.freedesktop.login1",
1117 "/org/freedesktop/login1",
1118 "org.freedesktop.login1.Manager",
1119 "KillSession",
1120 NULL,
1121 NULL,
1122 DBUS_TYPE_STRING, &args[i],
1123 DBUS_TYPE_STRING, &arg_kill_who,
1124 DBUS_TYPE_INT32, &arg_signal,
1125 DBUS_TYPE_INVALID);
1126 if (ret)
1127 goto finish;
1128 }
1129
1130 finish:
1131 return ret;
1132 }
1133
1134 static int enable_linger(DBusConnection *bus, char **args, unsigned n) {
1135 int ret = 0;
1136 unsigned i;
1137 dbus_bool_t b, interactive = true;
1138
1139 assert(args);
1140
1141 polkit_agent_open_if_enabled();
1142
1143 b = streq(args[0], "enable-linger");
1144
1145 for (i = 1; i < n; i++) {
1146 uint32_t u;
1147 uid_t uid;
1148
1149 ret = get_user_creds((const char**) (args+i), &uid, NULL, NULL, NULL);
1150 if (ret < 0) {
1151 log_error("Failed to resolve user %s: %s", args[i], strerror(-ret));
1152 goto finish;
1153 }
1154
1155 u = (uint32_t) uid;
1156 ret = bus_method_call_with_reply (
1157 bus,
1158 "org.freedesktop.login1",
1159 "/org/freedesktop/login1",
1160 "org.freedesktop.login1.Manager",
1161 "SetUserLinger",
1162 NULL,
1163 NULL,
1164 DBUS_TYPE_UINT32, &u,
1165 DBUS_TYPE_BOOLEAN, &b,
1166 DBUS_TYPE_BOOLEAN, &interactive,
1167 DBUS_TYPE_INVALID);
1168 if (ret)
1169 goto finish;
1170 }
1171
1172 finish:
1173 return ret;
1174 }
1175
1176 static int terminate_user(DBusConnection *bus, char **args, unsigned n) {
1177 int ret = 0;
1178 unsigned i;
1179
1180 assert(args);
1181
1182 for (i = 1; i < n; i++) {
1183 uint32_t u;
1184 uid_t uid;
1185
1186 ret = get_user_creds((const char**) (args+i), &uid, NULL, NULL, NULL);
1187 if (ret < 0) {
1188 log_error("Failed to look up user %s: %s", args[i], strerror(-ret));
1189 goto finish;
1190 }
1191
1192 u = (uint32_t) uid;
1193 ret = bus_method_call_with_reply (
1194 bus,
1195 "org.freedesktop.login1",
1196 "/org/freedesktop/login1",
1197 "org.freedesktop.login1.Manager",
1198 "TerminateUser",
1199 NULL,
1200 NULL,
1201 DBUS_TYPE_UINT32, &u,
1202 DBUS_TYPE_INVALID);
1203 if (ret)
1204 goto finish;
1205 }
1206
1207 finish:
1208 return ret;
1209 }
1210
1211 static int kill_user(DBusConnection *bus, char **args, unsigned n) {
1212 int ret = 0;
1213 unsigned i;
1214
1215 assert(args);
1216
1217 if (!arg_kill_who)
1218 arg_kill_who = "all";
1219
1220 for (i = 1; i < n; i++) {
1221 uid_t uid;
1222 uint32_t u;
1223
1224 ret = get_user_creds((const char**) (args+i), &uid, NULL, NULL, NULL);
1225 if (ret < 0) {
1226 log_error("Failed to look up user %s: %s", args[i], strerror(-ret));
1227 goto finish;
1228 }
1229
1230 u = (uint32_t) uid;
1231 ret = bus_method_call_with_reply (
1232 bus,
1233 "org.freedesktop.login1",
1234 "/org/freedesktop/login1",
1235 "org.freedesktop.login1.Manager",
1236 "KillUser",
1237 NULL,
1238 NULL,
1239 DBUS_TYPE_UINT32, &u,
1240 DBUS_TYPE_INT32, &arg_signal,
1241 DBUS_TYPE_INVALID);
1242 if (ret)
1243 goto finish;
1244 }
1245
1246 finish:
1247 return ret;
1248 }
1249
1250 static int attach(DBusConnection *bus, char **args, unsigned n) {
1251 int ret = 0;
1252 unsigned i;
1253 dbus_bool_t interactive = true;
1254
1255 assert(args);
1256
1257 polkit_agent_open_if_enabled();
1258
1259 for (i = 2; i < n; i++) {
1260 ret = bus_method_call_with_reply (
1261 bus,
1262 "org.freedesktop.login1",
1263 "/org/freedesktop/login1",
1264 "org.freedesktop.login1.Manager",
1265 "AttachDevice",
1266 NULL,
1267 NULL,
1268 DBUS_TYPE_STRING, &args[1],
1269 DBUS_TYPE_STRING, &args[i],
1270 DBUS_TYPE_BOOLEAN, &interactive,
1271 DBUS_TYPE_INVALID);
1272 if (ret)
1273 goto finish;
1274 }
1275
1276 finish:
1277 return ret;
1278 }
1279
1280 static int flush_devices(DBusConnection *bus, char **args, unsigned n) {
1281 dbus_bool_t interactive = true;
1282
1283 assert(args);
1284
1285 polkit_agent_open_if_enabled();
1286
1287 return bus_method_call_with_reply (
1288 bus,
1289 "org.freedesktop.login1",
1290 "/org/freedesktop/login1",
1291 "org.freedesktop.login1.Manager",
1292 "FlushDevices",
1293 NULL,
1294 NULL,
1295 DBUS_TYPE_BOOLEAN, &interactive,
1296 DBUS_TYPE_INVALID);
1297 }
1298
1299 static int lock_sessions(DBusConnection *bus, char **args, unsigned n) {
1300 polkit_agent_open_if_enabled();
1301
1302 return bus_method_call_with_reply (
1303 bus,
1304 "org.freedesktop.login1",
1305 "/org/freedesktop/login1",
1306 "org.freedesktop.login1.Manager",
1307 "LockSessions",
1308 NULL,
1309 NULL,
1310 DBUS_TYPE_INVALID);
1311 }
1312
1313 static int terminate_seat(DBusConnection *bus, char **args, unsigned n) {
1314 int ret = 0;
1315 unsigned i;
1316
1317 assert(args);
1318
1319 for (i = 1; i < n; i++) {
1320 ret = bus_method_call_with_reply (
1321 bus,
1322 "org.freedesktop.login1",
1323 "/org/freedesktop/login1",
1324 "org.freedesktop.login1.Manager",
1325 "TerminateSeat",
1326 NULL,
1327 NULL,
1328 DBUS_TYPE_STRING, &args[i],
1329 DBUS_TYPE_INVALID);
1330 if (ret)
1331 goto finish;
1332 }
1333
1334 finish:
1335 return ret;
1336 }
1337
1338 static int help(void) {
1339
1340 printf("%s [OPTIONS...] {COMMAND} ...\n\n"
1341 "Send control commands to or query the login manager.\n\n"
1342 " -h --help Show this help\n"
1343 " --version Show package version\n"
1344 " -p --property=NAME Show only properties by this name\n"
1345 " -a --all Show all properties, including empty ones\n"
1346 " --kill-who=WHO Who to send signal to\n"
1347 " -s --signal=SIGNAL Which signal to send\n"
1348 " -H --host=[USER@]HOST\n"
1349 " Show information for remote host\n"
1350 " -P --privileged Acquire privileges before execution\n"
1351 " --no-pager Do not pipe output into a pager\n\n"
1352 "Commands:\n"
1353 " list-sessions List sessions\n"
1354 " session-status [ID...] Show session status\n"
1355 " show-session [ID...] Show properties of one or more sessions\n"
1356 " activate [ID] Activate a session\n"
1357 " lock-session [ID...] Screen lock one or more sessions\n"
1358 " unlock-session [ID...] Screen unlock one or more sessions\n"
1359 " lock-sessions Screen lock all current sessions\n"
1360 " terminate-session [ID...] Terminate one or more sessions\n"
1361 " kill-session [ID...] Send signal to processes of a session\n"
1362 " list-users List users\n"
1363 " user-status [USER...] Show user status\n"
1364 " show-user [USER...] Show properties of one or more users\n"
1365 " enable-linger [USER...] Enable linger state of one or more users\n"
1366 " disable-linger [USER...] Disable linger state of one or more users\n"
1367 " terminate-user [USER...] Terminate all sessions of one or more users\n"
1368 " kill-user [USER...] Send signal to processes of a user\n"
1369 " list-seats List seats\n"
1370 " seat-status [NAME...] Show seat status\n"
1371 " show-seat [NAME...] Show properties of one or more seats\n"
1372 " attach [NAME] [DEVICE...] Attach one or more devices to a seat\n"
1373 " flush-devices Flush all device associations\n"
1374 " terminate-seat [NAME...] Terminate all sessions on one or more seats\n",
1375 program_invocation_short_name);
1376
1377 return 0;
1378 }
1379
1380 static int parse_argv(int argc, char *argv[]) {
1381
1382 enum {
1383 ARG_VERSION = 0x100,
1384 ARG_NO_PAGER,
1385 ARG_KILL_WHO,
1386 ARG_NO_ASK_PASSWORD
1387 };
1388
1389 static const struct option options[] = {
1390 { "help", no_argument, NULL, 'h' },
1391 { "version", no_argument, NULL, ARG_VERSION },
1392 { "property", required_argument, NULL, 'p' },
1393 { "all", no_argument, NULL, 'a' },
1394 { "no-pager", no_argument, NULL, ARG_NO_PAGER },
1395 { "kill-who", required_argument, NULL, ARG_KILL_WHO },
1396 { "signal", required_argument, NULL, 's' },
1397 { "host", required_argument, NULL, 'H' },
1398 { "privileged",no_argument, NULL, 'P' },
1399 { "no-ask-password", no_argument, NULL, ARG_NO_ASK_PASSWORD },
1400 { NULL, 0, NULL, 0 }
1401 };
1402
1403 int c;
1404
1405 assert(argc >= 0);
1406 assert(argv);
1407
1408 while ((c = getopt_long(argc, argv, "hp:as:H:P", options, NULL)) >= 0) {
1409
1410 switch (c) {
1411
1412 case 'h':
1413 help();
1414 return 0;
1415
1416 case ARG_VERSION:
1417 puts(PACKAGE_STRING);
1418 puts(DISTRIBUTION);
1419 puts(SYSTEMD_FEATURES);
1420 return 0;
1421
1422 case 'p': {
1423 char **l;
1424
1425 l = strv_append(arg_property, optarg);
1426 if (!l)
1427 return -ENOMEM;
1428
1429 strv_free(arg_property);
1430 arg_property = l;
1431
1432 /* If the user asked for a particular
1433 * property, show it to him, even if it is
1434 * empty. */
1435 arg_all = true;
1436 break;
1437 }
1438
1439 case 'a':
1440 arg_all = true;
1441 break;
1442
1443 case ARG_NO_PAGER:
1444 arg_no_pager = true;
1445 break;
1446
1447 case ARG_NO_ASK_PASSWORD:
1448 arg_ask_password = false;
1449
1450 case ARG_KILL_WHO:
1451 arg_kill_who = optarg;
1452 break;
1453
1454 case 's':
1455 arg_signal = signal_from_string_try_harder(optarg);
1456 if (arg_signal < 0) {
1457 log_error("Failed to parse signal string %s.", optarg);
1458 return -EINVAL;
1459 }
1460 break;
1461
1462 case 'P':
1463 arg_transport = TRANSPORT_POLKIT;
1464 break;
1465
1466 case 'H':
1467 arg_transport = TRANSPORT_SSH;
1468 arg_host = optarg;
1469 break;
1470
1471 case '?':
1472 return -EINVAL;
1473
1474 default:
1475 log_error("Unknown option code %c", c);
1476 return -EINVAL;
1477 }
1478 }
1479
1480 return 1;
1481 }
1482
1483 static int loginctl_main(DBusConnection *bus, int argc, char *argv[], DBusError *error) {
1484
1485 static const struct {
1486 const char* verb;
1487 const enum {
1488 MORE,
1489 LESS,
1490 EQUAL
1491 } argc_cmp;
1492 const int argc;
1493 int (* const dispatch)(DBusConnection *bus, char **args, unsigned n);
1494 } verbs[] = {
1495 { "list-sessions", LESS, 1, list_sessions },
1496 { "session-status", MORE, 2, show },
1497 { "show-session", MORE, 1, show },
1498 { "activate", EQUAL, 2, activate },
1499 { "lock-session", MORE, 2, activate },
1500 { "unlock-session", MORE, 2, activate },
1501 { "lock-sessions", EQUAL, 1, lock_sessions },
1502 { "terminate-session", MORE, 2, activate },
1503 { "kill-session", MORE, 2, kill_session },
1504 { "list-users", EQUAL, 1, list_users },
1505 { "user-status", MORE, 2, show },
1506 { "show-user", MORE, 1, show },
1507 { "enable-linger", MORE, 2, enable_linger },
1508 { "disable-linger", MORE, 2, enable_linger },
1509 { "terminate-user", MORE, 2, terminate_user },
1510 { "kill-user", MORE, 2, kill_user },
1511 { "list-seats", EQUAL, 1, list_seats },
1512 { "seat-status", MORE, 2, show },
1513 { "show-seat", MORE, 1, show },
1514 { "attach", MORE, 3, attach },
1515 { "flush-devices", EQUAL, 1, flush_devices },
1516 { "terminate-seat", MORE, 2, terminate_seat },
1517 };
1518
1519 int left;
1520 unsigned i;
1521
1522 assert(argc >= 0);
1523 assert(argv);
1524 assert(error);
1525
1526 left = argc - optind;
1527
1528 if (left <= 0)
1529 /* Special rule: no arguments means "list-sessions" */
1530 i = 0;
1531 else {
1532 if (streq(argv[optind], "help")) {
1533 help();
1534 return 0;
1535 }
1536
1537 for (i = 0; i < ELEMENTSOF(verbs); i++)
1538 if (streq(argv[optind], verbs[i].verb))
1539 break;
1540
1541 if (i >= ELEMENTSOF(verbs)) {
1542 log_error("Unknown operation %s", argv[optind]);
1543 return -EINVAL;
1544 }
1545 }
1546
1547 switch (verbs[i].argc_cmp) {
1548
1549 case EQUAL:
1550 if (left != verbs[i].argc) {
1551 log_error("Invalid number of arguments.");
1552 return -EINVAL;
1553 }
1554
1555 break;
1556
1557 case MORE:
1558 if (left < verbs[i].argc) {
1559 log_error("Too few arguments.");
1560 return -EINVAL;
1561 }
1562
1563 break;
1564
1565 case LESS:
1566 if (left > verbs[i].argc) {
1567 log_error("Too many arguments.");
1568 return -EINVAL;
1569 }
1570
1571 break;
1572
1573 default:
1574 assert_not_reached("Unknown comparison operator.");
1575 }
1576
1577 if (!bus) {
1578 log_error("Failed to get D-Bus connection: %s", error->message);
1579 return -EIO;
1580 }
1581
1582 return verbs[i].dispatch(bus, argv + optind, left);
1583 }
1584
1585 int main(int argc, char*argv[]) {
1586 int r, retval = EXIT_FAILURE;
1587 DBusConnection *bus = NULL;
1588 DBusError error;
1589
1590 dbus_error_init(&error);
1591
1592 log_parse_environment();
1593 log_open();
1594
1595 r = parse_argv(argc, argv);
1596 if (r < 0)
1597 goto finish;
1598 else if (r == 0) {
1599 retval = EXIT_SUCCESS;
1600 goto finish;
1601 }
1602
1603 if (arg_transport == TRANSPORT_NORMAL)
1604 bus = dbus_bus_get_private(DBUS_BUS_SYSTEM, &error);
1605 else if (arg_transport == TRANSPORT_POLKIT)
1606 bus_connect_system_polkit(&bus, &error);
1607 else if (arg_transport == TRANSPORT_SSH)
1608 bus_connect_system_ssh(NULL, arg_host, &bus, &error);
1609 else
1610 assert_not_reached("Uh, invalid transport...");
1611
1612 r = loginctl_main(bus, argc, argv, &error);
1613 retval = r < 0 ? EXIT_FAILURE : r;
1614
1615 finish:
1616 if (bus) {
1617 dbus_connection_flush(bus);
1618 dbus_connection_close(bus);
1619 dbus_connection_unref(bus);
1620 }
1621
1622 dbus_error_free(&error);
1623 dbus_shutdown();
1624
1625 strv_free(arg_property);
1626
1627 pager_close();
1628
1629 return retval;
1630 }
Unnamed repository; edit this file 'description' to name the repository.