src/libsystemd/sd-login/sd-login.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 <unistd.h>
  23 #include <string.h>
  24 #include <errno.h>
  25 #include <sys/inotify.h>
  26 #include <sys/poll.h>
  27
  28 #include "util.h"
  29 #include "cgroup-util.h"
  30 #include "macro.h"
  31 #include "strv.h"
  32 #include "fileio.h"
  33 #include "login-shared.h"
  34 #include "sd-login.h"
  35
  36 _public_ int sd_pid_get_session(pid_t pid, char **session) {
  37
  38         assert_return(pid >= 0, -EINVAL);
  39         assert_return(session, -EINVAL);
  40
  41         return cg_pid_get_session(pid, session);
  42 }
  43
  44 _public_ int sd_pid_get_unit(pid_t pid, char **unit) {
  45
  46         assert_return(pid >= 0, -EINVAL);
  47         assert_return(unit, -EINVAL);
  48
  49         return cg_pid_get_unit(pid, unit);
  50 }
  51
  52 _public_ int sd_pid_get_user_unit(pid_t pid, char **unit) {
  53
  54         assert_return(pid >= 0, -EINVAL);
  55         assert_return(unit, -EINVAL);
  56
  57         return cg_pid_get_user_unit(pid, unit);
  58 }
  59
  60 _public_ int sd_pid_get_machine_name(pid_t pid, char **name) {
  61
  62         assert_return(pid >= 0, -EINVAL);
  63         assert_return(name, -EINVAL);
  64
  65         return cg_pid_get_machine_name(pid, name);
  66 }
  67
  68 _public_ int sd_pid_get_slice(pid_t pid, char **slice) {
  69
  70         assert_return(pid >= 0, -EINVAL);
  71         assert_return(slice, -EINVAL);
  72
  73         return cg_pid_get_slice(pid, slice);
  74 }
  75
  76 _public_ int sd_pid_get_owner_uid(pid_t pid, uid_t *uid) {
  77
  78         assert_return(pid >= 0, -EINVAL);
  79         assert_return(uid, -EINVAL);
  80
  81         return cg_pid_get_owner_uid(pid, uid);
  82 }
  83
  84 _public_ int sd_peer_get_session(int fd, char **session) {
  85         struct ucred ucred;
  86         int r;
  87
  88         assert_return(fd >= 0, -EINVAL);
  89         assert_return(session, -EINVAL);
  90
  91         r = getpeercred(fd, &ucred);
  92         if (r < 0)
  93                 return r;
  94
  95         return cg_pid_get_session(ucred.pid, session);
  96 }
  97
  98 _public_ int sd_peer_get_owner_uid(int fd, uid_t *uid) {
  99         struct ucred ucred;
 100         int r;
 101
 102         assert_return(fd >= 0, -EINVAL);
 103         assert_return(uid, -EINVAL);
 104
 105         r = getpeercred(fd, &ucred);
 106         if (r < 0)
 107                 return r;
 108
 109         return cg_pid_get_owner_uid(ucred.pid, uid);
 110 }
 111
 112 _public_ int sd_peer_get_unit(int fd, char **unit) {
 113         struct ucred ucred;
 114         int r;
 115
 116         assert_return(fd >= 0, -EINVAL);
 117         assert_return(unit, -EINVAL);
 118
 119         r = getpeercred(fd, &ucred);
 120         if (r < 0)
 121                 return r;
 122
 123         return cg_pid_get_unit(ucred.pid, unit);
 124 }
 125
 126 _public_ int sd_peer_get_user_unit(int fd, char **unit) {
 127         struct ucred ucred;
 128         int r;
 129
 130         assert_return(fd >= 0, -EINVAL);
 131         assert_return(unit, -EINVAL);
 132
 133         r = getpeercred(fd, &ucred);
 134         if (r < 0)
 135                 return r;
 136
 137         return cg_pid_get_user_unit(ucred.pid, unit);
 138 }
 139
 140 _public_ int sd_peer_get_machine_name(int fd, char **machine) {
 141         struct ucred ucred;
 142         int r;
 143
 144         assert_return(fd >= 0, -EINVAL);
 145         assert_return(machine, -EINVAL);
 146
 147         r = getpeercred(fd, &ucred);
 148         if (r < 0)
 149                 return r;
 150
 151         return cg_pid_get_machine_name(ucred.pid, machine);
 152 }
 153
 154 _public_ int sd_peer_get_slice(int fd, char **slice) {
 155         struct ucred ucred;
 156         int r;
 157
 158         assert_return(fd >= 0, -EINVAL);
 159         assert_return(slice, -EINVAL);
 160
 161         r = getpeercred(fd, &ucred);
 162         if (r < 0)
 163                 return r;
 164
 165         return cg_pid_get_slice(ucred.pid, slice);
 166 }
 167
 168 _public_ int sd_uid_get_state(uid_t uid, char**state) {
 169         _cleanup_free_ char *p = NULL;
 170         char *s = NULL;
 171         int r;
 172
 173         assert_return(state, -EINVAL);
 174
 175         if (asprintf(&p, "/run/systemd/users/%lu", (unsigned long) uid) < 0)
 176                 return -ENOMEM;
 177
 178         r = parse_env_file(p, NEWLINE, "STATE", &s, NULL);
 179         if (r == -ENOENT) {
 180                 free(s);
 181                 s = strdup("offline");
 182                 if (!s)
 183                         return -ENOMEM;
 184
 185         } else if (r < 0) {
 186                 free(s);
 187                 return r;
 188         } else if (!s)
 189                 return -EIO;
 190
 191         *state = s;
 192         return 0;
 193 }
 194
 195 _public_ int sd_uid_is_on_seat(uid_t uid, int require_active, const char *seat) {
 196         char *w, *state;
 197         _cleanup_free_ char *t = NULL, *s = NULL, *p = NULL;
 198         size_t l;
 199         int r;
 200         const char *variable;
 201
 202         assert_return(seat, -EINVAL);
 203
 204         variable = require_active ? "ACTIVE_UID" : "UIDS";
 205
 206         p = strappend("/run/systemd/seats/", seat);
 207         if (!p)
 208                 return -ENOMEM;
 209
 210         r = parse_env_file(p, NEWLINE, variable, &s, NULL);
 211
 212         if (r < 0)
 213                 return r;
 214
 215         if (!s)
 216                 return -EIO;
 217
 218         if (asprintf(&t, "%lu", (unsigned long) uid) < 0)
 219                 return -ENOMEM;
 220
 221         FOREACH_WORD(w, l, s, state) {
 222                 if (strneq(t, w, l))
 223                         return 1;
 224         }
 225
 226         return 0;
 227 }
 228
 229 static int uid_get_array(uid_t uid, const char *variable, char ***array) {
 230         _cleanup_free_ char *p = NULL, *s = NULL;
 231         char **a;
 232         int r;
 233
 234         if (asprintf(&p, "/run/systemd/users/%lu", (unsigned long) uid) < 0)
 235                 return -ENOMEM;
 236
 237         r = parse_env_file(p, NEWLINE,
 238                            variable, &s,
 239                            NULL);
 240         if (r < 0) {
 241                 if (r == -ENOENT) {
 242                         if (array)
 243                                 *array = NULL;
 244                         return 0;
 245                 }
 246
 247                 return r;
 248         }
 249
 250         if (!s) {
 251                 if (array)
 252                         *array = NULL;
 253                 return 0;
 254         }
 255
 256         a = strv_split(s, " ");
 257
 258         if (!a)
 259                 return -ENOMEM;
 260
 261         strv_uniq(a);
 262         r = strv_length(a);
 263
 264         if (array)
 265                 *array = a;
 266         else
 267                 strv_free(a);
 268
 269         return r;
 270 }
 271
 272 _public_ int sd_uid_get_sessions(uid_t uid, int require_active, char ***sessions) {
 273         return uid_get_array(
 274                         uid,
 275                         require_active == 0 ? "ONLINE_SESSIONS" :
 276                         require_active > 0  ? "ACTIVE_SESSIONS" :
 277                                               "SESSIONS",
 278                         sessions);
 279 }
 280
 281 _public_ int sd_uid_get_seats(uid_t uid, int require_active, char ***seats) {
 282         return uid_get_array(
 283                         uid,
 284                         require_active == 0 ? "ONLINE_SEATS" :
 285                         require_active > 0  ? "ACTIVE_SEATS" :
 286                                               "SEATS",
 287                         seats);
 288 }
 289
 290 static int file_of_session(const char *session, char **_p) {
 291         char *p;
 292         int r;
 293
 294         assert(_p);
 295
 296         if (session) {
 297                 if (!session_id_valid(session))
 298                         return -EINVAL;
 299
 300                 p = strappend("/run/systemd/sessions/", session);
 301         } else {
 302                 _cleanup_free_ char *buf = NULL;
 303
 304                 r = sd_pid_get_session(0, &buf);
 305                 if (r < 0)
 306                         return r;
 307
 308                 p = strappend("/run/systemd/sessions/", buf);
 309         }
 310
 311         if (!p)
 312                 return -ENOMEM;
 313
 314         *_p = p;
 315         return 0;
 316 }
 317
 318 _public_ int sd_session_is_active(const char *session) {
 319         int r;
 320         _cleanup_free_ char *p = NULL, *s = NULL;
 321
 322         r = file_of_session(session, &p);
 323         if (r < 0)
 324                 return r;
 325
 326         r = parse_env_file(p, NEWLINE, "ACTIVE", &s, NULL);
 327         if (r < 0)
 328                 return r;
 329
 330         if (!s)
 331                 return -EIO;
 332
 333         return parse_boolean(s);
 334 }
 335
 336 _public_ int sd_session_is_remote(const char *session) {
 337         int r;
 338         _cleanup_free_ char *p = NULL, *s = NULL;
 339
 340         r = file_of_session(session, &p);
 341         if (r < 0)
 342                 return r;
 343
 344         r = parse_env_file(p, NEWLINE, "REMOTE", &s, NULL);
 345         if (r < 0)
 346                 return r;
 347
 348         if (!s)
 349                 return -EIO;
 350
 351         return parse_boolean(s);
 352 }
 353
 354 _public_ int sd_session_get_state(const char *session, char **state) {
 355         _cleanup_free_ char *p = NULL, *s = NULL;
 356         int r;
 357
 358         assert_return(state, -EINVAL);
 359
 360         r = file_of_session(session, &p);
 361         if (r < 0)
 362                 return r;
 363
 364         r = parse_env_file(p, NEWLINE, "STATE", &s, NULL);
 365
 366         if (r < 0)
 367                 return r;
 368         else if (!s)
 369                 return -EIO;
 370
 371         *state = s;
 372         s = NULL;
 373
 374         return 0;
 375 }
 376
 377 _public_ int sd_session_get_uid(const char *session, uid_t *uid) {
 378         int r;
 379         _cleanup_free_ char *p = NULL, *s = NULL;
 380
 381         assert_return(uid, -EINVAL);
 382
 383         r = file_of_session(session, &p);
 384         if (r < 0)
 385                 return r;
 386
 387         r = parse_env_file(p, NEWLINE, "UID", &s, NULL);
 388         if (r < 0)
 389                 return r;
 390
 391         if (!s)
 392                 return -EIO;
 393
 394         return parse_uid(s, uid);
 395 }
 396
 397 static int session_get_string(const char *session, const char *field, char **value) {
 398         _cleanup_free_ char *p = NULL, *s = NULL;
 399         int r;
 400
 401         assert_return(value, -EINVAL);
 402
 403         r = file_of_session(session, &p);
 404         if (r < 0)
 405                 return r;
 406
 407         r = parse_env_file(p, NEWLINE, field, &s, NULL);
 408
 409         if (r < 0)
 410                 return r;
 411
 412         if (isempty(s))
 413                 return -ENOENT;
 414
 415         *value = s;
 416         s = NULL;
 417         return 0;
 418 }
 419
 420 _public_ int sd_session_get_seat(const char *session, char **seat) {
 421         return session_get_string(session, "SEAT", seat);
 422 }
 423
 424 _public_ int sd_session_get_tty(const char *session, char **tty) {
 425         return session_get_string(session, "TTY", tty);
 426 }
 427
 428 _public_ int sd_session_get_vt(const char *session, unsigned *vtnr) {
 429         _cleanup_free_ char *vtnr_string = NULL;
 430         unsigned u;
 431         int r;
 432
 433         r = session_get_string(session, "VTNR", &vtnr_string);
 434         if (r < 0)
 435                 return r;
 436
 437         r = safe_atou(vtnr_string, &u);
 438         if (r < 0)
 439                 return r;
 440
 441         *vtnr = u;
 442         return 0;
 443 }
 444
 445 _public_ int sd_session_get_service(const char *session, char **service) {
 446         return session_get_string(session, "SERVICE", service);
 447 }
 448
 449 _public_ int sd_session_get_type(const char *session, char **type) {
 450         return session_get_string(session, "TYPE", type);
 451 }
 452
 453 _public_ int sd_session_get_class(const char *session, char **class) {
 454         return session_get_string(session, "CLASS", class);
 455 }
 456
 457 _public_ int sd_session_get_display(const char *session, char **display) {
 458         return session_get_string(session, "DISPLAY", display);
 459 }
 460
 461 _public_ int sd_session_get_remote_user(const char *session, char **remote_user) {
 462         return session_get_string(session, "REMOTE_USER", remote_user);
 463 }
 464
 465 _public_ int sd_session_get_remote_host(const char *session, char **remote_host) {
 466         return session_get_string(session, "REMOTE_HOST", remote_host);
 467 }
 468
 469 static int file_of_seat(const char *seat, char **_p) {
 470         char *p;
 471         int r;
 472
 473         assert(_p);
 474
 475         if (seat)
 476                 p = strappend("/run/systemd/seats/", seat);
 477         else {
 478                 _cleanup_free_ char *buf = NULL;
 479
 480                 r = sd_session_get_seat(NULL, &buf);
 481                 if (r < 0)
 482                         return r;
 483
 484                 p = strappend("/run/systemd/seats/", buf);
 485         }
 486
 487         if (!p)
 488                 return -ENOMEM;
 489
 490         *_p = p;
 491         p = NULL;
 492         return 0;
 493 }
 494
 495 _public_ int sd_seat_get_active(const char *seat, char **session, uid_t *uid) {
 496         _cleanup_free_ char *p = NULL, *s = NULL, *t = NULL;
 497         int r;
 498
 499         assert_return(session || uid, -EINVAL);
 500
 501         r = file_of_seat(seat, &p);
 502         if (r < 0)
 503                 return r;
 504
 505         r = parse_env_file(p, NEWLINE,
 506                            "ACTIVE", &s,
 507                            "ACTIVE_UID", &t,
 508                            NULL);
 509         if (r < 0)
 510                 return r;
 511
 512         if (session && !s)
 513                 return -ENOENT;
 514
 515         if (uid && !t)
 516                 return -ENOENT;
 517
 518         if (uid && t) {
 519                 r = parse_uid(t, uid);
 520                 if (r < 0)
 521                         return r;
 522         }
 523
 524         if (session && s) {
 525                 *session = s;
 526                 s = NULL;
 527         }
 528
 529         return 0;
 530 }
 531
 532 _public_ int sd_seat_get_sessions(const char *seat, char ***sessions, uid_t **uids, unsigned *n_uids) {
 533         _cleanup_free_ char *p = NULL, *s = NULL, *t = NULL;
 534         _cleanup_strv_free_ char **a = NULL;
 535         _cleanup_free_ uid_t *b = NULL;
 536         unsigned n = 0;
 537         int r;
 538
 539         r = file_of_seat(seat, &p);
 540         if (r < 0)
 541                 return r;
 542
 543         r = parse_env_file(p, NEWLINE,
 544                            "SESSIONS", &s,
 545                            "ACTIVE_SESSIONS", &t,
 546                            NULL);
 547
 548         if (r < 0)
 549                 return r;
 550
 551         if (s) {
 552                 a = strv_split(s, " ");
 553                 if (!a)
 554                         return -ENOMEM;
 555         }
 556
 557         if (uids && t) {
 558                 char *w, *state;
 559                 size_t l;
 560
 561                 FOREACH_WORD(w, l, t, state)
 562                         n++;
 563
 564                 if (n > 0) {
 565                         unsigned i = 0;
 566
 567                         b = new(uid_t, n);
 568                         if (!b)
 569                                 return -ENOMEM;
 570
 571                         FOREACH_WORD(w, l, t, state) {
 572                                 _cleanup_free_ char *k = NULL;
 573
 574                                 k = strndup(w, l);
 575                                 if (!k)
 576                                         return -ENOMEM;
 577
 578                                 r = parse_uid(k, b + i);
 579
 580                                 if (r < 0)
 581                                         continue;
 582
 583                                 i++;
 584                         }
 585                 }
 586         }
 587
 588         r = strv_length(a);
 589
 590         if (sessions) {
 591                 *sessions = a;
 592                 a = NULL;
 593         }
 594
 595         if (uids) {
 596                 *uids = b;
 597                 b = NULL;
 598         }
 599
 600         if (n_uids)
 601                 *n_uids = n;
 602
 603         return r;
 604 }
 605
 606 static int seat_get_can(const char *seat, const char *variable) {
 607         _cleanup_free_ char *p = NULL, *s = NULL;
 608         int r;
 609
 610         assert_return(variable, -EINVAL);
 611
 612         r = file_of_seat(seat, &p);
 613         if (r < 0)
 614                 return r;
 615
 616         r = parse_env_file(p, NEWLINE,
 617                            variable, &s,
 618                            NULL);
 619         if (r < 0)
 620                 return r;
 621         if (!s)
 622                 return 0;
 623
 624         return parse_boolean(s);
 625 }
 626
 627 _public_ int sd_seat_can_multi_session(const char *seat) {
 628         return seat_get_can(seat, "CAN_MULTI_SESSION");
 629 }
 630
 631 _public_ int sd_seat_can_tty(const char *seat) {
 632         return seat_get_can(seat, "CAN_TTY");
 633 }
 634
 635 _public_ int sd_seat_can_graphical(const char *seat) {
 636         return seat_get_can(seat, "CAN_GRAPHICAL");
 637 }
 638
 639 _public_ int sd_get_seats(char ***seats) {
 640         return get_files_in_directory("/run/systemd/seats/", seats);
 641 }
 642
 643 _public_ int sd_get_sessions(char ***sessions) {
 644         return get_files_in_directory("/run/systemd/sessions/", sessions);
 645 }
 646
 647 _public_ int sd_get_uids(uid_t **users) {
 648         _cleanup_closedir_ DIR *d;
 649         int r = 0;
 650         unsigned n = 0;
 651         _cleanup_free_ uid_t *l = NULL;
 652
 653         d = opendir("/run/systemd/users/");
 654         if (!d)
 655                 return -errno;
 656
 657         for (;;) {
 658                 struct dirent *de;
 659                 int k;
 660                 uid_t uid;
 661
 662                 errno = 0;
 663                 de = readdir(d);
 664                 if (!de && errno != 0)
 665                         return -errno;
 666
 667                 if (!de)
 668                         break;
 669
 670                 dirent_ensure_type(d, de);
 671
 672                 if (!dirent_is_file(de))
 673                         continue;
 674
 675                 k = parse_uid(de->d_name, &uid);
 676                 if (k < 0)
 677                         continue;
 678
 679                 if (users) {
 680                         if ((unsigned) r >= n) {
 681                                 uid_t *t;
 682
 683                                 n = MAX(16, 2*r);
 684                                 t = realloc(l, sizeof(uid_t) * n);
 685                                 if (!t)
 686                                         return -ENOMEM;
 687
 688                                 l = t;
 689                         }
 690
 691                         assert((unsigned) r < n);
 692                         l[r++] = uid;
 693                 } else
 694                         r++;
 695         }
 696
 697         if (users) {
 698                 *users = l;
 699                 l = NULL;
 700         }
 701
 702         return r;
 703 }
 704
 705 _public_ int sd_get_machine_names(char ***machines) {
 706         char **l = NULL, **a, **b;
 707         int r;
 708
 709         assert_return(machines, -EINVAL);
 710
 711         r = get_files_in_directory("/run/systemd/machines/", &l);
 712         if (r < 0)
 713                 return r;
 714
 715         if (l) {
 716                 r = 0;
 717
 718                 /* Filter out the unit: symlinks */
 719                 for (a = l, b = l; *a; a++) {
 720                         if (startswith(*a, "unit:"))
 721                                 free(*a);
 722                         else {
 723                                 *b = *a;
 724                                 b++;
 725                                 r++;
 726                         }
 727                 }
 728
 729                 *b = NULL;
 730         }
 731
 732         *machines = l;
 733         return r;
 734 }
 735
 736 _public_ int sd_machine_get_class(const char *machine, char **class) {
 737         _cleanup_free_ char *c = NULL;
 738         const char *p;
 739         int r;
 740
 741         assert_return(filename_is_safe(machine), -EINVAL);
 742         assert_return(class, -EINVAL);
 743
 744         p = strappenda("/run/systemd/machines/", machine);
 745         r = parse_env_file(p, NEWLINE, "CLASS", &c, NULL);
 746         if (r < 0)
 747                 return r;
 748         if (!c)
 749                 return -EIO;
 750
 751         *class = c;
 752         c = NULL;
 753
 754         return 0;
 755 }
 756
 757 static inline int MONITOR_TO_FD(sd_login_monitor *m) {
 758         return (int) (unsigned long) m - 1;
 759 }
 760
 761 static inline sd_login_monitor* FD_TO_MONITOR(int fd) {
 762         return (sd_login_monitor*) (unsigned long) (fd + 1);
 763 }
 764
 765 _public_ int sd_login_monitor_new(const char *category, sd_login_monitor **m) {
 766         int fd, k;
 767         bool good = false;
 768
 769         assert_return(m, -EINVAL);
 770
 771         fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC);
 772         if (fd < 0)
 773                 return -errno;
 774
 775         if (!category || streq(category, "seat")) {
 776                 k = inotify_add_watch(fd, "/run/systemd/seats/", IN_MOVED_TO|IN_DELETE);
 777                 if (k < 0) {
 778                         safe_close(fd);
 779                         return -errno;
 780                 }
 781
 782                 good = true;
 783         }
 784
 785         if (!category || streq(category, "session")) {
 786                 k = inotify_add_watch(fd, "/run/systemd/sessions/", IN_MOVED_TO|IN_DELETE);
 787                 if (k < 0) {
 788                         safe_close(fd);
 789                         return -errno;
 790                 }
 791
 792                 good = true;
 793         }
 794
 795         if (!category || streq(category, "uid")) {
 796                 k = inotify_add_watch(fd, "/run/systemd/users/", IN_MOVED_TO|IN_DELETE);
 797                 if (k < 0) {
 798                         safe_close(fd);
 799                         return -errno;
 800                 }
 801
 802                 good = true;
 803         }
 804
 805         if (!category || streq(category, "machine")) {
 806                 k = inotify_add_watch(fd, "/run/systemd/machines/", IN_MOVED_TO|IN_DELETE);
 807                 if (k < 0) {
 808                         safe_close(fd);
 809                         return -errno;
 810                 }
 811
 812                 good = true;
 813         }
 814
 815         if (!good) {
 816                 close_nointr(fd);
 817                 return -EINVAL;
 818         }
 819
 820         *m = FD_TO_MONITOR(fd);
 821         return 0;
 822 }
 823
 824 _public_ sd_login_monitor* sd_login_monitor_unref(sd_login_monitor *m) {
 825         int fd;
 826
 827         assert_return(m, NULL);
 828
 829         fd = MONITOR_TO_FD(m);
 830         close_nointr(fd);
 831
 832         return NULL;
 833 }
 834
 835 _public_ int sd_login_monitor_flush(sd_login_monitor *m) {
 836
 837         assert_return(m, -EINVAL);
 838
 839         return flush_fd(MONITOR_TO_FD(m));
 840 }
 841
 842 _public_ int sd_login_monitor_get_fd(sd_login_monitor *m) {
 843
 844         assert_return(m, -EINVAL);
 845
 846         return MONITOR_TO_FD(m);
 847 }
 848
 849 _public_ int sd_login_monitor_get_events(sd_login_monitor *m) {
 850
 851         assert_return(m, -EINVAL);
 852
 853         /* For now we will only return POLLIN here, since we don't
 854          * need anything else ever for inotify.  However, let's have
 855          * this API to keep our options open should we later on need
 856          * it. */
 857         return POLLIN;
 858 }
 859
 860 _public_ int sd_login_monitor_get_timeout(sd_login_monitor *m, uint64_t *timeout_usec) {
 861
 862         assert_return(m, -EINVAL);
 863         assert_return(timeout_usec, -EINVAL);
 864
 865         /* For now we will only return (uint64_t) -1, since we don't
 866          * need any timeout. However, let's have this API to keep our
 867          * options open should we later on need it. */
 868         *timeout_usec = (uint64_t) -1;
 869         return 0;
 870 }