src/login/logind-seat.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2011 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <errno.h>
  23 #include <unistd.h>
  24 #include <fcntl.h>
  25 #include <string.h>
  26
  27 #include "sd-messages.h"
  28 #include "logind-seat.h"
  29 #include "logind-acl.h"
  30 #include "util.h"
  31 #include "mkdir.h"
  32
  33 Seat *seat_new(Manager *m, const char *id) {
  34         Seat *s;
  35
  36         assert(m);
  37         assert(id);
  38
  39         s = new0(Seat, 1);
  40         if (!s)
  41                 return NULL;
  42
  43         s->state_file = strappend("/run/systemd/seats/", id);
  44         if (!s->state_file) {
  45                 free(s);
  46                 return NULL;
  47         }
  48
  49         s->id = basename(s->state_file);
  50         s->manager = m;
  51
  52         if (hashmap_put(m->seats, s->id, s) < 0) {
  53                 free(s->state_file);
  54                 free(s);
  55                 return NULL;
  56         }
  57
  58         return s;
  59 }
  60
  61 void seat_free(Seat *s) {
  62         assert(s);
  63
  64         if (s->in_gc_queue)
  65                 LIST_REMOVE(gc_queue, s->manager->seat_gc_queue, s);
  66
  67         while (s->sessions)
  68                 session_free(s->sessions);
  69
  70         assert(!s->active);
  71
  72         while (s->devices)
  73                 device_free(s->devices);
  74
  75         hashmap_remove(s->manager->seats, s->id);
  76
  77         free(s->positions);
  78         free(s->state_file);
  79         free(s);
  80 }
  81
  82 int seat_save(Seat *s) {
  83         _cleanup_free_ char *temp_path = NULL;
  84         _cleanup_fclose_ FILE *f = NULL;
  85         int r;
  86
  87         assert(s);
  88
  89         if (!s->started)
  90                 return 0;
  91
  92         r = mkdir_safe_label("/run/systemd/seats", 0755, 0, 0);
  93         if (r < 0)
  94                 goto finish;
  95
  96         r = fopen_temporary(s->state_file, &f, &temp_path);
  97         if (r < 0)
  98                 goto finish;
  99
 100         fchmod(fileno(f), 0644);
 101
 102         fprintf(f,
 103                 "# This is private data. Do not parse.\n"
 104                 "IS_SEAT0=%i\n"
 105                 "CAN_MULTI_SESSION=%i\n"
 106                 "CAN_TTY=%i\n"
 107                 "CAN_GRAPHICAL=%i\n",
 108                 seat_is_seat0(s),
 109                 seat_can_multi_session(s),
 110                 seat_can_tty(s),
 111                 seat_can_graphical(s));
 112
 113         if (s->active) {
 114                 assert(s->active->user);
 115
 116                 fprintf(f,
 117                         "ACTIVE=%s\n"
 118                         "ACTIVE_UID="UID_FMT"\n",
 119                         s->active->id,
 120                         s->active->user->uid);
 121         }
 122
 123         if (s->sessions) {
 124                 Session *i;
 125
 126                 fputs("SESSIONS=", f);
 127                 LIST_FOREACH(sessions_by_seat, i, s->sessions) {
 128                         fprintf(f,
 129                                 "%s%c",
 130                                 i->id,
 131                                 i->sessions_by_seat_next ? ' ' : '\n');
 132                 }
 133
 134                 fputs("UIDS=", f);
 135                 LIST_FOREACH(sessions_by_seat, i, s->sessions)
 136                         fprintf(f,
 137                                 UID_FMT"%c",
 138                                 i->user->uid,
 139                                 i->sessions_by_seat_next ? ' ' : '\n');
 140         }
 141
 142         fflush(f);
 143
 144         if (ferror(f) || rename(temp_path, s->state_file) < 0) {
 145                 r = -errno;
 146                 unlink(s->state_file);
 147                 unlink(temp_path);
 148         }
 149
 150 finish:
 151         if (r < 0)
 152                 log_error_errno(r, "Failed to save seat data %s: %m", s->state_file);
 153
 154         return r;
 155 }
 156
 157 int seat_load(Seat *s) {
 158         assert(s);
 159
 160         /* There isn't actually anything to read here ... */
 161
 162         return 0;
 163 }
 164
 165 static int vt_allocate(unsigned int vtnr) {
 166         char p[sizeof("/dev/tty") + DECIMAL_STR_MAX(unsigned int)];
 167         _cleanup_close_ int fd = -1;
 168
 169         assert(vtnr >= 1);
 170
 171         snprintf(p, sizeof(p), "/dev/tty%u", vtnr);
 172         fd = open_terminal(p, O_RDWR|O_NOCTTY|O_CLOEXEC);
 173         if (fd < 0)
 174                 return -errno;
 175
 176         return 0;
 177 }
 178
 179 int seat_preallocate_vts(Seat *s) {
 180         int r = 0;
 181         unsigned i;
 182
 183         assert(s);
 184         assert(s->manager);
 185
 186         log_debug("Preallocating VTs...");
 187
 188         if (s->manager->n_autovts <= 0)
 189                 return 0;
 190
 191         if (!seat_has_vts(s))
 192                 return 0;
 193
 194         for (i = 1; i <= s->manager->n_autovts; i++) {
 195                 int q;
 196
 197                 q = vt_allocate(i);
 198                 if (q < 0) {
 199                         log_error_errno(q, "Failed to preallocate VT %u: %m", i);
 200                         r = q;
 201                 }
 202         }
 203
 204         return r;
 205 }
 206
 207 int seat_apply_acls(Seat *s, Session *old_active) {
 208         int r;
 209
 210         assert(s);
 211
 212         r = devnode_acl_all(s->manager->udev,
 213                             s->id,
 214                             false,
 215                             !!old_active, old_active ? old_active->user->uid : 0,
 216                             !!s->active, s->active ? s->active->user->uid : 0);
 217
 218         if (r < 0)
 219                 log_error_errno(r, "Failed to apply ACLs: %m");
 220
 221         return r;
 222 }
 223
 224 int seat_set_active(Seat *s, Session *session) {
 225         Session *old_active;
 226
 227         assert(s);
 228         assert(!session || session->seat == s);
 229
 230         if (session == s->active)
 231                 return 0;
 232
 233         old_active = s->active;
 234         s->active = session;
 235
 236         if (old_active) {
 237                 session_device_pause_all(old_active);
 238                 session_send_changed(old_active, "Active", NULL);
 239         }
 240
 241         seat_apply_acls(s, old_active);
 242
 243         if (session && session->started) {
 244                 session_send_changed(session, "Active", NULL);
 245                 session_device_resume_all(session);
 246         }
 247
 248         if (!session || session->started)
 249                 seat_send_changed(s, "ActiveSession", NULL);
 250
 251         seat_save(s);
 252
 253         if (session) {
 254                 session_save(session);
 255                 user_save(session->user);
 256         }
 257
 258         if (old_active) {
 259                 session_save(old_active);
 260                 if (!session || session->user != old_active->user)
 261                         user_save(old_active->user);
 262         }
 263
 264         return 0;
 265 }
 266
 267 int seat_switch_to(Seat *s, unsigned int num) {
 268         /* Public session positions skip 0 (there is only F1-F12). Maybe it
 269          * will get reassigned in the future, so return error for now. */
 270         if (!num)
 271                 return -EINVAL;
 272
 273         if (num >= s->position_count || !s->positions[num]) {
 274                 /* allow switching to unused VTs to trigger auto-activate */
 275                 if (seat_has_vts(s) && num < 64)
 276                         return chvt(num);
 277
 278                 return -EINVAL;
 279         }
 280
 281         return session_activate(s->positions[num]);
 282 }
 283
 284 int seat_switch_to_next(Seat *s) {
 285         unsigned int start, i;
 286
 287         if (!s->position_count)
 288                 return -EINVAL;
 289
 290         start = 1;
 291         if (s->active && s->active->pos > 0)
 292                 start = s->active->pos;
 293
 294         for (i = start + 1; i < s->position_count; ++i)
 295                 if (s->positions[i])
 296                         return session_activate(s->positions[i]);
 297
 298         for (i = 1; i < start; ++i)
 299                 if (s->positions[i])
 300                         return session_activate(s->positions[i]);
 301
 302         return -EINVAL;
 303 }
 304
 305 int seat_switch_to_previous(Seat *s) {
 306         unsigned int start, i;
 307
 308         if (!s->position_count)
 309                 return -EINVAL;
 310
 311         start = 1;
 312         if (s->active && s->active->pos > 0)
 313                 start = s->active->pos;
 314
 315         for (i = start - 1; i > 0; --i)
 316                 if (s->positions[i])
 317                         return session_activate(s->positions[i]);
 318
 319         for (i = s->position_count - 1; i > start; --i)
 320                 if (s->positions[i])
 321                         return session_activate(s->positions[i]);
 322
 323         return -EINVAL;
 324 }
 325
 326 int seat_active_vt_changed(Seat *s, unsigned int vtnr) {
 327         Session *i, *new_active = NULL;
 328         int r;
 329
 330         assert(s);
 331         assert(vtnr >= 1);
 332
 333         if (!seat_has_vts(s))
 334                 return -EINVAL;
 335
 336         log_debug("VT changed to %u", vtnr);
 337
 338         /* we might have earlier closing sessions on the same VT, so try to
 339          * find a running one first */
 340         LIST_FOREACH(sessions_by_seat, i, s->sessions)
 341                 if (i->vtnr == vtnr && !i->stopping) {
 342                         new_active = i;
 343                         break;
 344                 }
 345
 346         if (!new_active) {
 347                 /* no running one? then we can't decide which one is the
 348                  * active one, let the first one win */
 349                 LIST_FOREACH(sessions_by_seat, i, s->sessions)
 350                         if (i->vtnr == vtnr) {
 351                                 new_active = i;
 352                                 break;
 353                         }
 354         }
 355
 356         r = seat_set_active(s, new_active);
 357         manager_spawn_autovt(s->manager, vtnr);
 358
 359         return r;
 360 }
 361
 362 int seat_read_active_vt(Seat *s) {
 363         char t[64];
 364         ssize_t k;
 365         unsigned int vtnr;
 366         int r;
 367
 368         assert(s);
 369
 370         if (!seat_has_vts(s))
 371                 return 0;
 372
 373         lseek(s->manager->console_active_fd, SEEK_SET, 0);
 374
 375         k = read(s->manager->console_active_fd, t, sizeof(t)-1);
 376         if (k <= 0) {
 377                 log_error("Failed to read current console: %s", k < 0 ? strerror(-errno) : "EOF");
 378                 return k < 0 ? -errno : -EIO;
 379         }
 380
 381         t[k] = 0;
 382         truncate_nl(t);
 383
 384         if (!startswith(t, "tty")) {
 385                 log_error("Hm, /sys/class/tty/tty0/active is badly formatted.");
 386                 return -EIO;
 387         }
 388
 389         r = safe_atou(t+3, &vtnr);
 390         if (r < 0) {
 391                 log_error("Failed to parse VT number %s", t+3);
 392                 return r;
 393         }
 394
 395         if (!vtnr) {
 396                 log_error("VT number invalid: %s", t+3);
 397                 return -EIO;
 398         }
 399
 400         return seat_active_vt_changed(s, vtnr);
 401 }
 402
 403 int seat_start(Seat *s) {
 404         assert(s);
 405
 406         if (s->started)
 407                 return 0;
 408
 409         log_struct(LOG_INFO,
 410                    LOG_MESSAGE_ID(SD_MESSAGE_SEAT_START),
 411                    "SEAT_ID=%s", s->id,
 412                    LOG_MESSAGE("New seat %s.", s->id),
 413                    NULL);
 414
 415         /* Initialize VT magic stuff */
 416         seat_preallocate_vts(s);
 417
 418         /* Read current VT */
 419         seat_read_active_vt(s);
 420
 421         s->started = true;
 422
 423         /* Save seat data */
 424         seat_save(s);
 425
 426         seat_send_signal(s, true);
 427
 428         return 0;
 429 }
 430
 431 int seat_stop(Seat *s, bool force) {
 432         int r = 0;
 433
 434         assert(s);
 435
 436         if (s->started)
 437                 log_struct(LOG_INFO,
 438                            LOG_MESSAGE_ID(SD_MESSAGE_SEAT_STOP),
 439                            "SEAT_ID=%s", s->id,
 440                            LOG_MESSAGE("Removed seat %s.", s->id),
 441                            NULL);
 442
 443         seat_stop_sessions(s, force);
 444
 445         unlink(s->state_file);
 446         seat_add_to_gc_queue(s);
 447
 448         if (s->started)
 449                 seat_send_signal(s, false);
 450
 451         s->started = false;
 452
 453         return r;
 454 }
 455
 456 int seat_stop_sessions(Seat *s, bool force) {
 457         Session *session;
 458         int r = 0, k;
 459
 460         assert(s);
 461
 462         LIST_FOREACH(sessions_by_seat, session, s->sessions) {
 463                 k = session_stop(session, force);
 464                 if (k < 0)
 465                         r = k;
 466         }
 467
 468         return r;
 469 }
 470
 471 void seat_evict_position(Seat *s, Session *session) {
 472         Session *iter;
 473         unsigned int pos = session->pos;
 474
 475         session->pos = 0;
 476
 477         if (!pos)
 478                 return;
 479
 480         if (pos < s->position_count && s->positions[pos] == session) {
 481                 s->positions[pos] = NULL;
 482
 483                 /* There might be another session claiming the same
 484                  * position (eg., during gdm->session transition), so lets look
 485                  * for it and set it on the free slot. */
 486                 LIST_FOREACH(sessions_by_seat, iter, s->sessions) {
 487                         if (iter->pos == pos) {
 488                                 s->positions[pos] = iter;
 489                                 break;
 490                         }
 491                 }
 492         }
 493 }
 494
 495 void seat_claim_position(Seat *s, Session *session, unsigned int pos) {
 496         /* with VTs, the position is always the same as the VTnr */
 497         if (seat_has_vts(s))
 498                 pos = session->vtnr;
 499
 500         if (!GREEDY_REALLOC0(s->positions, s->position_count, pos + 1))
 501                 return;
 502
 503         seat_evict_position(s, session);
 504
 505         session->pos = pos;
 506         if (pos > 0 && !s->positions[pos])
 507                 s->positions[pos] = session;
 508 }
 509
 510 static void seat_assign_position(Seat *s, Session *session) {
 511         unsigned int pos;
 512
 513         if (session->pos > 0)
 514                 return;
 515
 516         for (pos = 1; pos < s->position_count; ++pos)
 517                 if (!s->positions[pos])
 518                         break;
 519
 520         seat_claim_position(s, session, pos);
 521 }
 522
 523 int seat_attach_session(Seat *s, Session *session) {
 524         assert(s);
 525         assert(session);
 526         assert(!session->seat);
 527
 528         if (!seat_has_vts(s) != !session->vtnr)
 529                 return -EINVAL;
 530
 531         session->seat = s;
 532         LIST_PREPEND(sessions_by_seat, s->sessions, session);
 533         seat_assign_position(s, session);
 534
 535         seat_send_changed(s, "Sessions", NULL);
 536
 537         /* On seats with VTs, the VT logic defines which session is active. On
 538          * seats without VTs, we automatically activate new sessions. */
 539         if (!seat_has_vts(s))
 540                 seat_set_active(s, session);
 541
 542         return 0;
 543 }
 544
 545 void seat_complete_switch(Seat *s) {
 546         Session *session;
 547
 548         assert(s);
 549
 550         /* if no session-switch is pending or if it got canceled, do nothing */
 551         if (!s->pending_switch)
 552                 return;
 553
 554         session = s->pending_switch;
 555         s->pending_switch = NULL;
 556
 557         seat_set_active(s, session);
 558 }
 559
 560 bool seat_has_vts(Seat *s) {
 561         assert(s);
 562
 563         return seat_is_seat0(s) && s->manager->console_active_fd >= 0;
 564 }
 565
 566 bool seat_is_seat0(Seat *s) {
 567         assert(s);
 568
 569         return s->manager->seat0 == s;
 570 }
 571
 572 bool seat_can_multi_session(Seat *s) {
 573         assert(s);
 574
 575         return seat_has_vts(s);
 576 }
 577
 578 bool seat_can_tty(Seat *s) {
 579         assert(s);
 580
 581         return seat_has_vts(s);
 582 }
 583
 584 bool seat_has_master_device(Seat *s) {
 585         assert(s);
 586
 587         /* device list is ordered by "master" flag */
 588         return !!s->devices && s->devices->master;
 589 }
 590
 591 bool seat_can_graphical(Seat *s) {
 592         assert(s);
 593
 594         return seat_has_master_device(s);
 595 }
 596
 597 int seat_get_idle_hint(Seat *s, dual_timestamp *t) {
 598         Session *session;
 599         bool idle_hint = true;
 600         dual_timestamp ts = { 0, 0 };
 601
 602         assert(s);
 603
 604         LIST_FOREACH(sessions_by_seat, session, s->sessions) {
 605                 dual_timestamp k;
 606                 int ih;
 607
 608                 ih = session_get_idle_hint(session, &k);
 609                 if (ih < 0)
 610                         return ih;
 611
 612                 if (!ih) {
 613                         if (!idle_hint) {
 614                                 if (k.monotonic > ts.monotonic)
 615                                         ts = k;
 616                         } else {
 617                                 idle_hint = false;
 618                                 ts = k;
 619                         }
 620                 } else if (idle_hint) {
 621
 622                         if (k.monotonic > ts.monotonic)
 623                                 ts = k;
 624                 }
 625         }
 626
 627         if (t)
 628                 *t = ts;
 629
 630         return idle_hint;
 631 }
 632
 633 bool seat_check_gc(Seat *s, bool drop_not_started) {
 634         assert(s);
 635
 636         if (drop_not_started && !s->started)
 637                 return false;
 638
 639         if (seat_is_seat0(s))
 640                 return true;
 641
 642         return seat_has_master_device(s);
 643 }
 644
 645 void seat_add_to_gc_queue(Seat *s) {
 646         assert(s);
 647
 648         if (s->in_gc_queue)
 649                 return;
 650
 651         LIST_PREPEND(gc_queue, s->manager->seat_gc_queue, s);
 652         s->in_gc_queue = true;
 653 }
 654
 655 static bool seat_name_valid_char(char c) {
 656         return
 657                 (c >= 'a' && c <= 'z') ||
 658                 (c >= 'A' && c <= 'Z') ||
 659                 (c >= '0' && c <= '9') ||
 660                 c == '-' ||
 661                 c == '_';
 662 }
 663
 664 bool seat_name_is_valid(const char *name) {
 665         const char *p;
 666
 667         assert(name);
 668
 669         if (!startswith(name, "seat"))
 670                 return false;
 671
 672         if (!name[4])
 673                 return false;
 674
 675         for (p = name; *p; p++)
 676                 if (!seat_name_valid_char(*p))
 677                         return false;
 678
 679         if (strlen(name) > 255)
 680                 return false;
 681
 682         return true;
 683 }