src/login/logind-dbus.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2 /***
   3   This file is part of systemd.
   4
   5   Copyright 2011 Lennart Poettering
   6
   7   systemd is free software; you can redistribute it and/or modify it
   8   under the terms of the GNU Lesser General Public License as published by
   9   the Free Software Foundation; either version 2.1 of the License, or
  10   (at your option) any later version.
  11
  12   systemd is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   Lesser General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  19 ***/
  20
  21 #include <errno.h>
  22 #include <pwd.h>
  23 #include <string.h>
  24 #include <unistd.h>
  25
  26 #include "sd-messages.h"
  27
  28 #include "alloc-util.h"
  29 #include "audit-util.h"
  30 #include "bus-common-errors.h"
  31 #include "bus-error.h"
  32 #include "bus-util.h"
  33 #include "dirent-util.h"
  34 #include "efivars.h"
  35 #include "escape.h"
  36 #include "fd-util.h"
  37 #include "fileio-label.h"
  38 #include "format-util.h"
  39 #include "fs-util.h"
  40 #include "logind.h"
  41 #include "mkdir.h"
  42 #include "path-util.h"
  43 #include "process-util.h"
  44 #include "selinux-util.h"
  45 #include "sleep-config.h"
  46 #include "special.h"
  47 #include "strv.h"
  48 #include "terminal-util.h"
  49 #include "udev-util.h"
  50 #include "unit-name.h"
  51 #include "user-util.h"
  52 #include "utmp-wtmp.h"
  53
  54 static int get_sender_session(Manager *m, sd_bus_message *message, sd_bus_error *error, Session **ret) {
  55
  56         _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
  57         const char *name;
  58         Session *session;
  59         int r;
  60
  61         /* Get client login session.  This is not what you are looking for these days,
  62          * as apps may instead belong to a user service unit.  This includes terminal
  63          * emulators and hence command-line apps. */
  64         r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_SESSION|SD_BUS_CREDS_AUGMENT, &creds);
  65         if (r < 0)
  66                 return r;
  67
  68         r = sd_bus_creds_get_session(creds, &name);
  69         if (r == -ENXIO)
  70                 goto err_no_session;
  71         if (r < 0)
  72                 return r;
  73
  74         session = hashmap_get(m->sessions, name);
  75         if (!session)
  76                 goto err_no_session;
  77
  78         *ret = session;
  79         return 0;
  80
  81 err_no_session:
  82         return sd_bus_error_setf(error, BUS_ERROR_NO_SESSION_FOR_PID,
  83                                  "Caller does not belong to any known session");
  84 }
  85
  86 int manager_get_session_from_creds(Manager *m, sd_bus_message *message, const char *name, sd_bus_error *error, Session **ret) {
  87         Session *session;
  88
  89         assert(m);
  90         assert(message);
  91         assert(ret);
  92
  93         if (isempty(name))
  94                 return get_sender_session(m, message, error, ret);
  95
  96         session = hashmap_get(m->sessions, name);
  97         if (!session)
  98                 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_SESSION, "No session '%s' known", name);
  99
 100         *ret = session;
 101         return 0;
 102 }
 103
 104 static int get_sender_user(Manager *m, sd_bus_message *message, sd_bus_error *error, User **ret) {
 105
 106         _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
 107         uid_t uid;
 108         User *user;
 109         int r;
 110
 111         /* Note that we get the owner UID of the session, not the actual client UID here! */
 112         r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_OWNER_UID|SD_BUS_CREDS_AUGMENT, &creds);
 113         if (r < 0)
 114                 return r;
 115
 116         r = sd_bus_creds_get_owner_uid(creds, &uid);
 117         if (r == -ENXIO)
 118                 goto err_no_user;
 119         if (r < 0)
 120                 return r;
 121
 122         user = hashmap_get(m->users, UID_TO_PTR(uid));
 123         if (!user)
 124                 goto err_no_user;
 125
 126         *ret = user;
 127         return 0;
 128
 129 err_no_user:
 130         return sd_bus_error_setf(error, BUS_ERROR_NO_USER_FOR_PID, "Caller does not belong to any logged in user or lingering user");
 131 }
 132
 133 int manager_get_user_from_creds(Manager *m, sd_bus_message *message, uid_t uid, sd_bus_error *error, User **ret) {
 134         User *user;
 135
 136         assert(m);
 137         assert(message);
 138         assert(ret);
 139
 140         if (!uid_is_valid(uid))
 141                 return get_sender_user(m, message, error, ret);
 142
 143         user = hashmap_get(m->users, UID_TO_PTR(uid));
 144         if (!user)
 145                 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_USER, "User ID "UID_FMT" is not logged in or lingering", uid);
 146
 147         *ret = user;
 148         return 0;
 149 }
 150
 151 int manager_get_seat_from_creds(Manager *m, sd_bus_message *message, const char *name, sd_bus_error *error, Seat **ret) {
 152         Seat *seat;
 153         int r;
 154
 155         assert(m);
 156         assert(message);
 157         assert(ret);
 158
 159         if (isempty(name)) {
 160                 Session *session;
 161
 162                 r = manager_get_session_from_creds(m, message, NULL, error, &session);
 163                 if (r < 0)
 164                         return r;
 165
 166                 seat = session->seat;
 167                 if (!seat)
 168                         return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_SEAT, "Session has no seat.");
 169         } else {
 170                 seat = hashmap_get(m->seats, name);
 171                 if (!seat)
 172                         return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_SEAT, "No seat '%s' known", name);
 173         }
 174
 175         *ret = seat;
 176         return 0;
 177 }
 178
 179 static int property_get_idle_hint(
 180                 sd_bus *bus,
 181                 const char *path,
 182                 const char *interface,
 183                 const char *property,
 184                 sd_bus_message *reply,
 185                 void *userdata,
 186                 sd_bus_error *error) {
 187
 188         Manager *m = userdata;
 189
 190         assert(bus);
 191         assert(reply);
 192         assert(m);
 193
 194         return sd_bus_message_append(reply, "b", manager_get_idle_hint(m, NULL) > 0);
 195 }
 196
 197 static int property_get_idle_since_hint(
 198                 sd_bus *bus,
 199                 const char *path,
 200                 const char *interface,
 201                 const char *property,
 202                 sd_bus_message *reply,
 203                 void *userdata,
 204                 sd_bus_error *error) {
 205
 206         Manager *m = userdata;
 207         dual_timestamp t = DUAL_TIMESTAMP_NULL;
 208
 209         assert(bus);
 210         assert(reply);
 211         assert(m);
 212
 213         manager_get_idle_hint(m, &t);
 214
 215         return sd_bus_message_append(reply, "t", streq(property, "IdleSinceHint") ? t.realtime : t.monotonic);
 216 }
 217
 218 static int property_get_inhibited(
 219                 sd_bus *bus,
 220                 const char *path,
 221                 const char *interface,
 222                 const char *property,
 223                 sd_bus_message *reply,
 224                 void *userdata,
 225                 sd_bus_error *error) {
 226
 227         Manager *m = userdata;
 228         InhibitWhat w;
 229
 230         assert(bus);
 231         assert(reply);
 232         assert(m);
 233
 234         w = manager_inhibit_what(m, streq(property, "BlockInhibited") ? INHIBIT_BLOCK : INHIBIT_DELAY);
 235
 236         return sd_bus_message_append(reply, "s", inhibit_what_to_string(w));
 237 }
 238
 239 static int property_get_preparing(
 240                 sd_bus *bus,
 241                 const char *path,
 242                 const char *interface,
 243                 const char *property,
 244                 sd_bus_message *reply,
 245                 void *userdata,
 246                 sd_bus_error *error) {
 247
 248         Manager *m = userdata;
 249         bool b;
 250
 251         assert(bus);
 252         assert(reply);
 253         assert(m);
 254
 255         if (streq(property, "PreparingForShutdown"))
 256                 b = !!(m->action_what & INHIBIT_SHUTDOWN);
 257         else
 258                 b = !!(m->action_what & INHIBIT_SLEEP);
 259
 260         return sd_bus_message_append(reply, "b", b);
 261 }
 262
 263 static int property_get_scheduled_shutdown(
 264                 sd_bus *bus,
 265                 const char *path,
 266                 const char *interface,
 267                 const char *property,
 268                 sd_bus_message *reply,
 269                 void *userdata,
 270                 sd_bus_error *error) {
 271
 272         Manager *m = userdata;
 273         int r;
 274
 275         assert(bus);
 276         assert(reply);
 277         assert(m);
 278
 279         r = sd_bus_message_open_container(reply, 'r', "st");
 280         if (r < 0)
 281                 return r;
 282
 283         r = sd_bus_message_append(reply, "st", m->scheduled_shutdown_type, m->scheduled_shutdown_timeout);
 284         if (r < 0)
 285                 return r;
 286
 287         return sd_bus_message_close_container(reply);
 288 }
 289
 290 static BUS_DEFINE_PROPERTY_GET_ENUM(property_get_handle_action, handle_action, HandleAction);
 291
 292 static int property_get_docked(
 293                 sd_bus *bus,
 294                 const char *path,
 295                 const char *interface,
 296                 const char *property,
 297                 sd_bus_message *reply,
 298                 void *userdata,
 299                 sd_bus_error *error) {
 300
 301         Manager *m = userdata;
 302
 303         assert(bus);
 304         assert(reply);
 305         assert(m);
 306
 307         return sd_bus_message_append(reply, "b", manager_is_docked_or_external_displays(m));
 308 }
 309
 310 static int property_get_current_sessions(
 311                 sd_bus *bus,
 312                 const char *path,
 313                 const char *interface,
 314                 const char *property,
 315                 sd_bus_message *reply,
 316                 void *userdata,
 317                 sd_bus_error *error) {
 318
 319         Manager *m = userdata;
 320
 321         assert(bus);
 322         assert(reply);
 323         assert(m);
 324
 325         return sd_bus_message_append(reply, "t", (uint64_t) hashmap_size(m->sessions));
 326 }
 327
 328 static int property_get_current_inhibitors(
 329                 sd_bus *bus,
 330                 const char *path,
 331                 const char *interface,
 332                 const char *property,
 333                 sd_bus_message *reply,
 334                 void *userdata,
 335                 sd_bus_error *error) {
 336
 337         Manager *m = userdata;
 338
 339         assert(bus);
 340         assert(reply);
 341         assert(m);
 342
 343         return sd_bus_message_append(reply, "t", (uint64_t) hashmap_size(m->inhibitors));
 344 }
 345
 346 static int method_get_session(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 347         _cleanup_free_ char *p = NULL;
 348         Manager *m = userdata;
 349         const char *name;
 350         Session *session;
 351         int r;
 352
 353         assert(message);
 354         assert(m);
 355
 356         r = sd_bus_message_read(message, "s", &name);
 357         if (r < 0)
 358                 return r;
 359
 360         r = manager_get_session_from_creds(m, message, name, error, &session);
 361         if (r < 0)
 362                 return r;
 363
 364         p = session_bus_path(session);
 365         if (!p)
 366                 return -ENOMEM;
 367
 368         return sd_bus_reply_method_return(message, "o", p);
 369 }
 370
 371 /* Get login session of a process.  This is not what you are looking for these days,
 372  * as apps may instead belong to a user service unit.  This includes terminal
 373  * emulators and hence command-line apps. */
 374 static int method_get_session_by_pid(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 375         _cleanup_free_ char *p = NULL;
 376         Session *session = NULL;
 377         Manager *m = userdata;
 378         pid_t pid;
 379         int r;
 380
 381         assert(message);
 382         assert(m);
 383
 384         assert_cc(sizeof(pid_t) == sizeof(uint32_t));
 385
 386         r = sd_bus_message_read(message, "u", &pid);
 387         if (r < 0)
 388                 return r;
 389         if (pid < 0)
 390                 return -EINVAL;
 391
 392         if (pid == 0) {
 393                 r = manager_get_session_from_creds(m, message, NULL, error, &session);
 394                 if (r < 0)
 395                         return r;
 396         } else {
 397                 r = manager_get_session_by_pid(m, pid, &session);
 398                 if (r < 0)
 399                         return r;
 400
 401                 if (!session)
 402                         return sd_bus_error_setf(error, BUS_ERROR_NO_SESSION_FOR_PID, "PID "PID_FMT" does not belong to any known session", pid);
 403         }
 404
 405         p = session_bus_path(session);
 406         if (!p)
 407                 return -ENOMEM;
 408
 409         return sd_bus_reply_method_return(message, "o", p);
 410 }
 411
 412 static int method_get_user(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 413         _cleanup_free_ char *p = NULL;
 414         Manager *m = userdata;
 415         uint32_t uid;
 416         User *user;
 417         int r;
 418
 419         assert(message);
 420         assert(m);
 421
 422         r = sd_bus_message_read(message, "u", &uid);
 423         if (r < 0)
 424                 return r;
 425
 426         r = manager_get_user_from_creds(m, message, uid, error, &user);
 427         if (r < 0)
 428                 return r;
 429
 430         p = user_bus_path(user);
 431         if (!p)
 432                 return -ENOMEM;
 433
 434         return sd_bus_reply_method_return(message, "o", p);
 435 }
 436
 437 static int method_get_user_by_pid(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 438         _cleanup_free_ char *p = NULL;
 439         Manager *m = userdata;
 440         User *user = NULL;
 441         pid_t pid;
 442         int r;
 443
 444         assert(message);
 445         assert(m);
 446
 447         assert_cc(sizeof(pid_t) == sizeof(uint32_t));
 448
 449         r = sd_bus_message_read(message, "u", &pid);
 450         if (r < 0)
 451                 return r;
 452         if (pid < 0)
 453                 return -EINVAL;
 454
 455         if (pid == 0) {
 456                 r = manager_get_user_from_creds(m, message, UID_INVALID, error, &user);
 457                 if (r < 0)
 458                         return r;
 459         } else {
 460                 r = manager_get_user_by_pid(m, pid, &user);
 461                 if (r < 0)
 462                         return r;
 463                 if (!user)
 464                         return sd_bus_error_setf(error, BUS_ERROR_NO_USER_FOR_PID,
 465                                                  "PID "PID_FMT" does not belong to any logged in user or lingering user",
 466                                                  pid);
 467         }
 468
 469         p = user_bus_path(user);
 470         if (!p)
 471                 return -ENOMEM;
 472
 473         return sd_bus_reply_method_return(message, "o", p);
 474 }
 475
 476 static int method_get_seat(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 477         _cleanup_free_ char *p = NULL;
 478         Manager *m = userdata;
 479         const char *name;
 480         Seat *seat;
 481         int r;
 482
 483         assert(message);
 484         assert(m);
 485
 486         r = sd_bus_message_read(message, "s", &name);
 487         if (r < 0)
 488                 return r;
 489
 490         r = manager_get_seat_from_creds(m, message, name, error, &seat);
 491         if (r < 0)
 492                 return r;
 493
 494         p = seat_bus_path(seat);
 495         if (!p)
 496                 return -ENOMEM;
 497
 498         return sd_bus_reply_method_return(message, "o", p);
 499 }
 500
 501 static int method_list_sessions(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 502         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
 503         Manager *m = userdata;
 504         Session *session;
 505         Iterator i;
 506         int r;
 507
 508         assert(message);
 509         assert(m);
 510
 511         r = sd_bus_message_new_method_return(message, &reply);
 512         if (r < 0)
 513                 return r;
 514
 515         r = sd_bus_message_open_container(reply, 'a', "(susso)");
 516         if (r < 0)
 517                 return r;
 518
 519         HASHMAP_FOREACH(session, m->sessions, i) {
 520                 _cleanup_free_ char *p = NULL;
 521
 522                 p = session_bus_path(session);
 523                 if (!p)
 524                         return -ENOMEM;
 525
 526                 r = sd_bus_message_append(reply, "(susso)",
 527                                           session->id,
 528                                           (uint32_t) session->user->uid,
 529                                           session->user->name,
 530                                           session->seat ? session->seat->id : "",
 531                                           p);
 532                 if (r < 0)
 533                         return r;
 534         }
 535
 536         r = sd_bus_message_close_container(reply);
 537         if (r < 0)
 538                 return r;
 539
 540         return sd_bus_send(NULL, reply, NULL);
 541 }
 542
 543 static int method_list_users(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 544         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
 545         Manager *m = userdata;
 546         User *user;
 547         Iterator i;
 548         int r;
 549
 550         assert(message);
 551         assert(m);
 552
 553         r = sd_bus_message_new_method_return(message, &reply);
 554         if (r < 0)
 555                 return r;
 556
 557         r = sd_bus_message_open_container(reply, 'a', "(uso)");
 558         if (r < 0)
 559                 return r;
 560
 561         HASHMAP_FOREACH(user, m->users, i) {
 562                 _cleanup_free_ char *p = NULL;
 563
 564                 p = user_bus_path(user);
 565                 if (!p)
 566                         return -ENOMEM;
 567
 568                 r = sd_bus_message_append(reply, "(uso)",
 569                                           (uint32_t) user->uid,
 570                                           user->name,
 571                                           p);
 572                 if (r < 0)
 573                         return r;
 574         }
 575
 576         r = sd_bus_message_close_container(reply);
 577         if (r < 0)
 578                 return r;
 579
 580         return sd_bus_send(NULL, reply, NULL);
 581 }
 582
 583 static int method_list_seats(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 584         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
 585         Manager *m = userdata;
 586         Seat *seat;
 587         Iterator i;
 588         int r;
 589
 590         assert(message);
 591         assert(m);
 592
 593         r = sd_bus_message_new_method_return(message, &reply);
 594         if (r < 0)
 595                 return r;
 596
 597         r = sd_bus_message_open_container(reply, 'a', "(so)");
 598         if (r < 0)
 599                 return r;
 600
 601         HASHMAP_FOREACH(seat, m->seats, i) {
 602                 _cleanup_free_ char *p = NULL;
 603
 604                 p = seat_bus_path(seat);
 605                 if (!p)
 606                         return -ENOMEM;
 607
 608                 r = sd_bus_message_append(reply, "(so)", seat->id, p);
 609                 if (r < 0)
 610                         return r;
 611         }
 612
 613         r = sd_bus_message_close_container(reply);
 614         if (r < 0)
 615                 return r;
 616
 617         return sd_bus_send(NULL, reply, NULL);
 618 }
 619
 620 static int method_list_inhibitors(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 621         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
 622         Manager *m = userdata;
 623         Inhibitor *inhibitor;
 624         Iterator i;
 625         int r;
 626
 627         assert(message);
 628         assert(m);
 629
 630         r = sd_bus_message_new_method_return(message, &reply);
 631         if (r < 0)
 632                 return r;
 633
 634         r = sd_bus_message_open_container(reply, 'a', "(ssssuu)");
 635         if (r < 0)
 636                 return r;
 637
 638         HASHMAP_FOREACH(inhibitor, m->inhibitors, i) {
 639
 640                 r = sd_bus_message_append(reply, "(ssssuu)",
 641                                           strempty(inhibit_what_to_string(inhibitor->what)),
 642                                           strempty(inhibitor->who),
 643                                           strempty(inhibitor->why),
 644                                           strempty(inhibit_mode_to_string(inhibitor->mode)),
 645                                           (uint32_t) inhibitor->uid,
 646                                           (uint32_t) inhibitor->pid);
 647                 if (r < 0)
 648                         return r;
 649         }
 650
 651         r = sd_bus_message_close_container(reply);
 652         if (r < 0)
 653                 return r;
 654
 655         return sd_bus_send(NULL, reply, NULL);
 656 }
 657
 658 static int method_create_session(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 659         const char *service, *type, *class, *cseat, *tty, *display, *remote_user, *remote_host, *desktop;
 660         uint32_t audit_id = 0;
 661         _cleanup_free_ char *id = NULL;
 662         Session *session = NULL;
 663         Manager *m = userdata;
 664         User *user = NULL;
 665         Seat *seat = NULL;
 666         pid_t leader;
 667         uid_t uid;
 668         int remote;
 669         uint32_t vtnr = 0;
 670         SessionType t;
 671         SessionClass c;
 672         int r;
 673
 674         assert(message);
 675         assert(m);
 676
 677         assert_cc(sizeof(pid_t) == sizeof(uint32_t));
 678         assert_cc(sizeof(uid_t) == sizeof(uint32_t));
 679
 680         r = sd_bus_message_read(message, "uusssssussbss", &uid, &leader, &service, &type, &class, &desktop, &cseat, &vtnr, &tty, &display, &remote, &remote_user, &remote_host);
 681         if (r < 0)
 682                 return r;
 683
 684         if (!uid_is_valid(uid))
 685                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid UID");
 686         if (leader < 0 || leader == 1)
 687                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid leader PID");
 688
 689         if (isempty(type))
 690                 t = _SESSION_TYPE_INVALID;
 691         else {
 692                 t = session_type_from_string(type);
 693                 if (t < 0)
 694                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid session type %s", type);
 695         }
 696
 697         if (isempty(class))
 698                 c = _SESSION_CLASS_INVALID;
 699         else {
 700                 c = session_class_from_string(class);
 701                 if (c < 0)
 702                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid session class %s", class);
 703         }
 704
 705         if (isempty(desktop))
 706                 desktop = NULL;
 707         else {
 708                 if (!string_is_safe(desktop))
 709                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid desktop string %s", desktop);
 710         }
 711
 712         if (isempty(cseat))
 713                 seat = NULL;
 714         else {
 715                 seat = hashmap_get(m->seats, cseat);
 716                 if (!seat)
 717                         return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_SEAT, "No seat '%s' known", cseat);
 718         }
 719
 720         if (tty_is_vc(tty)) {
 721                 int v;
 722
 723                 if (!seat)
 724                         seat = m->seat0;
 725                 else if (seat != m->seat0)
 726                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "TTY %s is virtual console but seat %s is not seat0", tty, seat->id);
 727
 728                 v = vtnr_from_tty(tty);
 729                 if (v <= 0)
 730                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Cannot determine VT number from virtual console TTY %s", tty);
 731
 732                 if (!vtnr)
 733                         vtnr = (uint32_t) v;
 734                 else if (vtnr != (uint32_t) v)
 735                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Specified TTY and VT number do not match");
 736
 737         } else if (tty_is_console(tty)) {
 738
 739                 if (!seat)
 740                         seat = m->seat0;
 741                 else if (seat != m->seat0)
 742                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Console TTY specified but seat is not seat0");
 743
 744                 if (vtnr != 0)
 745                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Console TTY specified but VT number is not 0");
 746         }
 747
 748         if (seat) {
 749                 if (seat_has_vts(seat)) {
 750                         if (!vtnr || vtnr > 63)
 751                                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "VT number out of range");
 752                 } else {
 753                         if (vtnr != 0)
 754                                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Seat has no VTs but VT number not 0");
 755                 }
 756         }
 757
 758         r = sd_bus_message_enter_container(message, 'a', "(sv)");
 759         if (r < 0)
 760                 return r;
 761
 762         if (t == _SESSION_TYPE_INVALID) {
 763                 if (!isempty(display))
 764                         t = SESSION_X11;
 765                 else if (!isempty(tty))
 766                         t = SESSION_TTY;
 767                 else
 768                         t = SESSION_UNSPECIFIED;
 769         }
 770
 771         if (c == _SESSION_CLASS_INVALID) {
 772                 if (t == SESSION_UNSPECIFIED)
 773                         c = SESSION_BACKGROUND;
 774                 else
 775                         c = SESSION_USER;
 776         }
 777
 778         if (leader == 0) {
 779                 _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
 780
 781                 r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_PID, &creds);
 782                 if (r < 0)
 783                         return r;
 784
 785                 r = sd_bus_creds_get_pid(creds, (pid_t*) &leader);
 786                 if (r < 0)
 787                         return r;
 788         }
 789
 790         r = manager_get_session_by_pid(m, leader, NULL);
 791         if (r > 0)
 792                 return sd_bus_error_setf(error, BUS_ERROR_SESSION_BUSY, "Already running in a session");
 793
 794         /*
 795          * Old gdm and lightdm start the user-session on the same VT as
 796          * the greeter session. But they destroy the greeter session
 797          * after the user-session and want the user-session to take
 798          * over the VT. We need to support this for
 799          * backwards-compatibility, so make sure we allow new sessions
 800          * on a VT that a greeter is running on. Furthermore, to allow
 801          * re-logins, we have to allow a greeter to take over a used VT for
 802          * the exact same reasons.
 803          */
 804         if (c != SESSION_GREETER &&
 805             vtnr > 0 &&
 806             vtnr < m->seat0->position_count &&
 807             m->seat0->positions[vtnr] &&
 808             m->seat0->positions[vtnr]->class != SESSION_GREETER)
 809                 return sd_bus_error_setf(error, BUS_ERROR_SESSION_BUSY, "Already occupied by a session");
 810
 811         if (hashmap_size(m->sessions) >= m->sessions_max)
 812                 return sd_bus_error_setf(error, SD_BUS_ERROR_LIMITS_EXCEEDED, "Maximum number of sessions (%" PRIu64 ") reached, refusing further sessions.", m->sessions_max);
 813
 814         (void) audit_session_from_pid(leader, &audit_id);
 815         if (audit_session_is_valid(audit_id)) {
 816                 /* Keep our session IDs and the audit session IDs in sync */
 817
 818                 if (asprintf(&id, "%"PRIu32, audit_id) < 0)
 819                         return -ENOMEM;
 820
 821                 /* Wut? There's already a session by this name and we
 822                  * didn't find it above? Weird, then let's not trust
 823                  * the audit data and let's better register a new
 824                  * ID */
 825                 if (hashmap_get(m->sessions, id)) {
 826                         log_warning("Existing logind session ID %s used by new audit session, ignoring", id);
 827                         audit_id = AUDIT_SESSION_INVALID;
 828
 829                         id = mfree(id);
 830                 }
 831         }
 832
 833         if (!id) {
 834                 do {
 835                         id = mfree(id);
 836
 837                         if (asprintf(&id, "c%lu", ++m->session_counter) < 0)
 838                                 return -ENOMEM;
 839
 840                 } while (hashmap_get(m->sessions, id));
 841         }
 842
 843         r = manager_add_user_by_uid(m, uid, &user);
 844         if (r < 0)
 845                 goto fail;
 846
 847         r = manager_add_session(m, id, &session);
 848         if (r < 0)
 849                 goto fail;
 850
 851         session_set_user(session, user);
 852
 853         session->leader = leader;
 854         session->audit_id = audit_id;
 855         session->type = t;
 856         session->class = c;
 857         session->remote = remote;
 858         session->vtnr = vtnr;
 859
 860         if (!isempty(tty)) {
 861                 session->tty = strdup(tty);
 862                 if (!session->tty) {
 863                         r = -ENOMEM;
 864                         goto fail;
 865                 }
 866         }
 867
 868         if (!isempty(display)) {
 869                 session->display = strdup(display);
 870                 if (!session->display) {
 871                         r = -ENOMEM;
 872                         goto fail;
 873                 }
 874         }
 875
 876         if (!isempty(remote_user)) {
 877                 session->remote_user = strdup(remote_user);
 878                 if (!session->remote_user) {
 879                         r = -ENOMEM;
 880                         goto fail;
 881                 }
 882         }
 883
 884         if (!isempty(remote_host)) {
 885                 session->remote_host = strdup(remote_host);
 886                 if (!session->remote_host) {
 887                         r = -ENOMEM;
 888                         goto fail;
 889                 }
 890         }
 891
 892         if (!isempty(service)) {
 893                 session->service = strdup(service);
 894                 if (!session->service) {
 895                         r = -ENOMEM;
 896                         goto fail;
 897                 }
 898         }
 899
 900         if (!isempty(desktop)) {
 901                 session->desktop = strdup(desktop);
 902                 if (!session->desktop) {
 903                         r = -ENOMEM;
 904                         goto fail;
 905                 }
 906         }
 907
 908         if (seat) {
 909                 r = seat_attach_session(seat, session);
 910                 if (r < 0)
 911                         goto fail;
 912         }
 913
 914         r = session_start(session);
 915         if (r < 0)
 916                 goto fail;
 917
 918         session->create_message = sd_bus_message_ref(message);
 919
 920         /* Now, let's wait until the slice unit and stuff got
 921          * created. We send the reply back from
 922          * session_send_create_reply(). */
 923
 924         return 1;
 925
 926 fail:
 927         if (session)
 928                 session_add_to_gc_queue(session);
 929
 930         if (user)
 931                 user_add_to_gc_queue(user);
 932
 933         return r;
 934 }
 935
 936 static int method_release_session(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 937         Manager *m = userdata;
 938         Session *session;
 939         const char *name;
 940         int r;
 941
 942         assert(message);
 943         assert(m);
 944
 945         r = sd_bus_message_read(message, "s", &name);
 946         if (r < 0)
 947                 return r;
 948
 949         r = manager_get_session_from_creds(m, message, name, error, &session);
 950         if (r < 0)
 951                 return r;
 952
 953         r = session_release(session);
 954         if (r < 0)
 955                 return r;
 956
 957         return sd_bus_reply_method_return(message, NULL);
 958 }
 959
 960 static int method_activate_session(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 961         Manager *m = userdata;
 962         Session *session;
 963         const char *name;
 964         int r;
 965
 966         assert(message);
 967         assert(m);
 968
 969         r = sd_bus_message_read(message, "s", &name);
 970         if (r < 0)
 971                 return r;
 972
 973         r = manager_get_session_from_creds(m, message, name, error, &session);
 974         if (r < 0)
 975                 return r;
 976
 977         return bus_session_method_activate(message, session, error);
 978 }
 979
 980 static int method_activate_session_on_seat(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 981         const char *session_name, *seat_name;
 982         Manager *m = userdata;
 983         Session *session;
 984         Seat *seat;
 985         int r;
 986
 987         assert(message);
 988         assert(m);
 989
 990         /* Same as ActivateSession() but refuses to work if
 991          * the seat doesn't match */
 992
 993         r = sd_bus_message_read(message, "ss", &session_name, &seat_name);
 994         if (r < 0)
 995                 return r;
 996
 997         r = manager_get_session_from_creds(m, message, session_name, error, &session);
 998         if (r < 0)
 999                 return r;
1000
1001         r = manager_get_seat_from_creds(m, message, seat_name, error, &seat);
1002         if (r < 0)
1003                 return r;
1004
1005         if (session->seat != seat)
1006                 return sd_bus_error_setf(error, BUS_ERROR_SESSION_NOT_ON_SEAT, "Session %s not on seat %s", session_name, seat_name);
1007
1008         r = session_activate(session);
1009         if (r < 0)
1010                 return r;
1011
1012         return sd_bus_reply_method_return(message, NULL);
1013 }
1014
1015 static int method_lock_session(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1016         Manager *m = userdata;
1017         Session *session;
1018         const char *name;
1019         int r;
1020
1021         assert(message);
1022         assert(m);
1023
1024         r = sd_bus_message_read(message, "s", &name);
1025         if (r < 0)
1026                 return r;
1027
1028         r = manager_get_session_from_creds(m, message, name, error, &session);
1029         if (r < 0)
1030                 return r;
1031
1032         return bus_session_method_lock(message, session, error);
1033 }
1034
1035 static int method_lock_sessions(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1036         Manager *m = userdata;
1037         int r;
1038
1039         assert(message);
1040         assert(m);
1041
1042         r = bus_verify_polkit_async(
1043                         message,
1044                         CAP_SYS_ADMIN,
1045                         "org.freedesktop.login1.lock-sessions",
1046                         NULL,
1047                         false,
1048                         UID_INVALID,
1049                         &m->polkit_registry,
1050                         error);
1051         if (r < 0)
1052                 return r;
1053         if (r == 0)
1054                 return 1; /* Will call us back */
1055
1056         r = session_send_lock_all(m, streq(sd_bus_message_get_member(message), "LockSessions"));
1057         if (r < 0)
1058                 return r;
1059
1060         return sd_bus_reply_method_return(message, NULL);
1061 }
1062
1063 static int method_kill_session(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1064         const char *name;
1065         Manager *m = userdata;
1066         Session *session;
1067         int r;
1068
1069         assert(message);
1070         assert(m);
1071
1072         r = sd_bus_message_read(message, "s", &name);
1073         if (r < 0)
1074                 return r;
1075
1076         r = manager_get_session_from_creds(m, message, name, error, &session);
1077         if (r < 0)
1078                 return r;
1079
1080         return bus_session_method_kill(message, session, error);
1081 }
1082
1083 static int method_kill_user(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1084         Manager *m = userdata;
1085         uint32_t uid;
1086         User *user;
1087         int r;
1088
1089         assert(message);
1090         assert(m);
1091
1092         r = sd_bus_message_read(message, "u", &uid);
1093         if (r < 0)
1094                 return r;
1095
1096         r = manager_get_user_from_creds(m, message, uid, error, &user);
1097         if (r < 0)
1098                 return r;
1099
1100         return bus_user_method_kill(message, user, error);
1101 }
1102
1103 static int method_terminate_session(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1104         Manager *m = userdata;
1105         const char *name;
1106         Session *session;
1107         int r;
1108
1109         assert(message);
1110         assert(m);
1111
1112         r = sd_bus_message_read(message, "s", &name);
1113         if (r < 0)
1114                 return r;
1115
1116         r = manager_get_session_from_creds(m, message, name, error, &session);
1117         if (r < 0)
1118                 return r;
1119
1120         return bus_session_method_terminate(message, session, error);
1121 }
1122
1123 static int method_terminate_user(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1124         Manager *m = userdata;
1125         uint32_t uid;
1126         User *user;
1127         int r;
1128
1129         assert(message);
1130         assert(m);
1131
1132         r = sd_bus_message_read(message, "u", &uid);
1133         if (r < 0)
1134                 return r;
1135
1136         r = manager_get_user_from_creds(m, message, uid, error, &user);
1137         if (r < 0)
1138                 return r;
1139
1140         return bus_user_method_terminate(message, user, error);
1141 }
1142
1143 static int method_terminate_seat(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1144         Manager *m = userdata;
1145         const char *name;
1146         Seat *seat;
1147         int r;
1148
1149         assert(message);
1150         assert(m);
1151
1152         r = sd_bus_message_read(message, "s", &name);
1153         if (r < 0)
1154                 return r;
1155
1156         r = manager_get_seat_from_creds(m, message, name, error, &seat);
1157         if (r < 0)
1158                 return r;
1159
1160         return bus_seat_method_terminate(message, seat, error);
1161 }
1162
1163 static int method_set_user_linger(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1164         _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
1165         _cleanup_free_ char *cc = NULL;
1166         Manager *m = userdata;
1167         int r, b, interactive;
1168         struct passwd *pw;
1169         const char *path;
1170         uint32_t uid, auth_uid;
1171
1172         assert(message);
1173         assert(m);
1174
1175         r = sd_bus_message_read(message, "ubb", &uid, &b, &interactive);
1176         if (r < 0)
1177                 return r;
1178
1179         r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_EUID |
1180                                                SD_BUS_CREDS_OWNER_UID|SD_BUS_CREDS_AUGMENT, &creds);
1181         if (r < 0)
1182                 return r;
1183
1184         if (!uid_is_valid(uid)) {
1185                 /* Note that we get the owner UID of the session or user unit,
1186                  * not the actual client UID here! */
1187                 r = sd_bus_creds_get_owner_uid(creds, &uid);
1188                 if (r < 0)
1189                         return r;
1190         }
1191
1192         /* owner_uid is racy, so for authorization we must use euid */
1193         r = sd_bus_creds_get_euid(creds, &auth_uid);
1194         if (r < 0)
1195                 return r;
1196
1197         errno = 0;
1198         pw = getpwuid(uid);
1199         if (!pw)
1200                 return errno > 0 ? -errno : -ENOENT;
1201
1202         r = bus_verify_polkit_async(
1203                         message,
1204                         CAP_SYS_ADMIN,
1205                         uid == auth_uid ? "org.freedesktop.login1.set-self-linger" :
1206                                           "org.freedesktop.login1.set-user-linger",
1207                         NULL,
1208                         interactive,
1209                         UID_INVALID,
1210                         &m->polkit_registry,
1211                         error);
1212         if (r < 0)
1213                 return r;
1214         if (r == 0)
1215                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1216
1217         mkdir_p_label("/var/lib/systemd", 0755);
1218
1219         r = mkdir_safe_label("/var/lib/systemd/linger", 0755, 0, 0, false);
1220         if (r < 0)
1221                 return r;
1222
1223         cc = cescape(pw->pw_name);
1224         if (!cc)
1225                 return -ENOMEM;
1226
1227         path = strjoina("/var/lib/systemd/linger/", cc);
1228         if (b) {
1229                 User *u;
1230
1231                 r = touch(path);
1232                 if (r < 0)
1233                         return r;
1234
1235                 if (manager_add_user_by_uid(m, uid, &u) >= 0)
1236                         user_start(u);
1237
1238         } else {
1239                 User *u;
1240
1241                 r = unlink(path);
1242                 if (r < 0 && errno != ENOENT)
1243                         return -errno;
1244
1245                 u = hashmap_get(m->users, UID_TO_PTR(uid));
1246                 if (u)
1247                         user_add_to_gc_queue(u);
1248         }
1249
1250         return sd_bus_reply_method_return(message, NULL);
1251 }
1252
1253 static int trigger_device(Manager *m, struct udev_device *d) {
1254         _cleanup_udev_enumerate_unref_ struct udev_enumerate *e = NULL;
1255         struct udev_list_entry *first, *item;
1256         int r;
1257
1258         assert(m);
1259
1260         e = udev_enumerate_new(m->udev);
1261         if (!e)
1262                 return -ENOMEM;
1263
1264         if (d) {
1265                 r = udev_enumerate_add_match_parent(e, d);
1266                 if (r < 0)
1267                         return r;
1268         }
1269
1270         r = udev_enumerate_scan_devices(e);
1271         if (r < 0)
1272                 return r;
1273
1274         first = udev_enumerate_get_list_entry(e);
1275         udev_list_entry_foreach(item, first) {
1276                 _cleanup_free_ char *t = NULL;
1277                 const char *p;
1278
1279                 p = udev_list_entry_get_name(item);
1280
1281                 t = strappend(p, "/uevent");
1282                 if (!t)
1283                         return -ENOMEM;
1284
1285                 (void) write_string_file(t, "change", 0);
1286         }
1287
1288         return 0;
1289 }
1290
1291 static int attach_device(Manager *m, const char *seat, const char *sysfs) {
1292         _cleanup_udev_device_unref_ struct udev_device *d = NULL;
1293         _cleanup_free_ char *rule = NULL, *file = NULL;
1294         const char *id_for_seat;
1295         int r;
1296
1297         assert(m);
1298         assert(seat);
1299         assert(sysfs);
1300
1301         d = udev_device_new_from_syspath(m->udev, sysfs);
1302         if (!d)
1303                 return -ENODEV;
1304
1305         if (!udev_device_has_tag(d, "seat"))
1306                 return -ENODEV;
1307
1308         id_for_seat = udev_device_get_property_value(d, "ID_FOR_SEAT");
1309         if (!id_for_seat)
1310                 return -ENODEV;
1311
1312         if (asprintf(&file, "/etc/udev/rules.d/72-seat-%s.rules", id_for_seat) < 0)
1313                 return -ENOMEM;
1314
1315         if (asprintf(&rule, "TAG==\"seat\", ENV{ID_FOR_SEAT}==\"%s\", ENV{ID_SEAT}=\"%s\"", id_for_seat, seat) < 0)
1316                 return -ENOMEM;
1317
1318         mkdir_p_label("/etc/udev/rules.d", 0755);
1319         r = write_string_file_atomic_label(file, rule);
1320         if (r < 0)
1321                 return r;
1322
1323         return trigger_device(m, d);
1324 }
1325
1326 static int flush_devices(Manager *m) {
1327         _cleanup_closedir_ DIR *d;
1328
1329         assert(m);
1330
1331         d = opendir("/etc/udev/rules.d");
1332         if (!d) {
1333                 if (errno != ENOENT)
1334                         log_warning_errno(errno, "Failed to open /etc/udev/rules.d: %m");
1335         } else {
1336                 struct dirent *de;
1337
1338                 FOREACH_DIRENT_ALL(de, d, break) {
1339                         if (!dirent_is_file(de))
1340                                 continue;
1341
1342                         if (!startswith(de->d_name, "72-seat-"))
1343                                 continue;
1344
1345                         if (!endswith(de->d_name, ".rules"))
1346                                 continue;
1347
1348                         if (unlinkat(dirfd(d), de->d_name, 0) < 0)
1349                                 log_warning_errno(errno, "Failed to unlink %s: %m", de->d_name);
1350                 }
1351         }
1352
1353         return trigger_device(m, NULL);
1354 }
1355
1356 static int method_attach_device(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1357         const char *sysfs, *seat;
1358         Manager *m = userdata;
1359         int interactive, r;
1360
1361         assert(message);
1362         assert(m);
1363
1364         r = sd_bus_message_read(message, "ssb", &seat, &sysfs, &interactive);
1365         if (r < 0)
1366                 return r;
1367
1368         if (!path_startswith(sysfs, "/sys"))
1369                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Path %s is not in /sys", sysfs);
1370
1371         if (!seat_name_is_valid(seat))
1372                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Seat %s is not valid", seat);
1373
1374         r = bus_verify_polkit_async(
1375                         message,
1376                         CAP_SYS_ADMIN,
1377                         "org.freedesktop.login1.attach-device",
1378                         NULL,
1379                         interactive,
1380                         UID_INVALID,
1381                         &m->polkit_registry,
1382                         error);
1383         if (r < 0)
1384                 return r;
1385         if (r == 0)
1386                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1387
1388         r = attach_device(m, seat, sysfs);
1389         if (r < 0)
1390                 return r;
1391
1392         return sd_bus_reply_method_return(message, NULL);
1393 }
1394
1395 static int method_flush_devices(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1396         Manager *m = userdata;
1397         int interactive, r;
1398
1399         assert(message);
1400         assert(m);
1401
1402         r = sd_bus_message_read(message, "b", &interactive);
1403         if (r < 0)
1404                 return r;
1405
1406         r = bus_verify_polkit_async(
1407                         message,
1408                         CAP_SYS_ADMIN,
1409                         "org.freedesktop.login1.flush-devices",
1410                         NULL,
1411                         interactive,
1412                         UID_INVALID,
1413                         &m->polkit_registry,
1414                         error);
1415         if (r < 0)
1416                 return r;
1417         if (r == 0)
1418                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1419
1420         r = flush_devices(m);
1421         if (r < 0)
1422                 return r;
1423
1424         return sd_bus_reply_method_return(message, NULL);
1425 }
1426
1427 static int have_multiple_sessions(
1428                 Manager *m,
1429                 uid_t uid) {
1430
1431         Session *session;
1432         Iterator i;
1433
1434         assert(m);
1435
1436         /* Check for other users' sessions. Greeter sessions do not
1437          * count, and non-login sessions do not count either. */
1438         HASHMAP_FOREACH(session, m->sessions, i)
1439                 if (session->class == SESSION_USER &&
1440                     session->user->uid != uid)
1441                         return true;
1442
1443         return false;
1444 }
1445
1446 static int bus_manager_log_shutdown(
1447                 Manager *m,
1448                 const char *unit_name) {
1449
1450         const char *p, *q;
1451
1452         assert(m);
1453         assert(unit_name);
1454
1455         if (streq(unit_name, SPECIAL_POWEROFF_TARGET)) {
1456                 p = "MESSAGE=System is powering down";
1457                 q = "SHUTDOWN=power-off";
1458         } else if (streq(unit_name, SPECIAL_REBOOT_TARGET)) {
1459                 p = "MESSAGE=System is rebooting";
1460                 q = "SHUTDOWN=reboot";
1461         } else if (streq(unit_name, SPECIAL_HALT_TARGET)) {
1462                 p = "MESSAGE=System is halting";
1463                 q = "SHUTDOWN=halt";
1464         } else if (streq(unit_name, SPECIAL_KEXEC_TARGET)) {
1465                 p = "MESSAGE=System is rebooting with kexec";
1466                 q = "SHUTDOWN=kexec";
1467         } else {
1468                 p = "MESSAGE=System is shutting down";
1469                 q = NULL;
1470         }
1471
1472         if (isempty(m->wall_message))
1473                 p = strjoina(p, ".");
1474         else
1475                 p = strjoina(p, " (", m->wall_message, ").");
1476
1477         return log_struct(LOG_NOTICE,
1478                           "MESSAGE_ID=" SD_MESSAGE_SHUTDOWN_STR,
1479                           p,
1480                           q,
1481                           NULL);
1482 }
1483
1484 static int lid_switch_ignore_handler(sd_event_source *e, uint64_t usec, void *userdata) {
1485         Manager *m = userdata;
1486
1487         assert(e);
1488         assert(m);
1489
1490         m->lid_switch_ignore_event_source = sd_event_source_unref(m->lid_switch_ignore_event_source);
1491         return 0;
1492 }
1493
1494 int manager_set_lid_switch_ignore(Manager *m, usec_t until) {
1495         int r;
1496
1497         assert(m);
1498
1499         if (until <= now(CLOCK_MONOTONIC))
1500                 return 0;
1501
1502         /* We want to ignore the lid switch for a while after each
1503          * suspend, and after boot-up. Hence let's install a timer for
1504          * this. As long as the event source exists we ignore the lid
1505          * switch. */
1506
1507         if (m->lid_switch_ignore_event_source) {
1508                 usec_t u;
1509
1510                 r = sd_event_source_get_time(m->lid_switch_ignore_event_source, &u);
1511                 if (r < 0)
1512                         return r;
1513
1514                 if (until <= u)
1515                         return 0;
1516
1517                 r = sd_event_source_set_time(m->lid_switch_ignore_event_source, until);
1518         } else
1519                 r = sd_event_add_time(
1520                                 m->event,
1521                                 &m->lid_switch_ignore_event_source,
1522                                 CLOCK_MONOTONIC,
1523                                 until, 0,
1524                                 lid_switch_ignore_handler, m);
1525
1526         return r;
1527 }
1528
1529 static int send_prepare_for(Manager *m, InhibitWhat w, bool _active) {
1530
1531         static const char * const signal_name[_INHIBIT_WHAT_MAX] = {
1532                 [INHIBIT_SHUTDOWN] = "PrepareForShutdown",
1533                 [INHIBIT_SLEEP] = "PrepareForSleep"
1534         };
1535
1536         int active = _active;
1537
1538         assert(m);
1539         assert(w >= 0);
1540         assert(w < _INHIBIT_WHAT_MAX);
1541         assert(signal_name[w]);
1542
1543         return sd_bus_emit_signal(m->bus,
1544                                   "/org/freedesktop/login1",
1545                                   "org.freedesktop.login1.Manager",
1546                                   signal_name[w],
1547                                   "b",
1548                                   active);
1549 }
1550
1551 static int execute_shutdown_or_sleep(
1552                 Manager *m,
1553                 InhibitWhat w,
1554                 const char *unit_name,
1555                 sd_bus_error *error) {
1556
1557         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
1558         char *c = NULL;
1559         const char *p;
1560         int r;
1561
1562         assert(m);
1563         assert(w > 0);
1564         assert(w < _INHIBIT_WHAT_MAX);
1565         assert(unit_name);
1566
1567         if (w == INHIBIT_SHUTDOWN)
1568                 bus_manager_log_shutdown(m, unit_name);
1569
1570         r = sd_bus_call_method(
1571                         m->bus,
1572                         "org.freedesktop.systemd1",
1573                         "/org/freedesktop/systemd1",
1574                         "org.freedesktop.systemd1.Manager",
1575                         "StartUnit",
1576                         error,
1577                         &reply,
1578                         "ss", unit_name, "replace-irreversibly");
1579         if (r < 0)
1580                 goto error;
1581
1582         r = sd_bus_message_read(reply, "o", &p);
1583         if (r < 0)
1584                 goto error;
1585
1586         c = strdup(p);
1587         if (!c) {
1588                 r = -ENOMEM;
1589                 goto error;
1590         }
1591
1592         m->action_unit = unit_name;
1593         free(m->action_job);
1594         m->action_job = c;
1595         m->action_what = w;
1596
1597         /* Make sure the lid switch is ignored for a while */
1598         manager_set_lid_switch_ignore(m, now(CLOCK_MONOTONIC) + m->holdoff_timeout_usec);
1599
1600         return 0;
1601
1602 error:
1603         /* Tell people that they now may take a lock again */
1604         (void) send_prepare_for(m, w, false);
1605
1606         return r;
1607 }
1608
1609 int manager_dispatch_delayed(Manager *manager, bool timeout) {
1610
1611         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1612         Inhibitor *offending = NULL;
1613         int r;
1614
1615         assert(manager);
1616
1617         if (manager->action_what == 0 || manager->action_job)
1618                 return 0;
1619
1620         if (manager_is_inhibited(manager, manager->action_what, INHIBIT_DELAY, NULL, false, false, 0, &offending)) {
1621                 _cleanup_free_ char *comm = NULL, *u = NULL;
1622
1623                 if (!timeout)
1624                         return 0;
1625
1626                 (void) get_process_comm(offending->pid, &comm);
1627                 u = uid_to_name(offending->uid);
1628
1629                 log_notice("Delay lock is active (UID "UID_FMT"/%s, PID "PID_FMT"/%s) but inhibitor timeout is reached.",
1630                            offending->uid, strna(u),
1631                            offending->pid, strna(comm));
1632         }
1633
1634         /* Actually do the operation */
1635         r = execute_shutdown_or_sleep(manager, manager->action_what, manager->action_unit, &error);
1636         if (r < 0) {
1637                 log_warning("Error during inhibitor-delayed operation (already returned success to client): %s",
1638                             bus_error_message(&error, r));
1639
1640                 manager->action_unit = NULL;
1641                 manager->action_what = 0;
1642                 return r;
1643         }
1644
1645         return 1;
1646 }
1647
1648 static int manager_inhibit_timeout_handler(
1649                         sd_event_source *s,
1650                         uint64_t usec,
1651                         void *userdata) {
1652
1653         Manager *manager = userdata;
1654         int r;
1655
1656         assert(manager);
1657         assert(manager->inhibit_timeout_source == s);
1658
1659         r = manager_dispatch_delayed(manager, true);
1660         return (r < 0) ? r : 0;
1661 }
1662
1663 static int delay_shutdown_or_sleep(
1664                 Manager *m,
1665                 InhibitWhat w,
1666                 const char *unit_name) {
1667
1668         int r;
1669         usec_t timeout_val;
1670
1671         assert(m);
1672         assert(w >= 0);
1673         assert(w < _INHIBIT_WHAT_MAX);
1674         assert(unit_name);
1675
1676         timeout_val = now(CLOCK_MONOTONIC) + m->inhibit_delay_max;
1677
1678         if (m->inhibit_timeout_source) {
1679                 r = sd_event_source_set_time(m->inhibit_timeout_source, timeout_val);
1680                 if (r < 0)
1681                         return log_error_errno(r, "sd_event_source_set_time() failed: %m");
1682
1683                 r = sd_event_source_set_enabled(m->inhibit_timeout_source, SD_EVENT_ONESHOT);
1684                 if (r < 0)
1685                         return log_error_errno(r, "sd_event_source_set_enabled() failed: %m");
1686         } else {
1687                 r = sd_event_add_time(m->event, &m->inhibit_timeout_source, CLOCK_MONOTONIC,
1688                                       timeout_val, 0, manager_inhibit_timeout_handler, m);
1689                 if (r < 0)
1690                         return r;
1691         }
1692
1693         m->action_unit = unit_name;
1694         m->action_what = w;
1695
1696         return 0;
1697 }
1698
1699 int bus_manager_shutdown_or_sleep_now_or_later(
1700                 Manager *m,
1701                 const char *unit_name,
1702                 InhibitWhat w,
1703                 sd_bus_error *error) {
1704
1705         bool delayed;
1706         int r;
1707
1708         assert(m);
1709         assert(unit_name);
1710         assert(w > 0);
1711         assert(w <= _INHIBIT_WHAT_MAX);
1712         assert(!m->action_job);
1713
1714         /* Tell everybody to prepare for shutdown/sleep */
1715         (void) send_prepare_for(m, w, true);
1716
1717         delayed =
1718                 m->inhibit_delay_max > 0 &&
1719                 manager_is_inhibited(m, w, INHIBIT_DELAY, NULL, false, false, 0, NULL);
1720
1721         if (delayed)
1722                 /* Shutdown is delayed, keep in mind what we
1723                  * want to do, and start a timeout */
1724                 r = delay_shutdown_or_sleep(m, w, unit_name);
1725         else
1726                 /* Shutdown is not delayed, execute it
1727                  * immediately */
1728                 r = execute_shutdown_or_sleep(m, w, unit_name, error);
1729
1730         return r;
1731 }
1732
1733 static int verify_shutdown_creds(
1734                 Manager *m,
1735                 sd_bus_message *message,
1736                 InhibitWhat w,
1737                 bool interactive,
1738                 const char *action,
1739                 const char *action_multiple_sessions,
1740                 const char *action_ignore_inhibit,
1741                 sd_bus_error *error) {
1742
1743         _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
1744         bool multiple_sessions, blocked;
1745         uid_t uid;
1746         int r;
1747
1748         assert(m);
1749         assert(message);
1750         assert(w >= 0);
1751         assert(w <= _INHIBIT_WHAT_MAX);
1752
1753         r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_EUID, &creds);
1754         if (r < 0)
1755                 return r;
1756
1757         r = sd_bus_creds_get_euid(creds, &uid);
1758         if (r < 0)
1759                 return r;
1760
1761         r = have_multiple_sessions(m, uid);
1762         if (r < 0)
1763                 return r;
1764
1765         multiple_sessions = r > 0;
1766         blocked = manager_is_inhibited(m, w, INHIBIT_BLOCK, NULL, false, true, uid, NULL);
1767
1768         if (multiple_sessions && action_multiple_sessions) {
1769                 r = bus_verify_polkit_async(message, CAP_SYS_BOOT, action_multiple_sessions, NULL, interactive, UID_INVALID, &m->polkit_registry, error);
1770                 if (r < 0)
1771                         return r;
1772                 if (r == 0)
1773                         return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1774         }
1775
1776         if (blocked && action_ignore_inhibit) {
1777                 r = bus_verify_polkit_async(message, CAP_SYS_BOOT, action_ignore_inhibit, NULL, interactive, UID_INVALID, &m->polkit_registry, error);
1778                 if (r < 0)
1779                         return r;
1780                 if (r == 0)
1781                         return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1782         }
1783
1784         if (!multiple_sessions && !blocked && action) {
1785                 r = bus_verify_polkit_async(message, CAP_SYS_BOOT, action, NULL, interactive, UID_INVALID, &m->polkit_registry, error);
1786                 if (r < 0)
1787                         return r;
1788                 if (r == 0)
1789                         return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1790         }
1791
1792         return 0;
1793 }
1794
1795 static int method_do_shutdown_or_sleep(
1796                 Manager *m,
1797                 sd_bus_message *message,
1798                 const char *unit_name,
1799                 InhibitWhat w,
1800                 const char *action,
1801                 const char *action_multiple_sessions,
1802                 const char *action_ignore_inhibit,
1803                 const char *sleep_verb,
1804                 sd_bus_error *error) {
1805
1806         int interactive, r;
1807
1808         assert(m);
1809         assert(message);
1810         assert(unit_name);
1811         assert(w >= 0);
1812         assert(w <= _INHIBIT_WHAT_MAX);
1813
1814         r = sd_bus_message_read(message, "b", &interactive);
1815         if (r < 0)
1816                 return r;
1817
1818         /* Don't allow multiple jobs being executed at the same time */
1819         if (m->action_what)
1820                 return sd_bus_error_setf(error, BUS_ERROR_OPERATION_IN_PROGRESS, "There's already a shutdown or sleep operation in progress");
1821
1822         if (sleep_verb) {
1823                 r = can_sleep(sleep_verb);
1824                 if (r < 0)
1825                         return r;
1826
1827                 if (r == 0)
1828                         return sd_bus_error_setf(error, BUS_ERROR_SLEEP_VERB_NOT_SUPPORTED, "Sleep verb not supported");
1829         }
1830
1831         r = verify_shutdown_creds(m, message, w, interactive, action, action_multiple_sessions,
1832                                   action_ignore_inhibit, error);
1833         if (r != 0)
1834                 return r;
1835
1836         r = bus_manager_shutdown_or_sleep_now_or_later(m, unit_name, w, error);
1837         if (r < 0)
1838                 return r;
1839
1840         return sd_bus_reply_method_return(message, NULL);
1841 }
1842
1843 static int method_poweroff(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1844         Manager *m = userdata;
1845
1846         return method_do_shutdown_or_sleep(
1847                         m, message,
1848                         SPECIAL_POWEROFF_TARGET,
1849                         INHIBIT_SHUTDOWN,
1850                         "org.freedesktop.login1.power-off",
1851                         "org.freedesktop.login1.power-off-multiple-sessions",
1852                         "org.freedesktop.login1.power-off-ignore-inhibit",
1853                         NULL,
1854                         error);
1855 }
1856
1857 static int method_reboot(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1858         Manager *m = userdata;
1859
1860         return method_do_shutdown_or_sleep(
1861                         m, message,
1862                         SPECIAL_REBOOT_TARGET,
1863                         INHIBIT_SHUTDOWN,
1864                         "org.freedesktop.login1.reboot",
1865                         "org.freedesktop.login1.reboot-multiple-sessions",
1866                         "org.freedesktop.login1.reboot-ignore-inhibit",
1867                         NULL,
1868                         error);
1869 }
1870
1871 static int method_halt(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1872         Manager *m = userdata;
1873
1874         return method_do_shutdown_or_sleep(
1875                         m, message,
1876                         SPECIAL_HALT_TARGET,
1877                         INHIBIT_SHUTDOWN,
1878                         "org.freedesktop.login1.halt",
1879                         "org.freedesktop.login1.halt-multiple-sessions",
1880                         "org.freedesktop.login1.halt-ignore-inhibit",
1881                         NULL,
1882                         error);
1883 }
1884
1885 static int method_suspend(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1886         Manager *m = userdata;
1887
1888         return method_do_shutdown_or_sleep(
1889                         m, message,
1890                         SPECIAL_SUSPEND_TARGET,
1891                         INHIBIT_SLEEP,
1892                         "org.freedesktop.login1.suspend",
1893                         "org.freedesktop.login1.suspend-multiple-sessions",
1894                         "org.freedesktop.login1.suspend-ignore-inhibit",
1895                         "suspend",
1896                         error);
1897 }
1898
1899 static int method_hibernate(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1900         Manager *m = userdata;
1901
1902         return method_do_shutdown_or_sleep(
1903                         m, message,
1904                         SPECIAL_HIBERNATE_TARGET,
1905                         INHIBIT_SLEEP,
1906                         "org.freedesktop.login1.hibernate",
1907                         "org.freedesktop.login1.hibernate-multiple-sessions",
1908                         "org.freedesktop.login1.hibernate-ignore-inhibit",
1909                         "hibernate",
1910                         error);
1911 }
1912
1913 static int method_hybrid_sleep(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1914         Manager *m = userdata;
1915
1916         return method_do_shutdown_or_sleep(
1917                         m, message,
1918                         SPECIAL_HYBRID_SLEEP_TARGET,
1919                         INHIBIT_SLEEP,
1920                         "org.freedesktop.login1.hibernate",
1921                         "org.freedesktop.login1.hibernate-multiple-sessions",
1922                         "org.freedesktop.login1.hibernate-ignore-inhibit",
1923                         "hybrid-sleep",
1924                         error);
1925 }
1926
1927 static int nologin_timeout_handler(
1928                         sd_event_source *s,
1929                         uint64_t usec,
1930                         void *userdata) {
1931
1932         Manager *m = userdata;
1933         int r;
1934
1935         log_info("Creating /run/nologin, blocking further logins...");
1936
1937         r = write_string_file_atomic_label("/run/nologin", "System is going down.");
1938         if (r < 0)
1939                 log_error_errno(r, "Failed to create /run/nologin: %m");
1940         else
1941                 m->unlink_nologin = true;
1942
1943         return 0;
1944 }
1945
1946 static int update_schedule_file(Manager *m) {
1947         _cleanup_free_ char *temp_path = NULL;
1948         _cleanup_fclose_ FILE *f = NULL;
1949         int r;
1950
1951         assert(m);
1952
1953         r = mkdir_safe_label("/run/systemd/shutdown", 0755, 0, 0, false);
1954         if (r < 0)
1955                 return log_error_errno(r, "Failed to create shutdown subdirectory: %m");
1956
1957         r = fopen_temporary("/run/systemd/shutdown/scheduled", &f, &temp_path);
1958         if (r < 0)
1959                 return log_error_errno(r, "Failed to save information about scheduled shutdowns: %m");
1960
1961         (void) fchmod(fileno(f), 0644);
1962
1963         fprintf(f,
1964                 "USEC="USEC_FMT"\n"
1965                 "WARN_WALL=%i\n"
1966                 "MODE=%s\n",
1967                 m->scheduled_shutdown_timeout,
1968                 m->enable_wall_messages,
1969                 m->scheduled_shutdown_type);
1970
1971         if (!isempty(m->wall_message)) {
1972                 _cleanup_free_ char *t;
1973
1974                 t = cescape(m->wall_message);
1975                 if (!t) {
1976                         r = -ENOMEM;
1977                         goto fail;
1978                 }
1979
1980                 fprintf(f, "WALL_MESSAGE=%s\n", t);
1981         }
1982
1983         r = fflush_and_check(f);
1984         if (r < 0)
1985                 goto fail;
1986
1987         if (rename(temp_path, "/run/systemd/shutdown/scheduled") < 0) {
1988                 r = -errno;
1989                 goto fail;
1990         }
1991
1992         return 0;
1993
1994 fail:
1995         (void) unlink(temp_path);
1996         (void) unlink("/run/systemd/shutdown/scheduled");
1997
1998         return log_error_errno(r, "Failed to write information about scheduled shutdowns: %m");
1999 }
2000
2001 static void reset_scheduled_shutdown(Manager *m) {
2002         assert(m);
2003
2004         m->scheduled_shutdown_timeout_source = sd_event_source_unref(m->scheduled_shutdown_timeout_source);
2005         m->wall_message_timeout_source = sd_event_source_unref(m->wall_message_timeout_source);
2006         m->nologin_timeout_source = sd_event_source_unref(m->nologin_timeout_source);
2007
2008         m->scheduled_shutdown_type = mfree(m->scheduled_shutdown_type);
2009         m->scheduled_shutdown_timeout = 0;
2010         m->shutdown_dry_run = false;
2011
2012         if (m->unlink_nologin) {
2013                 (void) unlink("/run/nologin");
2014                 m->unlink_nologin = false;
2015         }
2016
2017         (void) unlink("/run/systemd/shutdown/scheduled");
2018 }
2019
2020 static int manager_scheduled_shutdown_handler(
2021                         sd_event_source *s,
2022                         uint64_t usec,
2023                         void *userdata) {
2024
2025         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
2026         Manager *m = userdata;
2027         const char *target;
2028         int r;
2029
2030         assert(m);
2031
2032         if (isempty(m->scheduled_shutdown_type))
2033                 return 0;
2034
2035         if (streq(m->scheduled_shutdown_type, "poweroff"))
2036                 target = SPECIAL_POWEROFF_TARGET;
2037         else if (streq(m->scheduled_shutdown_type, "reboot"))
2038                 target = SPECIAL_REBOOT_TARGET;
2039         else if (streq(m->scheduled_shutdown_type, "halt"))
2040                 target = SPECIAL_HALT_TARGET;
2041         else
2042                 assert_not_reached("unexpected shutdown type");
2043
2044         /* Don't allow multiple jobs being executed at the same time */
2045         if (m->action_what) {
2046                 r = -EALREADY;
2047                 log_error("Scheduled shutdown to %s failed: shutdown or sleep operation already in progress", target);
2048                 goto error;
2049         }
2050
2051         if (m->shutdown_dry_run) {
2052                 /* We do not process delay inhibitors here.  Otherwise, we
2053                  * would have to be considered "in progress" (like the check
2054                  * above) for some seconds after our admin has seen the final
2055                  * wall message. */
2056
2057                 bus_manager_log_shutdown(m, target);
2058                 log_info("Running in dry run, suppressing action.");
2059                 reset_scheduled_shutdown(m);
2060
2061                 return 0;
2062         }
2063
2064         r = bus_manager_shutdown_or_sleep_now_or_later(m, target, INHIBIT_SHUTDOWN, &error);
2065         if (r < 0) {
2066                 log_error_errno(r, "Scheduled shutdown to %s failed: %m", target);
2067                 goto error;
2068         }
2069
2070         return 0;
2071
2072 error:
2073         reset_scheduled_shutdown(m);
2074         return r;
2075 }
2076
2077 static int method_schedule_shutdown(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2078         Manager *m = userdata;
2079         _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
2080         const char *action_multiple_sessions = NULL;
2081         const char *action_ignore_inhibit = NULL;
2082         const char *action = NULL;
2083         uint64_t elapse;
2084         char *type;
2085         int r;
2086         bool dry_run = false;
2087
2088         assert(m);
2089         assert(message);
2090
2091         r = sd_bus_message_read(message, "st", &type, &elapse);
2092         if (r < 0)
2093                 return r;
2094
2095         if (startswith(type, "dry-")) {
2096                 type += 4;
2097                 dry_run = true;
2098         }
2099
2100         if (streq(type, "poweroff")) {
2101                 action = "org.freedesktop.login1.power-off";
2102                 action_multiple_sessions = "org.freedesktop.login1.power-off-multiple-sessions";
2103                 action_ignore_inhibit = "org.freedesktop.login1.power-off-ignore-inhibit";
2104         } else if (streq(type, "reboot")) {
2105                 action = "org.freedesktop.login1.reboot";
2106                 action_multiple_sessions = "org.freedesktop.login1.reboot-multiple-sessions";
2107                 action_ignore_inhibit = "org.freedesktop.login1.reboot-ignore-inhibit";
2108         } else if (streq(type, "halt")) {
2109                 action = "org.freedesktop.login1.halt";
2110                 action_multiple_sessions = "org.freedesktop.login1.halt-multiple-sessions";
2111                 action_ignore_inhibit = "org.freedesktop.login1.halt-ignore-inhibit";
2112         } else
2113                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Unsupported shutdown type");
2114
2115         r = verify_shutdown_creds(m, message, INHIBIT_SHUTDOWN, false,
2116                                   action, action_multiple_sessions, action_ignore_inhibit, error);
2117         if (r != 0)
2118                 return r;
2119
2120         if (m->scheduled_shutdown_timeout_source) {
2121                 r = sd_event_source_set_time(m->scheduled_shutdown_timeout_source, elapse);
2122                 if (r < 0)
2123                         return log_error_errno(r, "sd_event_source_set_time() failed: %m");
2124
2125                 r = sd_event_source_set_enabled(m->scheduled_shutdown_timeout_source, SD_EVENT_ONESHOT);
2126                 if (r < 0)
2127                         return log_error_errno(r, "sd_event_source_set_enabled() failed: %m");
2128         } else {
2129                 r = sd_event_add_time(m->event, &m->scheduled_shutdown_timeout_source,
2130                                       CLOCK_REALTIME, elapse, 0, manager_scheduled_shutdown_handler, m);
2131                 if (r < 0)
2132                         return log_error_errno(r, "sd_event_add_time() failed: %m");
2133         }
2134
2135         r = free_and_strdup(&m->scheduled_shutdown_type, type);
2136         if (r < 0) {
2137                 m->scheduled_shutdown_timeout_source = sd_event_source_unref(m->scheduled_shutdown_timeout_source);
2138                 return log_oom();
2139         }
2140
2141         m->shutdown_dry_run = dry_run;
2142
2143         if (m->nologin_timeout_source) {
2144                 r = sd_event_source_set_time(m->nologin_timeout_source, elapse);
2145                 if (r < 0)
2146                         return log_error_errno(r, "sd_event_source_set_time() failed: %m");
2147
2148                 r = sd_event_source_set_enabled(m->nologin_timeout_source, SD_EVENT_ONESHOT);
2149                 if (r < 0)
2150                         return log_error_errno(r, "sd_event_source_set_enabled() failed: %m");
2151         } else {
2152                 r = sd_event_add_time(m->event, &m->nologin_timeout_source,
2153                                       CLOCK_REALTIME, elapse - 5 * USEC_PER_MINUTE, 0, nologin_timeout_handler, m);
2154                 if (r < 0)
2155                         return log_error_errno(r, "sd_event_add_time() failed: %m");
2156         }
2157
2158         m->scheduled_shutdown_timeout = elapse;
2159
2160         r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_AUGMENT|SD_BUS_CREDS_TTY|SD_BUS_CREDS_UID, &creds);
2161         if (r >= 0) {
2162                 const char *tty = NULL;
2163
2164                 (void) sd_bus_creds_get_uid(creds, &m->scheduled_shutdown_uid);
2165                 (void) sd_bus_creds_get_tty(creds, &tty);
2166
2167                 r = free_and_strdup(&m->scheduled_shutdown_tty, tty);
2168                 if (r < 0) {
2169                         m->scheduled_shutdown_timeout_source = sd_event_source_unref(m->scheduled_shutdown_timeout_source);
2170                         return log_oom();
2171                 }
2172         }
2173
2174         r = manager_setup_wall_message_timer(m);
2175         if (r < 0)
2176                 return r;
2177
2178         r = update_schedule_file(m);
2179         if (r < 0)
2180                 return r;
2181
2182         return sd_bus_reply_method_return(message, NULL);
2183 }
2184
2185 static int method_cancel_scheduled_shutdown(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2186         Manager *m = userdata;
2187         bool cancelled;
2188
2189         assert(m);
2190         assert(message);
2191
2192         cancelled = m->scheduled_shutdown_type != NULL;
2193         reset_scheduled_shutdown(m);
2194
2195         if (cancelled) {
2196                 _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
2197                 const char *tty = NULL;
2198                 uid_t uid = 0;
2199                 int r;
2200
2201                 r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_AUGMENT|SD_BUS_CREDS_TTY|SD_BUS_CREDS_UID, &creds);
2202                 if (r >= 0) {
2203                         (void) sd_bus_creds_get_uid(creds, &uid);
2204                         (void) sd_bus_creds_get_tty(creds, &tty);
2205                 }
2206
2207                 utmp_wall("The system shutdown has been cancelled",
2208                           uid_to_name(uid), tty, logind_wall_tty_filter, m);
2209         }
2210
2211         return sd_bus_reply_method_return(message, "b", cancelled);
2212 }
2213
2214 static int method_can_shutdown_or_sleep(
2215                 Manager *m,
2216                 sd_bus_message *message,
2217                 InhibitWhat w,
2218                 const char *action,
2219                 const char *action_multiple_sessions,
2220                 const char *action_ignore_inhibit,
2221                 const char *sleep_verb,
2222                 sd_bus_error *error) {
2223
2224         _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
2225         bool multiple_sessions, challenge, blocked;
2226         const char *result = NULL;
2227         uid_t uid;
2228         int r;
2229
2230         assert(m);
2231         assert(message);
2232         assert(w >= 0);
2233         assert(w <= _INHIBIT_WHAT_MAX);
2234         assert(action);
2235         assert(action_multiple_sessions);
2236         assert(action_ignore_inhibit);
2237
2238         if (sleep_verb) {
2239                 r = can_sleep(sleep_verb);
2240                 if (r < 0)
2241                         return r;
2242                 if (r == 0)
2243                         return sd_bus_reply_method_return(message, "s", "na");
2244         }
2245
2246         r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_EUID, &creds);
2247         if (r < 0)
2248                 return r;
2249
2250         r = sd_bus_creds_get_euid(creds, &uid);
2251         if (r < 0)
2252                 return r;
2253
2254         r = have_multiple_sessions(m, uid);
2255         if (r < 0)
2256                 return r;
2257
2258         multiple_sessions = r > 0;
2259         blocked = manager_is_inhibited(m, w, INHIBIT_BLOCK, NULL, false, true, uid, NULL);
2260
2261         if (multiple_sessions) {
2262                 r = bus_test_polkit(message, CAP_SYS_BOOT, action_multiple_sessions, NULL, UID_INVALID, &challenge, error);
2263                 if (r < 0)
2264                         return r;
2265
2266                 if (r > 0)
2267                         result = "yes";
2268                 else if (challenge)
2269                         result = "challenge";
2270                 else
2271                         result = "no";
2272         }
2273
2274         if (blocked) {
2275                 r = bus_test_polkit(message, CAP_SYS_BOOT, action_ignore_inhibit, NULL, UID_INVALID, &challenge, error);
2276                 if (r < 0)
2277                         return r;
2278
2279                 if (r > 0 && !result)
2280                         result = "yes";
2281                 else if (challenge && (!result || streq(result, "yes")))
2282                         result = "challenge";
2283                 else
2284                         result = "no";
2285         }
2286
2287         if (!multiple_sessions && !blocked) {
2288                 /* If neither inhibit nor multiple sessions
2289                  * apply then just check the normal policy */
2290
2291                 r = bus_test_polkit(message, CAP_SYS_BOOT, action, NULL, UID_INVALID, &challenge, error);
2292                 if (r < 0)
2293                         return r;
2294
2295                 if (r > 0)
2296                         result = "yes";
2297                 else if (challenge)
2298                         result = "challenge";
2299                 else
2300                         result = "no";
2301         }
2302
2303         return sd_bus_reply_method_return(message, "s", result);
2304 }
2305
2306 static int method_can_poweroff(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2307         Manager *m = userdata;
2308
2309         return method_can_shutdown_or_sleep(
2310                         m, message,
2311                         INHIBIT_SHUTDOWN,
2312                         "org.freedesktop.login1.power-off",
2313                         "org.freedesktop.login1.power-off-multiple-sessions",
2314                         "org.freedesktop.login1.power-off-ignore-inhibit",
2315                         NULL,
2316                         error);
2317 }
2318
2319 static int method_can_reboot(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2320         Manager *m = userdata;
2321
2322         return method_can_shutdown_or_sleep(
2323                         m, message,
2324                         INHIBIT_SHUTDOWN,
2325                         "org.freedesktop.login1.reboot",
2326                         "org.freedesktop.login1.reboot-multiple-sessions",
2327                         "org.freedesktop.login1.reboot-ignore-inhibit",
2328                         NULL,
2329                         error);
2330 }
2331
2332 static int method_can_halt(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2333         Manager *m = userdata;
2334
2335         return method_can_shutdown_or_sleep(
2336                         m, message,
2337                         INHIBIT_SHUTDOWN,
2338                         "org.freedesktop.login1.halt",
2339                         "org.freedesktop.login1.halt-multiple-sessions",
2340                         "org.freedesktop.login1.halt-ignore-inhibit",
2341                         NULL,
2342                         error);
2343 }
2344
2345 static int method_can_suspend(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2346         Manager *m = userdata;
2347
2348         return method_can_shutdown_or_sleep(
2349                         m, message,
2350                         INHIBIT_SLEEP,
2351                         "org.freedesktop.login1.suspend",
2352                         "org.freedesktop.login1.suspend-multiple-sessions",
2353                         "org.freedesktop.login1.suspend-ignore-inhibit",
2354                         "suspend",
2355                         error);
2356 }
2357
2358 static int method_can_hibernate(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2359         Manager *m = userdata;
2360
2361         return method_can_shutdown_or_sleep(
2362                         m, message,
2363                         INHIBIT_SLEEP,
2364                         "org.freedesktop.login1.hibernate",
2365                         "org.freedesktop.login1.hibernate-multiple-sessions",
2366                         "org.freedesktop.login1.hibernate-ignore-inhibit",
2367                         "hibernate",
2368                         error);
2369 }
2370
2371 static int method_can_hybrid_sleep(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2372         Manager *m = userdata;
2373
2374         return method_can_shutdown_or_sleep(
2375                         m, message,
2376                         INHIBIT_SLEEP,
2377                         "org.freedesktop.login1.hibernate",
2378                         "org.freedesktop.login1.hibernate-multiple-sessions",
2379                         "org.freedesktop.login1.hibernate-ignore-inhibit",
2380                         "hybrid-sleep",
2381                         error);
2382 }
2383
2384 static int property_get_reboot_to_firmware_setup(
2385                 sd_bus *bus,
2386                 const char *path,
2387                 const char *interface,
2388                 const char *property,
2389                 sd_bus_message *reply,
2390                 void *userdata,
2391                 sd_bus_error *error) {
2392         int r;
2393
2394         assert(bus);
2395         assert(reply);
2396         assert(userdata);
2397
2398         r = efi_get_reboot_to_firmware();
2399         if (r < 0 && r != -EOPNOTSUPP)
2400                 log_warning_errno(r, "Failed to determine reboot-to-firmware state: %m");
2401
2402         return sd_bus_message_append(reply, "b", r > 0);
2403 }
2404
2405 static int method_set_reboot_to_firmware_setup(
2406                 sd_bus_message *message,
2407                 void *userdata,
2408                 sd_bus_error *error) {
2409
2410         int b, r;
2411         Manager *m = userdata;
2412
2413         assert(message);
2414         assert(m);
2415
2416         r = sd_bus_message_read(message, "b", &b);
2417         if (r < 0)
2418                 return r;
2419
2420         r = bus_verify_polkit_async(message,
2421                                     CAP_SYS_ADMIN,
2422                                     "org.freedesktop.login1.set-reboot-to-firmware-setup",
2423                                     NULL,
2424                                     false,
2425                                     UID_INVALID,
2426                                     &m->polkit_registry,
2427                                     error);
2428         if (r < 0)
2429                 return r;
2430         if (r == 0)
2431                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2432
2433         r = efi_set_reboot_to_firmware(b);
2434         if (r < 0)
2435                 return r;
2436
2437         return sd_bus_reply_method_return(message, NULL);
2438 }
2439
2440 static int method_can_reboot_to_firmware_setup(
2441                 sd_bus_message *message,
2442                 void *userdata,
2443                 sd_bus_error *error) {
2444
2445         int r;
2446         bool challenge;
2447         const char *result;
2448         Manager *m = userdata;
2449
2450         assert(message);
2451         assert(m);
2452
2453         r = efi_reboot_to_firmware_supported();
2454         if (r < 0) {
2455                 if (r != -EOPNOTSUPP)
2456                         log_warning_errno(errno, "Failed to determine whether reboot to firmware is supported: %m");
2457
2458                 return sd_bus_reply_method_return(message, "s", "na");
2459         }
2460
2461         r = bus_test_polkit(message,
2462                             CAP_SYS_ADMIN,
2463                             "org.freedesktop.login1.set-reboot-to-firmware-setup",
2464                             NULL,
2465                             UID_INVALID,
2466                             &challenge,
2467                             error);
2468         if (r < 0)
2469                 return r;
2470
2471         if (r > 0)
2472                 result = "yes";
2473         else if (challenge)
2474                 result = "challenge";
2475         else
2476                 result = "no";
2477
2478         return sd_bus_reply_method_return(message, "s", result);
2479 }
2480
2481 static int method_set_wall_message(
2482                 sd_bus_message *message,
2483                 void *userdata,
2484                 sd_bus_error *error) {
2485
2486         int r;
2487         Manager *m = userdata;
2488         char *wall_message;
2489         int enable_wall_messages;
2490
2491         assert(message);
2492         assert(m);
2493
2494         r = sd_bus_message_read(message, "sb", &wall_message, &enable_wall_messages);
2495         if (r < 0)
2496                 return r;
2497
2498         r = bus_verify_polkit_async(message,
2499                                     CAP_SYS_ADMIN,
2500                                     "org.freedesktop.login1.set-wall-message",
2501                                     NULL,
2502                                     false,
2503                                     UID_INVALID,
2504                                     &m->polkit_registry,
2505                                     error);
2506         if (r < 0)
2507                 return r;
2508         if (r == 0)
2509                 return 1; /* Will call us back */
2510
2511         r = free_and_strdup(&m->wall_message, empty_to_null(wall_message));
2512         if (r < 0)
2513                 return log_oom();
2514
2515         m->enable_wall_messages = enable_wall_messages;
2516
2517         return sd_bus_reply_method_return(message, NULL);
2518 }
2519
2520 static int method_inhibit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2521         _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
2522         const char *who, *why, *what, *mode;
2523         _cleanup_free_ char *id = NULL;
2524         _cleanup_close_ int fifo_fd = -1;
2525         Manager *m = userdata;
2526         Inhibitor *i = NULL;
2527         InhibitMode mm;
2528         InhibitWhat w;
2529         pid_t pid;
2530         uid_t uid;
2531         int r;
2532
2533         assert(message);
2534         assert(m);
2535
2536         r = sd_bus_message_read(message, "ssss", &what, &who, &why, &mode);
2537         if (r < 0)
2538                 return r;
2539
2540         w = inhibit_what_from_string(what);
2541         if (w <= 0)
2542                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid what specification %s", what);
2543
2544         mm = inhibit_mode_from_string(mode);
2545         if (mm < 0)
2546                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid mode specification %s", mode);
2547
2548         /* Delay is only supported for shutdown/sleep */
2549         if (mm == INHIBIT_DELAY && (w & ~(INHIBIT_SHUTDOWN|INHIBIT_SLEEP)))
2550                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Delay inhibitors only supported for shutdown and sleep");
2551
2552         /* Don't allow taking delay locks while we are already
2553          * executing the operation. We shouldn't create the impression
2554          * that the lock was successful if the machine is about to go
2555          * down/suspend any moment. */
2556         if (m->action_what & w)
2557                 return sd_bus_error_setf(error, BUS_ERROR_OPERATION_IN_PROGRESS, "The operation inhibition has been requested for is already running");
2558
2559         r = bus_verify_polkit_async(
2560                         message,
2561                         CAP_SYS_BOOT,
2562                         w == INHIBIT_SHUTDOWN             ? (mm == INHIBIT_BLOCK ? "org.freedesktop.login1.inhibit-block-shutdown" : "org.freedesktop.login1.inhibit-delay-shutdown") :
2563                         w == INHIBIT_SLEEP                ? (mm == INHIBIT_BLOCK ? "org.freedesktop.login1.inhibit-block-sleep"    : "org.freedesktop.login1.inhibit-delay-sleep") :
2564                         w == INHIBIT_IDLE                 ? "org.freedesktop.login1.inhibit-block-idle" :
2565                         w == INHIBIT_HANDLE_POWER_KEY     ? "org.freedesktop.login1.inhibit-handle-power-key" :
2566                         w == INHIBIT_HANDLE_SUSPEND_KEY   ? "org.freedesktop.login1.inhibit-handle-suspend-key" :
2567                         w == INHIBIT_HANDLE_HIBERNATE_KEY ? "org.freedesktop.login1.inhibit-handle-hibernate-key" :
2568                                                             "org.freedesktop.login1.inhibit-handle-lid-switch",
2569                         NULL,
2570                         false,
2571                         UID_INVALID,
2572                         &m->polkit_registry,
2573                         error);
2574         if (r < 0)
2575                 return r;
2576         if (r == 0)
2577                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2578
2579         r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_EUID|SD_BUS_CREDS_PID, &creds);
2580         if (r < 0)
2581                 return r;
2582
2583         r = sd_bus_creds_get_euid(creds, &uid);
2584         if (r < 0)
2585                 return r;
2586
2587         r = sd_bus_creds_get_pid(creds, &pid);
2588         if (r < 0)
2589                 return r;
2590
2591         if (hashmap_size(m->inhibitors) >= m->inhibitors_max)
2592                 return sd_bus_error_setf(error, SD_BUS_ERROR_LIMITS_EXCEEDED, "Maximum number of inhibitors (%" PRIu64 ") reached, refusing further inhibitors.", m->inhibitors_max);
2593
2594         do {
2595                 id = mfree(id);
2596
2597                 if (asprintf(&id, "%lu", ++m->inhibit_counter) < 0)
2598                         return -ENOMEM;
2599
2600         } while (hashmap_get(m->inhibitors, id));
2601
2602         r = manager_add_inhibitor(m, id, &i);
2603         if (r < 0)
2604                 return r;
2605
2606         i->what = w;
2607         i->mode = mm;
2608         i->pid = pid;
2609         i->uid = uid;
2610         i->why = strdup(why);
2611         i->who = strdup(who);
2612
2613         if (!i->why || !i->who) {
2614                 r = -ENOMEM;
2615                 goto fail;
2616         }
2617
2618         fifo_fd = inhibitor_create_fifo(i);
2619         if (fifo_fd < 0) {
2620                 r = fifo_fd;
2621                 goto fail;
2622         }
2623
2624         inhibitor_start(i);
2625
2626         return sd_bus_reply_method_return(message, "h", fifo_fd);
2627
2628 fail:
2629         if (i)
2630                 inhibitor_free(i);
2631
2632         return r;
2633 }
2634
2635 const sd_bus_vtable manager_vtable[] = {
2636         SD_BUS_VTABLE_START(0),
2637
2638         SD_BUS_WRITABLE_PROPERTY("EnableWallMessages", "b", NULL, NULL, offsetof(Manager, enable_wall_messages), 0),
2639         SD_BUS_WRITABLE_PROPERTY("WallMessage", "s", NULL, NULL, offsetof(Manager, wall_message), 0),
2640
2641         SD_BUS_PROPERTY("NAutoVTs", "u", NULL, offsetof(Manager, n_autovts), SD_BUS_VTABLE_PROPERTY_CONST),
2642         SD_BUS_PROPERTY("KillOnlyUsers", "as", NULL, offsetof(Manager, kill_only_users), SD_BUS_VTABLE_PROPERTY_CONST),
2643         SD_BUS_PROPERTY("KillExcludeUsers", "as", NULL, offsetof(Manager, kill_exclude_users), SD_BUS_VTABLE_PROPERTY_CONST),
2644         SD_BUS_PROPERTY("KillUserProcesses", "b", NULL, offsetof(Manager, kill_user_processes), SD_BUS_VTABLE_PROPERTY_CONST),
2645         SD_BUS_PROPERTY("RebootToFirmwareSetup", "b", property_get_reboot_to_firmware_setup, 0, SD_BUS_VTABLE_PROPERTY_CONST),
2646         SD_BUS_PROPERTY("IdleHint", "b", property_get_idle_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
2647         SD_BUS_PROPERTY("IdleSinceHint", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
2648         SD_BUS_PROPERTY("IdleSinceHintMonotonic", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
2649         SD_BUS_PROPERTY("BlockInhibited", "s", property_get_inhibited, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
2650         SD_BUS_PROPERTY("DelayInhibited", "s", property_get_inhibited, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
2651         SD_BUS_PROPERTY("InhibitDelayMaxUSec", "t", NULL, offsetof(Manager, inhibit_delay_max), SD_BUS_VTABLE_PROPERTY_CONST),
2652         SD_BUS_PROPERTY("HandlePowerKey", "s", property_get_handle_action, offsetof(Manager, handle_power_key), SD_BUS_VTABLE_PROPERTY_CONST),
2653         SD_BUS_PROPERTY("HandleSuspendKey", "s", property_get_handle_action, offsetof(Manager, handle_suspend_key), SD_BUS_VTABLE_PROPERTY_CONST),
2654         SD_BUS_PROPERTY("HandleHibernateKey", "s", property_get_handle_action, offsetof(Manager, handle_hibernate_key), SD_BUS_VTABLE_PROPERTY_CONST),
2655         SD_BUS_PROPERTY("HandleLidSwitch", "s", property_get_handle_action, offsetof(Manager, handle_lid_switch), SD_BUS_VTABLE_PROPERTY_CONST),
2656         SD_BUS_PROPERTY("HandleLidSwitchDocked", "s", property_get_handle_action, offsetof(Manager, handle_lid_switch_docked), SD_BUS_VTABLE_PROPERTY_CONST),
2657         SD_BUS_PROPERTY("HoldoffTimeoutUSec", "t", NULL, offsetof(Manager, holdoff_timeout_usec), SD_BUS_VTABLE_PROPERTY_CONST),
2658         SD_BUS_PROPERTY("IdleAction", "s", property_get_handle_action, offsetof(Manager, idle_action), SD_BUS_VTABLE_PROPERTY_CONST),
2659         SD_BUS_PROPERTY("IdleActionUSec", "t", NULL, offsetof(Manager, idle_action_usec), SD_BUS_VTABLE_PROPERTY_CONST),
2660         SD_BUS_PROPERTY("PreparingForShutdown", "b", property_get_preparing, 0, 0),
2661         SD_BUS_PROPERTY("PreparingForSleep", "b", property_get_preparing, 0, 0),
2662         SD_BUS_PROPERTY("ScheduledShutdown", "(st)", property_get_scheduled_shutdown, 0, 0),
2663         SD_BUS_PROPERTY("Docked", "b", property_get_docked, 0, 0),
2664         SD_BUS_PROPERTY("RemoveIPC", "b", bus_property_get_bool, offsetof(Manager, remove_ipc), SD_BUS_VTABLE_PROPERTY_CONST),
2665         SD_BUS_PROPERTY("RuntimeDirectorySize", "t", bus_property_get_size, offsetof(Manager, runtime_dir_size), SD_BUS_VTABLE_PROPERTY_CONST),
2666         SD_BUS_PROPERTY("InhibitorsMax", "t", NULL, offsetof(Manager, inhibitors_max), SD_BUS_VTABLE_PROPERTY_CONST),
2667         SD_BUS_PROPERTY("NCurrentInhibitors", "t", property_get_current_inhibitors, 0, 0),
2668         SD_BUS_PROPERTY("SessionsMax", "t", NULL, offsetof(Manager, sessions_max), SD_BUS_VTABLE_PROPERTY_CONST),
2669         SD_BUS_PROPERTY("NCurrentSessions", "t", property_get_current_sessions, 0, 0),
2670         SD_BUS_PROPERTY("UserTasksMax", "t", NULL, offsetof(Manager, user_tasks_max), SD_BUS_VTABLE_PROPERTY_CONST),
2671
2672         SD_BUS_METHOD("GetSession", "s", "o", method_get_session, SD_BUS_VTABLE_UNPRIVILEGED),
2673         SD_BUS_METHOD("GetSessionByPID", "u", "o", method_get_session_by_pid, SD_BUS_VTABLE_UNPRIVILEGED),
2674         SD_BUS_METHOD("GetUser", "u", "o", method_get_user, SD_BUS_VTABLE_UNPRIVILEGED),
2675         SD_BUS_METHOD("GetUserByPID", "u", "o", method_get_user_by_pid, SD_BUS_VTABLE_UNPRIVILEGED),
2676         SD_BUS_METHOD("GetSeat", "s", "o", method_get_seat, SD_BUS_VTABLE_UNPRIVILEGED),
2677         SD_BUS_METHOD("ListSessions", NULL, "a(susso)", method_list_sessions, SD_BUS_VTABLE_UNPRIVILEGED),
2678         SD_BUS_METHOD("ListUsers", NULL, "a(uso)", method_list_users, SD_BUS_VTABLE_UNPRIVILEGED),
2679         SD_BUS_METHOD("ListSeats", NULL, "a(so)", method_list_seats, SD_BUS_VTABLE_UNPRIVILEGED),
2680         SD_BUS_METHOD("ListInhibitors", NULL, "a(ssssuu)", method_list_inhibitors, SD_BUS_VTABLE_UNPRIVILEGED),
2681         SD_BUS_METHOD("CreateSession", "uusssssussbssa(sv)", "soshusub", method_create_session, 0),
2682         SD_BUS_METHOD("ReleaseSession", "s", NULL, method_release_session, 0),
2683         SD_BUS_METHOD("ActivateSession", "s", NULL, method_activate_session, SD_BUS_VTABLE_UNPRIVILEGED),
2684         SD_BUS_METHOD("ActivateSessionOnSeat", "ss", NULL, method_activate_session_on_seat, SD_BUS_VTABLE_UNPRIVILEGED),
2685         SD_BUS_METHOD("LockSession", "s", NULL, method_lock_session, SD_BUS_VTABLE_UNPRIVILEGED),
2686         SD_BUS_METHOD("UnlockSession", "s", NULL, method_lock_session, SD_BUS_VTABLE_UNPRIVILEGED),
2687         SD_BUS_METHOD("LockSessions", NULL, NULL, method_lock_sessions, SD_BUS_VTABLE_UNPRIVILEGED),
2688         SD_BUS_METHOD("UnlockSessions", NULL, NULL, method_lock_sessions, SD_BUS_VTABLE_UNPRIVILEGED),
2689         SD_BUS_METHOD("KillSession", "ssi", NULL, method_kill_session, SD_BUS_VTABLE_UNPRIVILEGED),
2690         SD_BUS_METHOD("KillUser", "ui", NULL, method_kill_user, SD_BUS_VTABLE_UNPRIVILEGED),
2691         SD_BUS_METHOD("TerminateSession", "s", NULL, method_terminate_session, SD_BUS_VTABLE_UNPRIVILEGED),
2692         SD_BUS_METHOD("TerminateUser", "u", NULL, method_terminate_user, SD_BUS_VTABLE_UNPRIVILEGED),
2693         SD_BUS_METHOD("TerminateSeat", "s", NULL, method_terminate_seat, SD_BUS_VTABLE_UNPRIVILEGED),
2694         SD_BUS_METHOD("SetUserLinger", "ubb", NULL, method_set_user_linger, SD_BUS_VTABLE_UNPRIVILEGED),
2695         SD_BUS_METHOD("AttachDevice", "ssb", NULL, method_attach_device, SD_BUS_VTABLE_UNPRIVILEGED),
2696         SD_BUS_METHOD("FlushDevices", "b", NULL, method_flush_devices, SD_BUS_VTABLE_UNPRIVILEGED),
2697         SD_BUS_METHOD("PowerOff", "b", NULL, method_poweroff, SD_BUS_VTABLE_UNPRIVILEGED),
2698         SD_BUS_METHOD("Reboot", "b", NULL, method_reboot, SD_BUS_VTABLE_UNPRIVILEGED),
2699         SD_BUS_METHOD("Halt", "b", NULL, method_halt, SD_BUS_VTABLE_UNPRIVILEGED),
2700         SD_BUS_METHOD("Suspend", "b", NULL, method_suspend, SD_BUS_VTABLE_UNPRIVILEGED),
2701         SD_BUS_METHOD("Hibernate", "b", NULL, method_hibernate, SD_BUS_VTABLE_UNPRIVILEGED),
2702         SD_BUS_METHOD("HybridSleep", "b", NULL, method_hybrid_sleep, SD_BUS_VTABLE_UNPRIVILEGED),
2703         SD_BUS_METHOD("CanPowerOff", NULL, "s", method_can_poweroff, SD_BUS_VTABLE_UNPRIVILEGED),
2704         SD_BUS_METHOD("CanReboot", NULL, "s", method_can_reboot, SD_BUS_VTABLE_UNPRIVILEGED),
2705         SD_BUS_METHOD("CanHalt", NULL, "s", method_can_halt, SD_BUS_VTABLE_UNPRIVILEGED),
2706         SD_BUS_METHOD("CanSuspend", NULL, "s", method_can_suspend, SD_BUS_VTABLE_UNPRIVILEGED),
2707         SD_BUS_METHOD("CanHibernate", NULL, "s", method_can_hibernate, SD_BUS_VTABLE_UNPRIVILEGED),
2708         SD_BUS_METHOD("CanHybridSleep", NULL, "s", method_can_hybrid_sleep, SD_BUS_VTABLE_UNPRIVILEGED),
2709         SD_BUS_METHOD("ScheduleShutdown", "st", NULL, method_schedule_shutdown, SD_BUS_VTABLE_UNPRIVILEGED),
2710         SD_BUS_METHOD("CancelScheduledShutdown", NULL, "b", method_cancel_scheduled_shutdown, SD_BUS_VTABLE_UNPRIVILEGED),
2711         SD_BUS_METHOD("Inhibit", "ssss", "h", method_inhibit, SD_BUS_VTABLE_UNPRIVILEGED),
2712         SD_BUS_METHOD("CanRebootToFirmwareSetup", NULL, "s", method_can_reboot_to_firmware_setup, SD_BUS_VTABLE_UNPRIVILEGED),
2713         SD_BUS_METHOD("SetRebootToFirmwareSetup", "b", NULL, method_set_reboot_to_firmware_setup, SD_BUS_VTABLE_UNPRIVILEGED),
2714         SD_BUS_METHOD("SetWallMessage", "sb", NULL, method_set_wall_message, SD_BUS_VTABLE_UNPRIVILEGED),
2715
2716         SD_BUS_SIGNAL("SessionNew", "so", 0),
2717         SD_BUS_SIGNAL("SessionRemoved", "so", 0),
2718         SD_BUS_SIGNAL("UserNew", "uo", 0),
2719         SD_BUS_SIGNAL("UserRemoved", "uo", 0),
2720         SD_BUS_SIGNAL("SeatNew", "so", 0),
2721         SD_BUS_SIGNAL("SeatRemoved", "so", 0),
2722         SD_BUS_SIGNAL("PrepareForShutdown", "b", 0),
2723         SD_BUS_SIGNAL("PrepareForSleep", "b", 0),
2724
2725         SD_BUS_VTABLE_END
2726 };
2727
2728 static int session_jobs_reply(Session *s, const char *unit, const char *result) {
2729         int r = 0;
2730
2731         assert(s);
2732         assert(unit);
2733
2734         if (!s->started)
2735                 return r;
2736
2737         if (streq(result, "done"))
2738                 r = session_send_create_reply(s, NULL);
2739         else {
2740                 _cleanup_(sd_bus_error_free) sd_bus_error e = SD_BUS_ERROR_NULL;
2741
2742                 sd_bus_error_setf(&e, BUS_ERROR_JOB_FAILED, "Start job for unit %s failed with '%s'", unit, result);
2743                 r = session_send_create_reply(s, &e);
2744         }
2745
2746         return r;
2747 }
2748
2749 int match_job_removed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2750         const char *path, *result, *unit;
2751         Manager *m = userdata;
2752         Session *session;
2753         uint32_t id;
2754         User *user;
2755         int r;
2756
2757         assert(message);
2758         assert(m);
2759
2760         r = sd_bus_message_read(message, "uoss", &id, &path, &unit, &result);
2761         if (r < 0) {
2762                 bus_log_parse_error(r);
2763                 return 0;
2764         }
2765
2766         if (m->action_job && streq(m->action_job, path)) {
2767                 log_info("Operation '%s' finished.", inhibit_what_to_string(m->action_what));
2768
2769                 /* Tell people that they now may take a lock again */
2770                 (void) send_prepare_for(m, m->action_what, false);
2771
2772                 m->action_job = mfree(m->action_job);
2773                 m->action_unit = NULL;
2774                 m->action_what = 0;
2775                 return 0;
2776         }
2777
2778         session = hashmap_get(m->session_units, unit);
2779         if (session && streq_ptr(path, session->scope_job)) {
2780                 session->scope_job = mfree(session->scope_job);
2781                 session_jobs_reply(session, unit, result);
2782
2783                 session_save(session);
2784                 user_save(session->user);
2785                 session_add_to_gc_queue(session);
2786         }
2787
2788         user = hashmap_get(m->user_units, unit);
2789         if (user &&
2790             (streq_ptr(path, user->service_job) ||
2791              streq_ptr(path, user->slice_job))) {
2792
2793                 if (streq_ptr(path, user->service_job))
2794                         user->service_job = mfree(user->service_job);
2795
2796                 if (streq_ptr(path, user->slice_job))
2797                         user->slice_job = mfree(user->slice_job);
2798
2799                 LIST_FOREACH(sessions_by_user, session, user->sessions)
2800                         session_jobs_reply(session, unit, result);
2801
2802                 user_save(user);
2803                 user_add_to_gc_queue(user);
2804         }
2805
2806         return 0;
2807 }
2808
2809 int match_unit_removed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2810         const char *path, *unit;
2811         Manager *m = userdata;
2812         Session *session;
2813         User *user;
2814         int r;
2815
2816         assert(message);
2817         assert(m);
2818
2819         r = sd_bus_message_read(message, "so", &unit, &path);
2820         if (r < 0) {
2821                 bus_log_parse_error(r);
2822                 return 0;
2823         }
2824
2825         session = hashmap_get(m->session_units, unit);
2826         if (session)
2827                 session_add_to_gc_queue(session);
2828
2829         user = hashmap_get(m->user_units, unit);
2830         if (user)
2831                 user_add_to_gc_queue(user);
2832
2833         return 0;
2834 }
2835
2836 int match_properties_changed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2837         _cleanup_free_ char *unit = NULL;
2838         Manager *m = userdata;
2839         const char *path;
2840         Session *session;
2841         User *user;
2842         int r;
2843
2844         assert(message);
2845         assert(m);
2846
2847         path = sd_bus_message_get_path(message);
2848         if (!path)
2849                 return 0;
2850
2851         r = unit_name_from_dbus_path(path, &unit);
2852         if (r == -EINVAL) /* not a unit */
2853                 return 0;
2854         if (r < 0) {
2855                 log_oom();
2856                 return 0;
2857         }
2858
2859         session = hashmap_get(m->session_units, unit);
2860         if (session)
2861                 session_add_to_gc_queue(session);
2862
2863         user = hashmap_get(m->user_units, unit);
2864         if (user)
2865                 user_add_to_gc_queue(user);
2866
2867         return 0;
2868 }
2869
2870 int match_reloading(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2871         Manager *m = userdata;
2872         Session *session;
2873         Iterator i;
2874         int b, r;
2875
2876         assert(message);
2877         assert(m);
2878
2879         r = sd_bus_message_read(message, "b", &b);
2880         if (r < 0) {
2881                 bus_log_parse_error(r);
2882                 return 0;
2883         }
2884
2885         if (b)
2886                 return 0;
2887
2888         /* systemd finished reloading, let's recheck all our sessions */
2889         log_debug("System manager has been reloaded, rechecking sessions...");
2890
2891         HASHMAP_FOREACH(session, m->sessions, i)
2892                 session_add_to_gc_queue(session);
2893
2894         return 0;
2895 }
2896
2897 int manager_send_changed(Manager *manager, const char *property, ...) {
2898         char **l;
2899
2900         assert(manager);
2901
2902         l = strv_from_stdarg_alloca(property);
2903
2904         return sd_bus_emit_properties_changed_strv(
2905                         manager->bus,
2906                         "/org/freedesktop/login1",
2907                         "org.freedesktop.login1.Manager",
2908                         l);
2909 }
2910
2911 static int strdup_job(sd_bus_message *reply, char **job) {
2912         const char *j;
2913         char *copy;
2914         int r;
2915
2916         r = sd_bus_message_read(reply, "o", &j);
2917         if (r < 0)
2918                 return r;
2919
2920         copy = strdup(j);
2921         if (!copy)
2922                 return -ENOMEM;
2923
2924         *job = copy;
2925         return 1;
2926 }
2927
2928 int manager_start_slice(
2929                 Manager *manager,
2930                 const char *slice,
2931                 const char *description,
2932                 const char *after,
2933                 const char *after2,
2934                 uint64_t tasks_max,
2935                 sd_bus_error *error,
2936                 char **job) {
2937
2938         _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL, *reply = NULL;
2939         int r;
2940
2941         assert(manager);
2942         assert(slice);
2943         assert(job);
2944
2945         r = sd_bus_message_new_method_call(
2946                         manager->bus,
2947                         &m,
2948                         "org.freedesktop.systemd1",
2949                         "/org/freedesktop/systemd1",
2950                         "org.freedesktop.systemd1.Manager",
2951                         "StartTransientUnit");
2952         if (r < 0)
2953                 return r;
2954
2955         r = sd_bus_message_append(m, "ss", strempty(slice), "fail");
2956         if (r < 0)
2957                 return r;
2958
2959         r = sd_bus_message_open_container(m, 'a', "(sv)");
2960         if (r < 0)
2961                 return r;
2962
2963         if (!isempty(description)) {
2964                 r = sd_bus_message_append(m, "(sv)", "Description", "s", description);
2965                 if (r < 0)
2966                         return r;
2967         }
2968
2969         if (!isempty(after)) {
2970                 r = sd_bus_message_append(m, "(sv)", "After", "as", 1, after);
2971                 if (r < 0)
2972                         return r;
2973         }
2974
2975         if (!isempty(after2)) {
2976                 r = sd_bus_message_append(m, "(sv)", "After", "as", 1, after2);
2977                 if (r < 0)
2978                         return r;
2979         }
2980
2981         r = sd_bus_message_append(m, "(sv)", "TasksMax", "t", tasks_max);
2982         if (r < 0)
2983                 return r;
2984
2985         r = sd_bus_message_close_container(m);
2986         if (r < 0)
2987                 return r;
2988
2989         r = sd_bus_message_append(m, "a(sa(sv))", 0);
2990         if (r < 0)
2991                 return r;
2992
2993         r = sd_bus_call(manager->bus, m, 0, error, &reply);
2994         if (r < 0)
2995                 return r;
2996
2997         return strdup_job(reply, job);
2998 }
2999
3000 int manager_start_scope(
3001                 Manager *manager,
3002                 const char *scope,
3003                 pid_t pid,
3004                 const char *slice,
3005                 const char *description,
3006                 const char *after,
3007                 const char *after2,
3008                 uint64_t tasks_max,
3009                 sd_bus_error *error,
3010                 char **job) {
3011
3012         _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL, *reply = NULL;
3013         int r;
3014
3015         assert(manager);
3016         assert(scope);
3017         assert(pid > 1);
3018         assert(job);
3019
3020         r = sd_bus_message_new_method_call(
3021                         manager->bus,
3022                         &m,
3023                         "org.freedesktop.systemd1",
3024                         "/org/freedesktop/systemd1",
3025                         "org.freedesktop.systemd1.Manager",
3026                         "StartTransientUnit");
3027         if (r < 0)
3028                 return r;
3029
3030         r = sd_bus_message_append(m, "ss", strempty(scope), "fail");
3031         if (r < 0)
3032                 return r;
3033
3034         r = sd_bus_message_open_container(m, 'a', "(sv)");
3035         if (r < 0)
3036                 return r;
3037
3038         if (!isempty(slice)) {
3039                 r = sd_bus_message_append(m, "(sv)", "Slice", "s", slice);
3040                 if (r < 0)
3041                         return r;
3042         }
3043
3044         if (!isempty(description)) {
3045                 r = sd_bus_message_append(m, "(sv)", "Description", "s", description);
3046                 if (r < 0)
3047                         return r;
3048         }
3049
3050         if (!isempty(after)) {
3051                 r = sd_bus_message_append(m, "(sv)", "After", "as", 1, after);
3052                 if (r < 0)
3053                         return r;
3054         }
3055
3056         if (!isempty(after2)) {
3057                 r = sd_bus_message_append(m, "(sv)", "After", "as", 1, after2);
3058                 if (r < 0)
3059                         return r;
3060         }
3061
3062         /* cgroup empty notification is not available in containers
3063          * currently. To make this less problematic, let's shorten the
3064          * stop timeout for sessions, so that we don't wait
3065          * forever. */
3066
3067         /* Make sure that the session shells are terminated with
3068          * SIGHUP since bash and friends tend to ignore SIGTERM */
3069         r = sd_bus_message_append(m, "(sv)", "SendSIGHUP", "b", true);
3070         if (r < 0)
3071                 return r;
3072
3073         r = sd_bus_message_append(m, "(sv)", "PIDs", "au", 1, pid);
3074         if (r < 0)
3075                 return r;
3076
3077         r = sd_bus_message_append(m, "(sv)", "TasksMax", "t", tasks_max);
3078         if (r < 0)
3079                 return r;
3080
3081         r = sd_bus_message_close_container(m);
3082         if (r < 0)
3083                 return r;
3084
3085         r = sd_bus_message_append(m, "a(sa(sv))", 0);
3086         if (r < 0)
3087                 return r;
3088
3089         r = sd_bus_call(manager->bus, m, 0, error, &reply);
3090         if (r < 0)
3091                 return r;
3092
3093         return strdup_job(reply, job);
3094 }
3095
3096 int manager_start_unit(Manager *manager, const char *unit, sd_bus_error *error, char **job) {
3097         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
3098         int r;
3099
3100         assert(manager);
3101         assert(unit);
3102         assert(job);
3103
3104         r = sd_bus_call_method(
3105                         manager->bus,
3106                         "org.freedesktop.systemd1",
3107                         "/org/freedesktop/systemd1",
3108                         "org.freedesktop.systemd1.Manager",
3109                         "StartUnit",
3110                         error,
3111                         &reply,
3112                         "ss", unit, "replace");
3113         if (r < 0)
3114                 return r;
3115
3116         return strdup_job(reply, job);
3117 }
3118
3119 int manager_stop_unit(Manager *manager, const char *unit, sd_bus_error *error, char **job) {
3120         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
3121         int r;
3122
3123         assert(manager);
3124         assert(unit);
3125         assert(job);
3126
3127         r = sd_bus_call_method(
3128                         manager->bus,
3129                         "org.freedesktop.systemd1",
3130                         "/org/freedesktop/systemd1",
3131                         "org.freedesktop.systemd1.Manager",
3132                         "StopUnit",
3133                         error,
3134                         &reply,
3135                         "ss", unit, "fail");
3136         if (r < 0) {
3137                 if (sd_bus_error_has_name(error, BUS_ERROR_NO_SUCH_UNIT) ||
3138                     sd_bus_error_has_name(error, BUS_ERROR_LOAD_FAILED)) {
3139
3140                         *job = NULL;
3141                         sd_bus_error_free(error);
3142                         return 0;
3143                 }
3144
3145                 return r;
3146         }
3147
3148         return strdup_job(reply, job);
3149 }
3150
3151 int manager_abandon_scope(Manager *manager, const char *scope, sd_bus_error *error) {
3152         _cleanup_free_ char *path = NULL;
3153         int r;
3154
3155         assert(manager);
3156         assert(scope);
3157
3158         path = unit_dbus_path_from_name(scope);
3159         if (!path)
3160                 return -ENOMEM;
3161
3162         r = sd_bus_call_method(
3163                         manager->bus,
3164                         "org.freedesktop.systemd1",
3165                         path,
3166                         "org.freedesktop.systemd1.Scope",
3167                         "Abandon",
3168                         error,
3169                         NULL,
3170                         NULL);
3171         if (r < 0) {
3172                 if (sd_bus_error_has_name(error, BUS_ERROR_NO_SUCH_UNIT) ||
3173                     sd_bus_error_has_name(error, BUS_ERROR_LOAD_FAILED) ||
3174                     sd_bus_error_has_name(error, BUS_ERROR_SCOPE_NOT_RUNNING)) {
3175                         sd_bus_error_free(error);
3176                         return 0;
3177                 }
3178
3179                 return r;
3180         }
3181
3182         return 1;
3183 }
3184
3185 int manager_kill_unit(Manager *manager, const char *unit, KillWho who, int signo, sd_bus_error *error) {
3186         assert(manager);
3187         assert(unit);
3188
3189         return sd_bus_call_method(
3190                         manager->bus,
3191                         "org.freedesktop.systemd1",
3192                         "/org/freedesktop/systemd1",
3193                         "org.freedesktop.systemd1.Manager",
3194                         "KillUnit",
3195                         error,
3196                         NULL,
3197                         "ssi", unit, who == KILL_LEADER ? "main" : "all", signo);
3198 }
3199
3200 int manager_unit_is_active(Manager *manager, const char *unit) {
3201         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
3202         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
3203         _cleanup_free_ char *path = NULL;
3204         const char *state;
3205         int r;
3206
3207         assert(manager);
3208         assert(unit);
3209
3210         path = unit_dbus_path_from_name(unit);
3211         if (!path)
3212                 return -ENOMEM;
3213
3214         r = sd_bus_get_property(
3215                         manager->bus,
3216                         "org.freedesktop.systemd1",
3217                         path,
3218                         "org.freedesktop.systemd1.Unit",
3219                         "ActiveState",
3220                         &error,
3221                         &reply,
3222                         "s");
3223         if (r < 0) {
3224                 /* systemd might have droppped off momentarily, let's
3225                  * not make this an error */
3226                 if (sd_bus_error_has_name(&error, SD_BUS_ERROR_NO_REPLY) ||
3227                     sd_bus_error_has_name(&error, SD_BUS_ERROR_DISCONNECTED))
3228                         return true;
3229
3230                 /* If the unit is already unloaded then it's not
3231                  * active */
3232                 if (sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_UNIT) ||
3233                     sd_bus_error_has_name(&error, BUS_ERROR_LOAD_FAILED))
3234                         return false;
3235
3236                 return r;
3237         }
3238
3239         r = sd_bus_message_read(reply, "s", &state);
3240         if (r < 0)
3241                 return -EINVAL;
3242
3243         return !streq(state, "inactive") && !streq(state, "failed");
3244 }
3245
3246 int manager_job_is_active(Manager *manager, const char *path) {
3247         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
3248         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
3249         int r;
3250
3251         assert(manager);
3252         assert(path);
3253
3254         r = sd_bus_get_property(
3255                         manager->bus,
3256                         "org.freedesktop.systemd1",
3257                         path,
3258                         "org.freedesktop.systemd1.Job",
3259                         "State",
3260                         &error,
3261                         &reply,
3262                         "s");
3263         if (r < 0) {
3264                 if (sd_bus_error_has_name(&error, SD_BUS_ERROR_NO_REPLY) ||
3265                     sd_bus_error_has_name(&error, SD_BUS_ERROR_DISCONNECTED))
3266                         return true;
3267
3268                 if (sd_bus_error_has_name(&error, SD_BUS_ERROR_UNKNOWN_OBJECT))
3269                         return false;
3270
3271                 return r;
3272         }
3273
3274         /* We don't actually care about the state really. The fact
3275          * that we could read the job state is enough for us */
3276
3277         return true;
3278 }