[systemd.git] / src / login / logind-core.c

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright 2011 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <pwd.h>
#include <unistd.h>
#include <linux/vt.h>

#include "logind.h"
#include "dbus-common.h"
#include "strv.h"

int manager_add_device(Manager *m, const char *sysfs, bool master, Device **_device) {
        Device *d;

        assert(m);
        assert(sysfs);

        d = hashmap_get(m->devices, sysfs);
        if (d) {
                if (_device)
                        *_device = d;

                /* we support adding master-flags, but not removing them */
                d->master = d->master || master;

                return 0;
        }

        d = device_new(m, sysfs, master);
        if (!d)
                return -ENOMEM;

        if (_device)
                *_device = d;

        return 0;
}

int manager_add_seat(Manager *m, const char *id, Seat **_seat) {
        Seat *s;

        assert(m);
        assert(id);

        s = hashmap_get(m->seats, id);
        if (s) {
                if (_seat)
                        *_seat = s;

                return 0;
        }

        s = seat_new(m, id);
        if (!s)
                return -ENOMEM;

        if (_seat)
                *_seat = s;

        return 0;
}

int manager_add_session(Manager *m, const char *id, Session **_session) {
        Session *s;

        assert(m);
        assert(id);

        s = hashmap_get(m->sessions, id);
        if (s) {
                if (_session)
                        *_session = s;

                return 0;
        }

        s = session_new(m, id);
        if (!s)
                return -ENOMEM;

        if (_session)
                *_session = s;

        return 0;
}

int manager_add_user(Manager *m, uid_t uid, gid_t gid, const char *name, User **_user) {
        User *u;

        assert(m);
        assert(name);

        u = hashmap_get(m->users, ULONG_TO_PTR((unsigned long) uid));
        if (u) {
                if (_user)
                        *_user = u;

                return 0;
        }

        u = user_new(m, uid, gid, name);
        if (!u)
                return -ENOMEM;

        if (_user)
                *_user = u;

        return 0;
}

int manager_add_user_by_name(Manager *m, const char *name, User **_user) {
        uid_t uid;
        gid_t gid;
        int r;

        assert(m);
        assert(name);

        r = get_user_creds(&name, &uid, &gid, NULL, NULL);
        if (r < 0)
                return r;

        return manager_add_user(m, uid, gid, name, _user);
}

int manager_add_user_by_uid(Manager *m, uid_t uid, User **_user) {
        struct passwd *p;

        assert(m);

        errno = 0;
        p = getpwuid(uid);
        if (!p)
                return errno ? -errno : -ENOENT;

        return manager_add_user(m, uid, p->pw_gid, p->pw_name, _user);
}

int manager_add_inhibitor(Manager *m, const char* id, Inhibitor **_inhibitor) {
        Inhibitor *i;

        assert(m);
        assert(id);

        i = hashmap_get(m->inhibitors, id);
        if (i) {
                if (_inhibitor)
                        *_inhibitor = i;

                return 0;
        }

        i = inhibitor_new(m, id);
        if (!i)
                return -ENOMEM;

        if (_inhibitor)
                *_inhibitor = i;

        return 0;
}

int manager_add_button(Manager *m, const char *name, Button **_button) {
        Button *b;

        assert(m);
        assert(name);

        b = hashmap_get(m->buttons, name);
        if (b) {
                if (_button)
                        *_button = b;

                return 0;
        }

        b = button_new(m, name);
        if (!b)
                return -ENOMEM;

        if (_button)
                *_button = b;

        return 0;
}

int manager_watch_busname(Manager *m, const char *name) {
        char *n;
        int r;

        assert(m);
        assert(name);

        if (hashmap_get(m->busnames, name))
                return 0;

        n = strdup(name);
        if (!n)
                return -ENOMEM;

        r = hashmap_put(m->busnames, n, n);
        if (r < 0) {
                free(n);
                return r;
        }

        return 0;
}

void manager_drop_busname(Manager *m, const char *name) {
        Session *session;
        Iterator i;
        char *key;

        assert(m);
        assert(name);

        if (!hashmap_get(m->busnames, name))
                return;

        /* keep it if the name still owns a controller */
        HASHMAP_FOREACH(session, m->sessions, i)
                if (session_is_controller(session, name))
                        return;

        key = hashmap_remove(m->busnames, name);
        if (key)
                free(key);
}

int manager_process_seat_device(Manager *m, struct udev_device *d) {
        Device *device;
        int r;

        assert(m);

        if (streq_ptr(udev_device_get_action(d), "remove")) {

                device = hashmap_get(m->devices, udev_device_get_syspath(d));
                if (!device)
                        return 0;

                seat_add_to_gc_queue(device->seat);
                device_free(device);

        } else {
                const char *sn;
                Seat *seat = NULL;
                bool master;

                sn = udev_device_get_property_value(d, "ID_SEAT");
                if (isempty(sn))
                        sn = "seat0";

                if (!seat_name_is_valid(sn)) {
                        log_warning("Device with invalid seat name %s found, ignoring.", sn);
                        return 0;
                }

                /* ignore non-master devices for unknown seats */
                master = udev_device_has_tag(d, "master-of-seat");
                if (!master && !(seat = hashmap_get(m->seats, sn)))
                        return 0;

                r = manager_add_device(m, udev_device_get_syspath(d), master, &device);
                if (r < 0)
                        return r;

                if (!seat) {
                        r = manager_add_seat(m, sn, &seat);
                        if (r < 0) {
                                if (!device->seat)
                                        device_free(device);

                                return r;
                        }
                }

                device_attach(device, seat);
                seat_start(seat);
        }

        return 0;
}

int manager_process_button_device(Manager *m, struct udev_device *d) {
        Button *b;

        int r;

        assert(m);

        if (streq_ptr(udev_device_get_action(d), "remove")) {

                b = hashmap_get(m->buttons, udev_device_get_sysname(d));
                if (!b)
                        return 0;

                button_free(b);

        } else {
                const char *sn;

                r = manager_add_button(m, udev_device_get_sysname(d), &b);
                if (r < 0)
                        return r;

                sn = udev_device_get_property_value(d, "ID_SEAT");
                if (isempty(sn))
                        sn = "seat0";

                button_set_seat(b, sn);
                button_open(b);
        }

        return 0;
}

int manager_get_session_by_pid(Manager *m, pid_t pid, Session **session) {
        _cleanup_free_ char *unit = NULL;
        Session *s;
        int r;

        assert(m);
        assert(session);

        if (pid < 1)
                return -EINVAL;

        r = cg_pid_get_unit(pid, &unit);
        if (r < 0)
                return r;

        s = hashmap_get(m->session_units, unit);
        if (!s)
                return 0;

        *session = s;
        return 1;
}

int manager_get_user_by_pid(Manager *m, pid_t pid, User **user) {
        _cleanup_free_ char *unit = NULL;
        User *u;
        int r;

        assert(m);
        assert(user);

        if (pid < 1)
                return -EINVAL;

        r = cg_pid_get_slice(pid, &unit);
        if (r < 0)
                return r;

        u = hashmap_get(m->user_units, unit);
        if (!u)
                return 0;

        *user = u;
        return 1;
}

int manager_get_idle_hint(Manager *m, dual_timestamp *t) {
        Session *s;
        bool idle_hint;
        dual_timestamp ts = { 0, 0 };
        Iterator i;

        assert(m);

        idle_hint = !manager_is_inhibited(m, INHIBIT_IDLE, INHIBIT_BLOCK, t, false, false, 0);

        HASHMAP_FOREACH(s, m->sessions, i) {
                dual_timestamp k;
                int ih;

                ih = session_get_idle_hint(s, &k);
                if (ih < 0)
                        return ih;

                if (!ih) {
                        if (!idle_hint) {
                                if (k.monotonic < ts.monotonic)
                                        ts = k;
                        } else {
                                idle_hint = false;
                                ts = k;
                        }
                } else if (idle_hint) {

                        if (k.monotonic > ts.monotonic)
                                ts = k;
                }
        }

        if (t)
                *t = ts;

        return idle_hint;
}

bool manager_shall_kill(Manager *m, const char *user) {
        assert(m);
        assert(user);

        if (!m->kill_user_processes)
                return false;

        if (strv_contains(m->kill_exclude_users, user))
                return false;

        if (strv_isempty(m->kill_only_users))
                return true;

        return strv_contains(m->kill_only_users, user);
}

static int vt_is_busy(int vtnr) {
        struct vt_stat vt_stat;
        int r = 0, fd;

        assert(vtnr >= 1);

        /* We explicitly open /dev/tty1 here instead of /dev/tty0. If
         * we'd open the latter we'd open the foreground tty which
         * hence would be unconditionally busy. By opening /dev/tty1
         * we avoid this. Since tty1 is special and needs to be an
         * explicitly loaded getty or DM this is safe. */

        fd = open_terminal("/dev/tty1", O_RDWR|O_NOCTTY|O_CLOEXEC);
        if (fd < 0)
                return -errno;

        if (ioctl(fd, VT_GETSTATE, &vt_stat) < 0)
                r = -errno;
        else
                r = !!(vt_stat.v_state & (1 << vtnr));

        close_nointr_nofail(fd);

        return r;
}

int manager_spawn_autovt(Manager *m, int vtnr) {
        int r;
        char *name = NULL;
        const char *mode = "fail";

        assert(m);
        assert(vtnr >= 1);

        if ((unsigned) vtnr > m->n_autovts &&
            (unsigned) vtnr != m->reserve_vt)
                return 0;

        if ((unsigned) vtnr != m->reserve_vt) {
                /* If this is the reserved TTY, we'll start the getty
                 * on it in any case, but otherwise only if it is not
                 * busy. */

                r = vt_is_busy(vtnr);
                if (r < 0)
                        return r;
                else if (r > 0)
                        return -EBUSY;
        }

        if (asprintf(&name, "autovt@tty%i.service", vtnr) < 0) {
                log_error("Could not allocate service name.");
                r = -ENOMEM;
                goto finish;
        }

        r = bus_method_call_with_reply (
                        m->bus,
                        "org.freedesktop.systemd1",
                        "/org/freedesktop/systemd1",
                        "org.freedesktop.systemd1.Manager",
                        "StartUnit",
                        NULL,
                        NULL,
                        DBUS_TYPE_STRING, &name,
                        DBUS_TYPE_STRING, &mode,
                        DBUS_TYPE_INVALID);

finish:
        free(name);

        return r;
}
Commit	Line	Data
14228c0d MB	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 <sys/types.h>
	23	#include <sys/stat.h>
	24	#include <sys/ioctl.h>
	25	#include <fcntl.h>
	26	#include <pwd.h>
	27	#include <unistd.h>
	28	#include <linux/vt.h>
	29
	30	#include "logind.h"
	31	#include "dbus-common.h"
	32	#include "strv.h"
	33
	34	int manager_add_device(Manager m, const char sysfs, bool master, Device **_device) {
	35	Device *d;
	36
	37	assert(m);
	38	assert(sysfs);
	39
	40	d = hashmap_get(m->devices, sysfs);
	41	if (d) {
	42	if (_device)
	43	*_device = d;
	44
	45	/* we support adding master-flags, but not removing them */
	46	d->master = d->master \|\| master;
	47
	48	return 0;
	49	}
	50
	51	d = device_new(m, sysfs, master);
	52	if (!d)
	53	return -ENOMEM;
	54
	55	if (_device)
	56	*_device = d;
	57
	58	return 0;
	59	}
	60
	61	int manager_add_seat(Manager m, const char id, Seat **_seat) {
	62	Seat *s;
	63
	64	assert(m);
65	assert(id);
66
67	s = hashmap_get(m->seats, id);
68	if (s) {
69	if (_seat)
70	*_seat = s;
71
72	return 0;
73	}
74
75	s = seat_new(m, id);
76	if (!s)
77	return -ENOMEM;
78
79	if (_seat)
80	*_seat = s;
81
82	return 0;
83	}
84
85	int manager_add_session(Manager m, const char id, Session **_session) {
86	Session *s;
87
88	assert(m);
89	assert(id);
90
91	s = hashmap_get(m->sessions, id);
92	if (s) {
93	if (_session)
94	*_session = s;
95
96	return 0;
97	}
98
99	s = session_new(m, id);
100	if (!s)
101	return -ENOMEM;
102
103	if (_session)
104	*_session = s;
105
106	return 0;
107	}
108
109	int manager_add_user(Manager m, uid_t uid, gid_t gid, const char name, User **_user) {
110	User *u;
111
112	assert(m);
113	assert(name);
114
115	u = hashmap_get(m->users, ULONG_TO_PTR((unsigned long) uid));
116	if (u) {
117	if (_user)
118	*_user = u;
119
120	return 0;
121	}
122
123	u = user_new(m, uid, gid, name);
124	if (!u)
125	return -ENOMEM;
126
127	if (_user)
128	*_user = u;
129
130	return 0;
131	}
132
133	int manager_add_user_by_name(Manager m, const char name, User **_user) {
134	uid_t uid;
135	gid_t gid;
136	int r;
137
138	assert(m);
139	assert(name);
140
141	r = get_user_creds(&name, &uid, &gid, NULL, NULL);
142	if (r < 0)
143	return r;
144
145	return manager_add_user(m, uid, gid, name, _user);
146	}
147
148	int manager_add_user_by_uid(Manager m, uid_t uid, User *_user) {
149	struct passwd *p;
150
151	assert(m);
152
153	errno = 0;
154	p = getpwuid(uid);
155	if (!p)
156	return errno ? -errno : -ENOENT;
157
158	return manager_add_user(m, uid, p->pw_gid, p->pw_name, _user);
159	}
160
161	int manager_add_inhibitor(Manager m, const char id, Inhibitor **_inhibitor) {
162	Inhibitor *i;
163
164	assert(m);
165	assert(id);
166
167	i = hashmap_get(m->inhibitors, id);
168	if (i) {
169	if (_inhibitor)
170	*_inhibitor = i;
171
172	return 0;
173	}
174
175	i = inhibitor_new(m, id);
176	if (!i)
177	return -ENOMEM;
178
179	if (_inhibitor)
180	*_inhibitor = i;
181
182	return 0;
183	}
184
185	int manager_add_button(Manager m, const char name, Button **_button) {
186	Button *b;
187
188	assert(m);
189	assert(name);
190
191	b = hashmap_get(m->buttons, name);
192	if (b) {
193	if (_button)
194	*_button = b;
195
196	return 0;
197	}
198
199	b = button_new(m, name);
200	if (!b)
201	return -ENOMEM;
202
203	if (_button)
204	*_button = b;
205
206	return 0;
207	}
208
209	int manager_watch_busname(Manager m, const char name) {
210	char *n;
211	int r;
212
213	assert(m);
214	assert(name);
215
216	if (hashmap_get(m->busnames, name))
217	return 0;
218
219	n = strdup(name);
220	if (!n)
221	return -ENOMEM;
222
223	r = hashmap_put(m->busnames, n, n);
224	if (r < 0) {
225	free(n);
226	return r;
227	}
228
229	return 0;
230	}
231
232	void manager_drop_busname(Manager m, const char name) {
233	Session *session;
234	Iterator i;
235	char *key;
236
237	assert(m);
238	assert(name);
239
240	if (!hashmap_get(m->busnames, name))
241	return;
242
243	/* keep it if the name still owns a controller */
244	HASHMAP_FOREACH(session, m->sessions, i)
245	if (session_is_controller(session, name))
246	return;
247
248	key = hashmap_remove(m->busnames, name);
249	if (key)
250	free(key);
251	}
252
253	int manager_process_seat_device(Manager m, struct udev_device d) {
254	Device *device;
255	int r;
256
257	assert(m);
258
259	if (streq_ptr(udev_device_get_action(d), "remove")) {
260
261	device = hashmap_get(m->devices, udev_device_get_syspath(d));
262	if (!device)
263	return 0;
264
265	seat_add_to_gc_queue(device->seat);
266	device_free(device);
267
268	} else {
269	const char *sn;
270	Seat *seat = NULL;
271	bool master;
272
273	sn = udev_device_get_property_value(d, "ID_SEAT");
274	if (isempty(sn))
275	sn = "seat0";
276
277	if (!seat_name_is_valid(sn)) {
278	log_warning("Device with invalid seat name %s found, ignoring.", sn);
279	return 0;
280	}
281
282	/* ignore non-master devices for unknown seats */
283	master = udev_device_has_tag(d, "master-of-seat");
284	if (!master && !(seat = hashmap_get(m->seats, sn)))
285	return 0;
286
287	r = manager_add_device(m, udev_device_get_syspath(d), master, &device);
288	if (r < 0)
289	return r;
290
291	if (!seat) {
292	r = manager_add_seat(m, sn, &seat);
293	if (r < 0) {
294	if (!device->seat)
295	device_free(device);
296
297	return r;
298	}
299	}
300
301	device_attach(device, seat);
302	seat_start(seat);
303	}
304
305	return 0;
306	}
307
308	int manager_process_button_device(Manager m, struct udev_device d) {
309	Button *b;
310
311	int r;
312
313	assert(m);
314
315	if (streq_ptr(udev_device_get_action(d), "remove")) {
316
317	b = hashmap_get(m->buttons, udev_device_get_sysname(d));
318	if (!b)
319	return 0;
320
321	button_free(b);
322
323	} else {
324	const char *sn;
325
326	r = manager_add_button(m, udev_device_get_sysname(d), &b);
327	if (r < 0)
328	return r;
329
330	sn = udev_device_get_property_value(d, "ID_SEAT");
331	if (isempty(sn))
332	sn = "seat0";
333
334	button_set_seat(b, sn);
335	button_open(b);
336	}
337
338	return 0;
339	}
340
341	int manager_get_session_by_pid(Manager m, pid_t pid, Session *session) {
342	_cleanup_free_ char *unit = NULL;
343	Session *s;
344	int r;
345
346	assert(m);
347	assert(session);
348
349	if (pid < 1)
350	return -EINVAL;
351
352	r = cg_pid_get_unit(pid, &unit);
353	if (r < 0)
354	return r;
355
356	s = hashmap_get(m->session_units, unit);
357	if (!s)
358	return 0;
359
360	*session = s;
361	return 1;
362	}
363
364	int manager_get_user_by_pid(Manager m, pid_t pid, User *user) {
365	_cleanup_free_ char *unit = NULL;
366	User *u;
367	int r;
368
369	assert(m);
370	assert(user);
371
372	if (pid < 1)
373	return -EINVAL;
374
375	r = cg_pid_get_slice(pid, &unit);
376	if (r < 0)
377	return r;
378
379	u = hashmap_get(m->user_units, unit);
380	if (!u)
381	return 0;
382
383	*user = u;
384	return 1;
385	}
386
387	int manager_get_idle_hint(Manager m, dual_timestamp t) {
388	Session *s;
389	bool idle_hint;
390	dual_timestamp ts = { 0, 0 };
391	Iterator i;
392
393	assert(m);
394
395	idle_hint = !manager_is_inhibited(m, INHIBIT_IDLE, INHIBIT_BLOCK, t, false, false, 0);
396
397	HASHMAP_FOREACH(s, m->sessions, i) {
398	dual_timestamp k;
399	int ih;
400
401	ih = session_get_idle_hint(s, &k);
402	if (ih < 0)
403	return ih;
404
405	if (!ih) {
406	if (!idle_hint) {
407	if (k.monotonic < ts.monotonic)
408	ts = k;
409	} else {
410	idle_hint = false;
411	ts = k;
412	}
413	} else if (idle_hint) {
414
415	if (k.monotonic > ts.monotonic)
416	ts = k;
417	}
418	}
419
420	if (t)
421	*t = ts;
422
423	return idle_hint;
424	}
425
426	bool manager_shall_kill(Manager m, const char user) {
427	assert(m);
428	assert(user);
429
430	if (!m->kill_user_processes)
431	return false;
432
433	if (strv_contains(m->kill_exclude_users, user))
434	return false;
435
436	if (strv_isempty(m->kill_only_users))
437	return true;
438
439	return strv_contains(m->kill_only_users, user);
440	}
441
442	static int vt_is_busy(int vtnr) {
443	struct vt_stat vt_stat;
444	int r = 0, fd;
445
446	assert(vtnr >= 1);
447
448	/* We explicitly open /dev/tty1 here instead of /dev/tty0. If
449	* we'd open the latter we'd open the foreground tty which
450	* hence would be unconditionally busy. By opening /dev/tty1
451	* we avoid this. Since tty1 is special and needs to be an
452	* explicitly loaded getty or DM this is safe. */
453
454	fd = open_terminal("/dev/tty1", O_RDWR\|O_NOCTTY\|O_CLOEXEC);
455	if (fd < 0)
456	return -errno;
457
458	if (ioctl(fd, VT_GETSTATE, &vt_stat) < 0)
459	r = -errno;
460	else
461	r = !!(vt_stat.v_state & (1 << vtnr));
462
463	close_nointr_nofail(fd);
464
465	return r;
466	}
467
468	int manager_spawn_autovt(Manager *m, int vtnr) {
469	int r;
470	char *name = NULL;
471	const char *mode = "fail";
472
473	assert(m);
474	assert(vtnr >= 1);
475
476	if ((unsigned) vtnr > m->n_autovts &&
477	(unsigned) vtnr != m->reserve_vt)
478	return 0;
479
480	if ((unsigned) vtnr != m->reserve_vt) {
481	/* If this is the reserved TTY, we'll start the getty
482	* on it in any case, but otherwise only if it is not
483	* busy. */
484
485	r = vt_is_busy(vtnr);
486	if (r < 0)
487	return r;
488	else if (r > 0)
489	return -EBUSY;
490	}
491
492	if (asprintf(&name, "autovt@tty%i.service", vtnr) < 0) {
493	log_error("Could not allocate service name.");
494	r = -ENOMEM;
495	goto finish;
496	}
497
498	r = bus_method_call_with_reply (
499	m->bus,
500	"org.freedesktop.systemd1",
501	"/org/freedesktop/systemd1",
502	"org.freedesktop.systemd1.Manager",
503	"StartUnit",
504	NULL,
505	NULL,
506	DBUS_TYPE_STRING, &name,
507	DBUS_TYPE_STRING, &mode,
508	DBUS_TYPE_INVALID);
509
510	finish:
511	free(name);
512
513	return r;
514	}