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                 write_string_file(t, "change", WRITE_STRING_FILE_CREATE);
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         send_prepare_for(m, m->action_what, 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         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                 return r;
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 == -EOPNOTSUPP)
2455                 return sd_bus_reply_method_return(message, "s", "na");
2456         else if (r < 0)
2457                 return r;
2458
2459         r = bus_test_polkit(message,
2460                             CAP_SYS_ADMIN,
2461                             "org.freedesktop.login1.set-reboot-to-firmware-setup",
2462                             NULL,
2463                             UID_INVALID,
2464                             &challenge,
2465                             error);
2466         if (r < 0)
2467                 return r;
2468
2469         if (r > 0)
2470                 result = "yes";
2471         else if (challenge)
2472                 result = "challenge";
2473         else
2474                 result = "no";
2475
2476         return sd_bus_reply_method_return(message, "s", result);
2477 }
2478
2479 static int method_set_wall_message(
2480                 sd_bus_message *message,
2481                 void *userdata,
2482                 sd_bus_error *error) {
2483
2484         int r;
2485         Manager *m = userdata;
2486         char *wall_message;
2487         int enable_wall_messages;
2488
2489         assert(message);
2490         assert(m);
2491
2492         r = sd_bus_message_read(message, "sb", &wall_message, &enable_wall_messages);
2493         if (r < 0)
2494                 return r;
2495
2496         r = bus_verify_polkit_async(message,
2497                                     CAP_SYS_ADMIN,
2498                                     "org.freedesktop.login1.set-wall-message",
2499                                     NULL,
2500                                     false,
2501                                     UID_INVALID,
2502                                     &m->polkit_registry,
2503                                     error);
2504         if (r < 0)
2505                 return r;
2506         if (r == 0)
2507                 return 1; /* Will call us back */
2508
2509         r = free_and_strdup(&m->wall_message, empty_to_null(wall_message));
2510         if (r < 0)
2511                 return log_oom();
2512
2513         m->enable_wall_messages = enable_wall_messages;
2514
2515         return sd_bus_reply_method_return(message, NULL);
2516 }
2517
2518 static int method_inhibit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2519         _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
2520         const char *who, *why, *what, *mode;
2521         _cleanup_free_ char *id = NULL;
2522         _cleanup_close_ int fifo_fd = -1;
2523         Manager *m = userdata;
2524         Inhibitor *i = NULL;
2525         InhibitMode mm;
2526         InhibitWhat w;
2527         pid_t pid;
2528         uid_t uid;
2529         int r;
2530
2531         assert(message);
2532         assert(m);
2533
2534         r = sd_bus_message_read(message, "ssss", &what, &who, &why, &mode);
2535         if (r < 0)
2536                 return r;
2537
2538         w = inhibit_what_from_string(what);
2539         if (w <= 0)
2540                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid what specification %s", what);
2541
2542         mm = inhibit_mode_from_string(mode);
2543         if (mm < 0)
2544                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid mode specification %s", mode);
2545
2546         /* Delay is only supported for shutdown/sleep */
2547         if (mm == INHIBIT_DELAY && (w & ~(INHIBIT_SHUTDOWN|INHIBIT_SLEEP)))
2548                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Delay inhibitors only supported for shutdown and sleep");
2549
2550         /* Don't allow taking delay locks while we are already
2551          * executing the operation. We shouldn't create the impression
2552          * that the lock was successful if the machine is about to go
2553          * down/suspend any moment. */
2554         if (m->action_what & w)
2555                 return sd_bus_error_setf(error, BUS_ERROR_OPERATION_IN_PROGRESS, "The operation inhibition has been requested for is already running");
2556
2557         r = bus_verify_polkit_async(
2558                         message,
2559                         CAP_SYS_BOOT,
2560                         w == INHIBIT_SHUTDOWN             ? (mm == INHIBIT_BLOCK ? "org.freedesktop.login1.inhibit-block-shutdown" : "org.freedesktop.login1.inhibit-delay-shutdown") :
2561                         w == INHIBIT_SLEEP                ? (mm == INHIBIT_BLOCK ? "org.freedesktop.login1.inhibit-block-sleep"    : "org.freedesktop.login1.inhibit-delay-sleep") :
2562                         w == INHIBIT_IDLE                 ? "org.freedesktop.login1.inhibit-block-idle" :
2563                         w == INHIBIT_HANDLE_POWER_KEY     ? "org.freedesktop.login1.inhibit-handle-power-key" :
2564                         w == INHIBIT_HANDLE_SUSPEND_KEY   ? "org.freedesktop.login1.inhibit-handle-suspend-key" :
2565                         w == INHIBIT_HANDLE_HIBERNATE_KEY ? "org.freedesktop.login1.inhibit-handle-hibernate-key" :
2566                                                             "org.freedesktop.login1.inhibit-handle-lid-switch",
2567                         NULL,
2568                         false,
2569                         UID_INVALID,
2570                         &m->polkit_registry,
2571                         error);
2572         if (r < 0)
2573                 return r;
2574         if (r == 0)
2575                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2576
2577         r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_EUID|SD_BUS_CREDS_PID, &creds);
2578         if (r < 0)
2579                 return r;
2580
2581         r = sd_bus_creds_get_euid(creds, &uid);
2582         if (r < 0)
2583                 return r;
2584
2585         r = sd_bus_creds_get_pid(creds, &pid);
2586         if (r < 0)
2587                 return r;
2588
2589         if (hashmap_size(m->inhibitors) >= m->inhibitors_max)
2590                 return sd_bus_error_setf(error, SD_BUS_ERROR_LIMITS_EXCEEDED, "Maximum number of inhibitors (%" PRIu64 ") reached, refusing further inhibitors.", m->inhibitors_max);
2591
2592         do {
2593                 id = mfree(id);
2594
2595                 if (asprintf(&id, "%lu", ++m->inhibit_counter) < 0)
2596                         return -ENOMEM;
2597
2598         } while (hashmap_get(m->inhibitors, id));
2599
2600         r = manager_add_inhibitor(m, id, &i);
2601         if (r < 0)
2602                 return r;
2603
2604         i->what = w;
2605         i->mode = mm;
2606         i->pid = pid;
2607         i->uid = uid;
2608         i->why = strdup(why);
2609         i->who = strdup(who);
2610
2611         if (!i->why || !i->who) {
2612                 r = -ENOMEM;
2613                 goto fail;
2614         }
2615
2616         fifo_fd = inhibitor_create_fifo(i);
2617         if (fifo_fd < 0) {
2618                 r = fifo_fd;
2619                 goto fail;
2620         }
2621
2622         inhibitor_start(i);
2623
2624         return sd_bus_reply_method_return(message, "h", fifo_fd);
2625
2626 fail:
2627         if (i)
2628                 inhibitor_free(i);
2629
2630         return r;
2631 }
2632
2633 const sd_bus_vtable manager_vtable[] = {
2634         SD_BUS_VTABLE_START(0),
2635
2636         SD_BUS_WRITABLE_PROPERTY("EnableWallMessages", "b", NULL, NULL, offsetof(Manager, enable_wall_messages), 0),
2637         SD_BUS_WRITABLE_PROPERTY("WallMessage", "s", NULL, NULL, offsetof(Manager, wall_message), 0),
2638
2639         SD_BUS_PROPERTY("NAutoVTs", "u", NULL, offsetof(Manager, n_autovts), SD_BUS_VTABLE_PROPERTY_CONST),
2640         SD_BUS_PROPERTY("KillOnlyUsers", "as", NULL, offsetof(Manager, kill_only_users), SD_BUS_VTABLE_PROPERTY_CONST),
2641         SD_BUS_PROPERTY("KillExcludeUsers", "as", NULL, offsetof(Manager, kill_exclude_users), SD_BUS_VTABLE_PROPERTY_CONST),
2642         SD_BUS_PROPERTY("KillUserProcesses", "b", NULL, offsetof(Manager, kill_user_processes), SD_BUS_VTABLE_PROPERTY_CONST),
2643         SD_BUS_PROPERTY("RebootToFirmwareSetup", "b", property_get_reboot_to_firmware_setup, 0, SD_BUS_VTABLE_PROPERTY_CONST),
2644         SD_BUS_PROPERTY("IdleHint", "b", property_get_idle_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
2645         SD_BUS_PROPERTY("IdleSinceHint", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
2646         SD_BUS_PROPERTY("IdleSinceHintMonotonic", "t", property_get_idle_since_hint, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
2647         SD_BUS_PROPERTY("BlockInhibited", "s", property_get_inhibited, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
2648         SD_BUS_PROPERTY("DelayInhibited", "s", property_get_inhibited, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
2649         SD_BUS_PROPERTY("InhibitDelayMaxUSec", "t", NULL, offsetof(Manager, inhibit_delay_max), SD_BUS_VTABLE_PROPERTY_CONST),
2650         SD_BUS_PROPERTY("HandlePowerKey", "s", property_get_handle_action, offsetof(Manager, handle_power_key), SD_BUS_VTABLE_PROPERTY_CONST),
2651         SD_BUS_PROPERTY("HandleSuspendKey", "s", property_get_handle_action, offsetof(Manager, handle_suspend_key), SD_BUS_VTABLE_PROPERTY_CONST),
2652         SD_BUS_PROPERTY("HandleHibernateKey", "s", property_get_handle_action, offsetof(Manager, handle_hibernate_key), SD_BUS_VTABLE_PROPERTY_CONST),
2653         SD_BUS_PROPERTY("HandleLidSwitch", "s", property_get_handle_action, offsetof(Manager, handle_lid_switch), SD_BUS_VTABLE_PROPERTY_CONST),
2654         SD_BUS_PROPERTY("HandleLidSwitchDocked", "s", property_get_handle_action, offsetof(Manager, handle_lid_switch_docked), SD_BUS_VTABLE_PROPERTY_CONST),
2655         SD_BUS_PROPERTY("HoldoffTimeoutUSec", "t", NULL, offsetof(Manager, holdoff_timeout_usec), SD_BUS_VTABLE_PROPERTY_CONST),
2656         SD_BUS_PROPERTY("IdleAction", "s", property_get_handle_action, offsetof(Manager, idle_action), SD_BUS_VTABLE_PROPERTY_CONST),
2657         SD_BUS_PROPERTY("IdleActionUSec", "t", NULL, offsetof(Manager, idle_action_usec), SD_BUS_VTABLE_PROPERTY_CONST),
2658         SD_BUS_PROPERTY("PreparingForShutdown", "b", property_get_preparing, 0, 0),
2659         SD_BUS_PROPERTY("PreparingForSleep", "b", property_get_preparing, 0, 0),
2660         SD_BUS_PROPERTY("ScheduledShutdown", "(st)", property_get_scheduled_shutdown, 0, 0),
2661         SD_BUS_PROPERTY("Docked", "b", property_get_docked, 0, 0),
2662         SD_BUS_PROPERTY("RemoveIPC", "b", bus_property_get_bool, offsetof(Manager, remove_ipc), SD_BUS_VTABLE_PROPERTY_CONST),
2663         SD_BUS_PROPERTY("RuntimeDirectorySize", "t", bus_property_get_size, offsetof(Manager, runtime_dir_size), SD_BUS_VTABLE_PROPERTY_CONST),
2664         SD_BUS_PROPERTY("InhibitorsMax", "t", NULL, offsetof(Manager, inhibitors_max), SD_BUS_VTABLE_PROPERTY_CONST),
2665         SD_BUS_PROPERTY("NCurrentInhibitors", "t", property_get_current_inhibitors, 0, 0),
2666         SD_BUS_PROPERTY("SessionsMax", "t", NULL, offsetof(Manager, sessions_max), SD_BUS_VTABLE_PROPERTY_CONST),
2667         SD_BUS_PROPERTY("NCurrentSessions", "t", property_get_current_sessions, 0, 0),
2668         SD_BUS_PROPERTY("UserTasksMax", "t", NULL, offsetof(Manager, user_tasks_max), SD_BUS_VTABLE_PROPERTY_CONST),
2669
2670         SD_BUS_METHOD("GetSession", "s", "o", method_get_session, SD_BUS_VTABLE_UNPRIVILEGED),
2671         SD_BUS_METHOD("GetSessionByPID", "u", "o", method_get_session_by_pid, SD_BUS_VTABLE_UNPRIVILEGED),
2672         SD_BUS_METHOD("GetUser", "u", "o", method_get_user, SD_BUS_VTABLE_UNPRIVILEGED),
2673         SD_BUS_METHOD("GetUserByPID", "u", "o", method_get_user_by_pid, SD_BUS_VTABLE_UNPRIVILEGED),
2674         SD_BUS_METHOD("GetSeat", "s", "o", method_get_seat, SD_BUS_VTABLE_UNPRIVILEGED),
2675         SD_BUS_METHOD("ListSessions", NULL, "a(susso)", method_list_sessions, SD_BUS_VTABLE_UNPRIVILEGED),
2676         SD_BUS_METHOD("ListUsers", NULL, "a(uso)", method_list_users, SD_BUS_VTABLE_UNPRIVILEGED),
2677         SD_BUS_METHOD("ListSeats", NULL, "a(so)", method_list_seats, SD_BUS_VTABLE_UNPRIVILEGED),
2678         SD_BUS_METHOD("ListInhibitors", NULL, "a(ssssuu)", method_list_inhibitors, SD_BUS_VTABLE_UNPRIVILEGED),
2679         SD_BUS_METHOD("CreateSession", "uusssssussbssa(sv)", "soshusub", method_create_session, 0),
2680         SD_BUS_METHOD("ReleaseSession", "s", NULL, method_release_session, 0),
2681         SD_BUS_METHOD("ActivateSession", "s", NULL, method_activate_session, SD_BUS_VTABLE_UNPRIVILEGED),
2682         SD_BUS_METHOD("ActivateSessionOnSeat", "ss", NULL, method_activate_session_on_seat, SD_BUS_VTABLE_UNPRIVILEGED),
2683         SD_BUS_METHOD("LockSession", "s", NULL, method_lock_session, SD_BUS_VTABLE_UNPRIVILEGED),
2684         SD_BUS_METHOD("UnlockSession", "s", NULL, method_lock_session, SD_BUS_VTABLE_UNPRIVILEGED),
2685         SD_BUS_METHOD("LockSessions", NULL, NULL, method_lock_sessions, SD_BUS_VTABLE_UNPRIVILEGED),
2686         SD_BUS_METHOD("UnlockSessions", NULL, NULL, method_lock_sessions, SD_BUS_VTABLE_UNPRIVILEGED),
2687         SD_BUS_METHOD("KillSession", "ssi", NULL, method_kill_session, SD_BUS_VTABLE_UNPRIVILEGED),
2688         SD_BUS_METHOD("KillUser", "ui", NULL, method_kill_user, SD_BUS_VTABLE_UNPRIVILEGED),
2689         SD_BUS_METHOD("TerminateSession", "s", NULL, method_terminate_session, SD_BUS_VTABLE_UNPRIVILEGED),
2690         SD_BUS_METHOD("TerminateUser", "u", NULL, method_terminate_user, SD_BUS_VTABLE_UNPRIVILEGED),
2691         SD_BUS_METHOD("TerminateSeat", "s", NULL, method_terminate_seat, SD_BUS_VTABLE_UNPRIVILEGED),
2692         SD_BUS_METHOD("SetUserLinger", "ubb", NULL, method_set_user_linger, SD_BUS_VTABLE_UNPRIVILEGED),
2693         SD_BUS_METHOD("AttachDevice", "ssb", NULL, method_attach_device, SD_BUS_VTABLE_UNPRIVILEGED),
2694         SD_BUS_METHOD("FlushDevices", "b", NULL, method_flush_devices, SD_BUS_VTABLE_UNPRIVILEGED),
2695         SD_BUS_METHOD("PowerOff", "b", NULL, method_poweroff, SD_BUS_VTABLE_UNPRIVILEGED),
2696         SD_BUS_METHOD("Reboot", "b", NULL, method_reboot, SD_BUS_VTABLE_UNPRIVILEGED),
2697         SD_BUS_METHOD("Halt", "b", NULL, method_halt, SD_BUS_VTABLE_UNPRIVILEGED),
2698         SD_BUS_METHOD("Suspend", "b", NULL, method_suspend, SD_BUS_VTABLE_UNPRIVILEGED),
2699         SD_BUS_METHOD("Hibernate", "b", NULL, method_hibernate, SD_BUS_VTABLE_UNPRIVILEGED),
2700         SD_BUS_METHOD("HybridSleep", "b", NULL, method_hybrid_sleep, SD_BUS_VTABLE_UNPRIVILEGED),
2701         SD_BUS_METHOD("CanPowerOff", NULL, "s", method_can_poweroff, SD_BUS_VTABLE_UNPRIVILEGED),
2702         SD_BUS_METHOD("CanReboot", NULL, "s", method_can_reboot, SD_BUS_VTABLE_UNPRIVILEGED),
2703         SD_BUS_METHOD("CanHalt", NULL, "s", method_can_halt, SD_BUS_VTABLE_UNPRIVILEGED),
2704         SD_BUS_METHOD("CanSuspend", NULL, "s", method_can_suspend, SD_BUS_VTABLE_UNPRIVILEGED),
2705         SD_BUS_METHOD("CanHibernate", NULL, "s", method_can_hibernate, SD_BUS_VTABLE_UNPRIVILEGED),
2706         SD_BUS_METHOD("CanHybridSleep", NULL, "s", method_can_hybrid_sleep, SD_BUS_VTABLE_UNPRIVILEGED),
2707         SD_BUS_METHOD("ScheduleShutdown", "st", NULL, method_schedule_shutdown, SD_BUS_VTABLE_UNPRIVILEGED),
2708         SD_BUS_METHOD("CancelScheduledShutdown", NULL, "b", method_cancel_scheduled_shutdown, SD_BUS_VTABLE_UNPRIVILEGED),
2709         SD_BUS_METHOD("Inhibit", "ssss", "h", method_inhibit, SD_BUS_VTABLE_UNPRIVILEGED),
2710         SD_BUS_METHOD("CanRebootToFirmwareSetup", NULL, "s", method_can_reboot_to_firmware_setup, SD_BUS_VTABLE_UNPRIVILEGED),
2711         SD_BUS_METHOD("SetRebootToFirmwareSetup", "b", NULL, method_set_reboot_to_firmware_setup, SD_BUS_VTABLE_UNPRIVILEGED),
2712         SD_BUS_METHOD("SetWallMessage", "sb", NULL, method_set_wall_message, SD_BUS_VTABLE_UNPRIVILEGED),
2713
2714         SD_BUS_SIGNAL("SessionNew", "so", 0),
2715         SD_BUS_SIGNAL("SessionRemoved", "so", 0),
2716         SD_BUS_SIGNAL("UserNew", "uo", 0),
2717         SD_BUS_SIGNAL("UserRemoved", "uo", 0),
2718         SD_BUS_SIGNAL("SeatNew", "so", 0),
2719         SD_BUS_SIGNAL("SeatRemoved", "so", 0),
2720         SD_BUS_SIGNAL("PrepareForShutdown", "b", 0),
2721         SD_BUS_SIGNAL("PrepareForSleep", "b", 0),
2722
2723         SD_BUS_VTABLE_END
2724 };
2725
2726 static int session_jobs_reply(Session *s, const char *unit, const char *result) {
2727         int r = 0;
2728
2729         assert(s);
2730         assert(unit);
2731
2732         if (!s->started)
2733                 return r;
2734
2735         if (streq(result, "done"))
2736                 r = session_send_create_reply(s, NULL);
2737         else {
2738                 _cleanup_(sd_bus_error_free) sd_bus_error e = SD_BUS_ERROR_NULL;
2739
2740                 sd_bus_error_setf(&e, BUS_ERROR_JOB_FAILED, "Start job for unit %s failed with '%s'", unit, result);
2741                 r = session_send_create_reply(s, &e);
2742         }
2743
2744         return r;
2745 }
2746
2747 int match_job_removed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2748         const char *path, *result, *unit;
2749         Manager *m = userdata;
2750         Session *session;
2751         uint32_t id;
2752         User *user;
2753         int r;
2754
2755         assert(message);
2756         assert(m);
2757
2758         r = sd_bus_message_read(message, "uoss", &id, &path, &unit, &result);
2759         if (r < 0) {
2760                 bus_log_parse_error(r);
2761                 return 0;
2762         }
2763
2764         if (m->action_job && streq(m->action_job, path)) {
2765                 log_info("Operation '%s' finished.", inhibit_what_to_string(m->action_what));
2766
2767                 /* Tell people that they now may take a lock again */
2768                 send_prepare_for(m, m->action_what, false);
2769
2770                 m->action_job = mfree(m->action_job);
2771                 m->action_unit = NULL;
2772                 m->action_what = 0;
2773                 return 0;
2774         }
2775
2776         session = hashmap_get(m->session_units, unit);
2777         if (session && streq_ptr(path, session->scope_job)) {
2778                 session->scope_job = mfree(session->scope_job);
2779                 session_jobs_reply(session, unit, result);
2780
2781                 session_save(session);
2782                 user_save(session->user);
2783                 session_add_to_gc_queue(session);
2784         }
2785
2786         user = hashmap_get(m->user_units, unit);
2787         if (user &&
2788             (streq_ptr(path, user->service_job) ||
2789              streq_ptr(path, user->slice_job))) {
2790
2791                 if (streq_ptr(path, user->service_job))
2792                         user->service_job = mfree(user->service_job);
2793
2794                 if (streq_ptr(path, user->slice_job))
2795                         user->slice_job = mfree(user->slice_job);
2796
2797                 LIST_FOREACH(sessions_by_user, session, user->sessions)
2798                         session_jobs_reply(session, unit, result);
2799
2800                 user_save(user);
2801                 user_add_to_gc_queue(user);
2802         }
2803
2804         return 0;
2805 }
2806
2807 int match_unit_removed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2808         const char *path, *unit;
2809         Manager *m = userdata;
2810         Session *session;
2811         User *user;
2812         int r;
2813
2814         assert(message);
2815         assert(m);
2816
2817         r = sd_bus_message_read(message, "so", &unit, &path);
2818         if (r < 0) {
2819                 bus_log_parse_error(r);
2820                 return 0;
2821         }
2822
2823         session = hashmap_get(m->session_units, unit);
2824         if (session)
2825                 session_add_to_gc_queue(session);
2826
2827         user = hashmap_get(m->user_units, unit);
2828         if (user)
2829                 user_add_to_gc_queue(user);
2830
2831         return 0;
2832 }
2833
2834 int match_properties_changed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2835         _cleanup_free_ char *unit = NULL;
2836         Manager *m = userdata;
2837         const char *path;
2838         Session *session;
2839         User *user;
2840         int r;
2841
2842         assert(message);
2843         assert(m);
2844
2845         path = sd_bus_message_get_path(message);
2846         if (!path)
2847                 return 0;
2848
2849         r = unit_name_from_dbus_path(path, &unit);
2850         if (r == -EINVAL) /* not a unit */
2851                 return 0;
2852         if (r < 0) {
2853                 log_oom();
2854                 return 0;
2855         }
2856
2857         session = hashmap_get(m->session_units, unit);
2858         if (session)
2859                 session_add_to_gc_queue(session);
2860
2861         user = hashmap_get(m->user_units, unit);
2862         if (user)
2863                 user_add_to_gc_queue(user);
2864
2865         return 0;
2866 }
2867
2868 int match_reloading(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2869         Manager *m = userdata;
2870         Session *session;
2871         Iterator i;
2872         int b, r;
2873
2874         assert(message);
2875         assert(m);
2876
2877         r = sd_bus_message_read(message, "b", &b);
2878         if (r < 0) {
2879                 bus_log_parse_error(r);
2880                 return 0;
2881         }
2882
2883         if (b)
2884                 return 0;
2885
2886         /* systemd finished reloading, let's recheck all our sessions */
2887         log_debug("System manager has been reloaded, rechecking sessions...");
2888
2889         HASHMAP_FOREACH(session, m->sessions, i)
2890                 session_add_to_gc_queue(session);
2891
2892         return 0;
2893 }
2894
2895 int manager_send_changed(Manager *manager, const char *property, ...) {
2896         char **l;
2897
2898         assert(manager);
2899
2900         l = strv_from_stdarg_alloca(property);
2901
2902         return sd_bus_emit_properties_changed_strv(
2903                         manager->bus,
2904                         "/org/freedesktop/login1",
2905                         "org.freedesktop.login1.Manager",
2906                         l);
2907 }
2908
2909 static int strdup_job(sd_bus_message *reply, char **job) {
2910         const char *j;
2911         char *copy;
2912         int r;
2913
2914         r = sd_bus_message_read(reply, "o", &j);
2915         if (r < 0)
2916                 return r;
2917
2918         copy = strdup(j);
2919         if (!copy)
2920                 return -ENOMEM;
2921
2922         *job = copy;
2923         return 1;
2924 }
2925
2926 int manager_start_slice(
2927                 Manager *manager,
2928                 const char *slice,
2929                 const char *description,
2930                 const char *after,
2931                 const char *after2,
2932                 uint64_t tasks_max,
2933                 sd_bus_error *error,
2934                 char **job) {
2935
2936         _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL, *reply = NULL;
2937         int r;
2938
2939         assert(manager);
2940         assert(slice);
2941         assert(job);
2942
2943         r = sd_bus_message_new_method_call(
2944                         manager->bus,
2945                         &m,
2946                         "org.freedesktop.systemd1",
2947                         "/org/freedesktop/systemd1",
2948                         "org.freedesktop.systemd1.Manager",
2949                         "StartTransientUnit");
2950         if (r < 0)
2951                 return r;
2952
2953         r = sd_bus_message_append(m, "ss", strempty(slice), "fail");
2954         if (r < 0)
2955                 return r;
2956
2957         r = sd_bus_message_open_container(m, 'a', "(sv)");
2958         if (r < 0)
2959                 return r;
2960
2961         if (!isempty(description)) {
2962                 r = sd_bus_message_append(m, "(sv)", "Description", "s", description);
2963                 if (r < 0)
2964                         return r;
2965         }
2966
2967         if (!isempty(after)) {
2968                 r = sd_bus_message_append(m, "(sv)", "After", "as", 1, after);
2969                 if (r < 0)
2970                         return r;
2971         }
2972
2973         if (!isempty(after2)) {
2974                 r = sd_bus_message_append(m, "(sv)", "After", "as", 1, after2);
2975                 if (r < 0)
2976                         return r;
2977         }
2978
2979         r = sd_bus_message_append(m, "(sv)", "TasksMax", "t", tasks_max);
2980         if (r < 0)
2981                 return r;
2982
2983         r = sd_bus_message_close_container(m);
2984         if (r < 0)
2985                 return r;
2986
2987         r = sd_bus_message_append(m, "a(sa(sv))", 0);
2988         if (r < 0)
2989                 return r;
2990
2991         r = sd_bus_call(manager->bus, m, 0, error, &reply);
2992         if (r < 0)
2993                 return r;
2994
2995         return strdup_job(reply, job);
2996 }
2997
2998 int manager_start_scope(
2999                 Manager *manager,
3000                 const char *scope,
3001                 pid_t pid,
3002                 const char *slice,
3003                 const char *description,
3004                 const char *after,
3005                 const char *after2,
3006                 uint64_t tasks_max,
3007                 sd_bus_error *error,
3008                 char **job) {
3009
3010         _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL, *reply = NULL;
3011         int r;
3012
3013         assert(manager);
3014         assert(scope);
3015         assert(pid > 1);
3016         assert(job);
3017
3018         r = sd_bus_message_new_method_call(
3019                         manager->bus,
3020                         &m,
3021                         "org.freedesktop.systemd1",
3022                         "/org/freedesktop/systemd1",
3023                         "org.freedesktop.systemd1.Manager",
3024                         "StartTransientUnit");
3025         if (r < 0)
3026                 return r;
3027
3028         r = sd_bus_message_append(m, "ss", strempty(scope), "fail");
3029         if (r < 0)
3030                 return r;
3031
3032         r = sd_bus_message_open_container(m, 'a', "(sv)");
3033         if (r < 0)
3034                 return r;
3035
3036         if (!isempty(slice)) {
3037                 r = sd_bus_message_append(m, "(sv)", "Slice", "s", slice);
3038                 if (r < 0)
3039                         return r;
3040         }
3041
3042         if (!isempty(description)) {
3043                 r = sd_bus_message_append(m, "(sv)", "Description", "s", description);
3044                 if (r < 0)
3045                         return r;
3046         }
3047
3048         if (!isempty(after)) {
3049                 r = sd_bus_message_append(m, "(sv)", "After", "as", 1, after);
3050                 if (r < 0)
3051                         return r;
3052         }
3053
3054         if (!isempty(after2)) {
3055                 r = sd_bus_message_append(m, "(sv)", "After", "as", 1, after2);
3056                 if (r < 0)
3057                         return r;
3058         }
3059
3060         /* cgroup empty notification is not available in containers
3061          * currently. To make this less problematic, let's shorten the
3062          * stop timeout for sessions, so that we don't wait
3063          * forever. */
3064
3065         /* Make sure that the session shells are terminated with
3066          * SIGHUP since bash and friends tend to ignore SIGTERM */
3067         r = sd_bus_message_append(m, "(sv)", "SendSIGHUP", "b", true);
3068         if (r < 0)
3069                 return r;
3070
3071         r = sd_bus_message_append(m, "(sv)", "PIDs", "au", 1, pid);
3072         if (r < 0)
3073                 return r;
3074
3075         r = sd_bus_message_append(m, "(sv)", "TasksMax", "t", tasks_max);
3076         if (r < 0)
3077                 return r;
3078
3079         r = sd_bus_message_close_container(m);
3080         if (r < 0)
3081                 return r;
3082
3083         r = sd_bus_message_append(m, "a(sa(sv))", 0);
3084         if (r < 0)
3085                 return r;
3086
3087         r = sd_bus_call(manager->bus, m, 0, error, &reply);
3088         if (r < 0)
3089                 return r;
3090
3091         return strdup_job(reply, job);
3092 }
3093
3094 int manager_start_unit(Manager *manager, const char *unit, sd_bus_error *error, char **job) {
3095         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
3096         int r;
3097
3098         assert(manager);
3099         assert(unit);
3100         assert(job);
3101
3102         r = sd_bus_call_method(
3103                         manager->bus,
3104                         "org.freedesktop.systemd1",
3105                         "/org/freedesktop/systemd1",
3106                         "org.freedesktop.systemd1.Manager",
3107                         "StartUnit",
3108                         error,
3109                         &reply,
3110                         "ss", unit, "replace");
3111         if (r < 0)
3112                 return r;
3113
3114         return strdup_job(reply, job);
3115 }
3116
3117 int manager_stop_unit(Manager *manager, const char *unit, sd_bus_error *error, char **job) {
3118         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
3119         int r;
3120
3121         assert(manager);
3122         assert(unit);
3123         assert(job);
3124
3125         r = sd_bus_call_method(
3126                         manager->bus,
3127                         "org.freedesktop.systemd1",
3128                         "/org/freedesktop/systemd1",
3129                         "org.freedesktop.systemd1.Manager",
3130                         "StopUnit",
3131                         error,
3132                         &reply,
3133                         "ss", unit, "fail");
3134         if (r < 0) {
3135                 if (sd_bus_error_has_name(error, BUS_ERROR_NO_SUCH_UNIT) ||
3136                     sd_bus_error_has_name(error, BUS_ERROR_LOAD_FAILED)) {
3137
3138                         *job = NULL;
3139                         sd_bus_error_free(error);
3140                         return 0;
3141                 }
3142
3143                 return r;
3144         }
3145
3146         return strdup_job(reply, job);
3147 }
3148
3149 int manager_abandon_scope(Manager *manager, const char *scope, sd_bus_error *error) {
3150         _cleanup_free_ char *path = NULL;
3151         int r;
3152
3153         assert(manager);
3154         assert(scope);
3155
3156         path = unit_dbus_path_from_name(scope);
3157         if (!path)
3158                 return -ENOMEM;
3159
3160         r = sd_bus_call_method(
3161                         manager->bus,
3162                         "org.freedesktop.systemd1",
3163                         path,
3164                         "org.freedesktop.systemd1.Scope",
3165                         "Abandon",
3166                         error,
3167                         NULL,
3168                         NULL);
3169         if (r < 0) {
3170                 if (sd_bus_error_has_name(error, BUS_ERROR_NO_SUCH_UNIT) ||
3171                     sd_bus_error_has_name(error, BUS_ERROR_LOAD_FAILED) ||
3172                     sd_bus_error_has_name(error, BUS_ERROR_SCOPE_NOT_RUNNING)) {
3173                         sd_bus_error_free(error);
3174                         return 0;
3175                 }
3176
3177                 return r;
3178         }
3179
3180         return 1;
3181 }
3182
3183 int manager_kill_unit(Manager *manager, const char *unit, KillWho who, int signo, sd_bus_error *error) {
3184         assert(manager);
3185         assert(unit);
3186
3187         return sd_bus_call_method(
3188                         manager->bus,
3189                         "org.freedesktop.systemd1",
3190                         "/org/freedesktop/systemd1",
3191                         "org.freedesktop.systemd1.Manager",
3192                         "KillUnit",
3193                         error,
3194                         NULL,
3195                         "ssi", unit, who == KILL_LEADER ? "main" : "all", signo);
3196 }
3197
3198 int manager_unit_is_active(Manager *manager, const char *unit) {
3199         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
3200         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
3201         _cleanup_free_ char *path = NULL;
3202         const char *state;
3203         int r;
3204
3205         assert(manager);
3206         assert(unit);
3207
3208         path = unit_dbus_path_from_name(unit);
3209         if (!path)
3210                 return -ENOMEM;
3211
3212         r = sd_bus_get_property(
3213                         manager->bus,
3214                         "org.freedesktop.systemd1",
3215                         path,
3216                         "org.freedesktop.systemd1.Unit",
3217                         "ActiveState",
3218                         &error,
3219                         &reply,
3220                         "s");
3221         if (r < 0) {
3222                 /* systemd might have droppped off momentarily, let's
3223                  * not make this an error */
3224                 if (sd_bus_error_has_name(&error, SD_BUS_ERROR_NO_REPLY) ||
3225                     sd_bus_error_has_name(&error, SD_BUS_ERROR_DISCONNECTED))
3226                         return true;
3227
3228                 /* If the unit is already unloaded then it's not
3229                  * active */
3230                 if (sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_UNIT) ||
3231                     sd_bus_error_has_name(&error, BUS_ERROR_LOAD_FAILED))
3232                         return false;
3233
3234                 return r;
3235         }
3236
3237         r = sd_bus_message_read(reply, "s", &state);
3238         if (r < 0)
3239                 return -EINVAL;
3240
3241         return !streq(state, "inactive") && !streq(state, "failed");
3242 }
3243
3244 int manager_job_is_active(Manager *manager, const char *path) {
3245         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
3246         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
3247         int r;
3248
3249         assert(manager);
3250         assert(path);
3251
3252         r = sd_bus_get_property(
3253                         manager->bus,
3254                         "org.freedesktop.systemd1",
3255                         path,
3256                         "org.freedesktop.systemd1.Job",
3257                         "State",
3258                         &error,
3259                         &reply,
3260                         "s");
3261         if (r < 0) {
3262                 if (sd_bus_error_has_name(&error, SD_BUS_ERROR_NO_REPLY) ||
3263                     sd_bus_error_has_name(&error, SD_BUS_ERROR_DISCONNECTED))
3264                         return true;
3265
3266                 if (sd_bus_error_has_name(&error, SD_BUS_ERROR_UNKNOWN_OBJECT))
3267                         return false;
3268
3269                 return r;
3270         }
3271
3272         /* We don't actually care about the state really. The fact
3273          * that we could read the job state is enough for us */
3274
3275         return true;
3276 }