chiark / gitweb /
5ff8ea6810529988d1abbcc758aa9e4cc10bd9e6
[elogind.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 }