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