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