← Back to branch summary

~stgraber/ubuntu/trusty/systemd/logind-cgroup-controllers

« back to all changes in this revision

Viewing changes to .pc/0025-login-monitor-no-machine.patch/src/login/sd-login.c

  • Committer: Package Import Robot
  • Author(s): Martin Pitt
  • Date: 2013-07-19 09:45:54 UTC
  • Revision ID: package-import@ubuntu.com-20130719094554-oca4p9kxgazhn0ts
Tags: 204-0ubuntu6
https://launchpad.net/bugs/1202700
https://launchpad.net/bugs/1201180
* debian/rules: Drop /system/firmware and /vendor/firmware paths again, we
  don't currently need them.
* debian/extra/initramfs.top: Drop the $ROOTDELAY sleep, we already do that
  in a more sensible way in wait-for-root. (LP: #1202700)
* Add debian/tests/api: Add check for sd_login_monitor_*(), to reproduce
  LP #1201180.
* Add 0025-login-monitor-no-machine.patch: Fix sd_login_monitor_new() to not
  fail if there is no /sys/fs/cgroup/systemd/machine; that only exists when
  running with systemd as PID 1. (LP: #1201180)
* debian/tests/logind: Create /run/udev/rules.d if it does not exist.
* Switch from pre-generated hwdb database to shipping the source files
  (/lib/udev/hwdb.d/) and building hwdb.bin in postinst and with a trigger.
  Upstream software like libgphoto, libsane, and media-player-info will ship
  their own hwdb files soon, so be prepared for that.

Show diffs side-by-side

added added

removed removed

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