[thirdparty/systemd.git] / src / logind-user.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 General Public License as published by
  the Free Software Foundation; either version 2 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
  General Public License for more details.

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

#include <string.h>
#include <unistd.h>
#include <errno.h>

#include "logind.h"
#include "util.h"
#include "cgroup-util.h"
#include "hashmap.h"
#include "strv.h"

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

        assert(m);
        assert(name);

        u = new(User, 1);
        if (!u)
                return NULL;

        u->name = strdup(name);
        if (!u->name) {
                free(u);
                return NULL;
        }

        if (asprintf(&u->state_file, "/run/systemd/user/%lu", (unsigned long) uid) < 0) {
                free(u->name);
                free(u);
                return NULL;
        }

        if (hashmap_put(m->users, ULONG_TO_PTR((unsigned long) uid), u) < 0) {
                free(u->state_file);
                free(u->name);
                free(u);
                return NULL;
        }

        u->manager = m;
        u->uid = uid;
        u->gid = gid;

        return u;
}

void user_free(User *u) {
        assert(u);

        while (u->sessions)
                session_free(u->sessions);

        free(u->cgroup_path);

        free(u->service);
        free(u->runtime_path);

        hashmap_remove(u->manager->users, ULONG_TO_PTR((unsigned long) u->uid));

        free(u->name);
        free(u->state_file);
        free(u);
}

int user_save(User *u) {
        FILE *f;
        int r;

        assert(u);
        assert(u->state_file);

        r = safe_mkdir("/run/systemd/user", 0755, 0, 0);
        if (r < 0)
                return r;

        f = fopen(u->state_file, "we");
        if (!f)
                return -errno;

        fprintf(f,
                "NAME=%s\n"
                "STATE=%s\n",
                u->name,
                user_state_to_string(user_get_state(u)));

        if (u->cgroup_path)
                fprintf(f,
                        "CGROUP=%s\n",
                        u->cgroup_path);

        if (u->runtime_path)
                fprintf(f,
                        "RUNTIME=%s\n",
                        u->runtime_path);

        if (u->service)
                fprintf(f,
                        "SERVICE=%s\n",
                        u->service);

        if (u->display)
                fprintf(f,
                        "DISPLAY=%s\n",
                        u->display->id);

        fflush(f);
        if (ferror(f)) {
                r = -errno;
                unlink(u->state_file);
        }

        fclose(f);
        return r;
}

int user_load(User *u) {
        int r;
        char *display = NULL;
        Session *s;

        assert(u);

        r = parse_env_file(u->state_file, "r",
                           "CGROUP", &u->cgroup_path,
                           "RUNTIME", &u->runtime_path,
                           "SERVICE", &u->service,
                           "DISPLAY", &display,
                           NULL);
        if (r < 0) {
                free(display);

                if (r == -ENOENT)
                        return 0;

                log_error("Failed to read %s: %s", u->state_file, strerror(-r));
                return r;
        }

        s = hashmap_get(u->manager->sessions, display);
        free(display);

        if (s && s->display && x11_display_is_local(s->display))
                u->display = s;

        return r;
}

static int user_mkdir_runtime_path(User *u) {
        char *p;
        int r;

        assert(u);

        r = safe_mkdir("/run/user", 0755, 0, 0);
        if (r < 0) {
                log_error("Failed to create /run/user: %s", strerror(-r));
                return r;
        }

        if (!u->runtime_path) {
                p = strappend("/run/user/", u->name);

                if (!p) {
                        log_error("Out of memory");
                        return -ENOMEM;
                }
        } else
                p = u->runtime_path;

        r = safe_mkdir(p, 0700, u->uid, u->gid);
        if (r < 0) {
                log_error("Failed to create runtime directory %s: %s", p, strerror(-r));
                free(p);
                u->runtime_path = NULL;
                return r;
        }

        u->runtime_path = p;
        return 0;
}

static int user_create_cgroup(User *u) {
        char **k;
        char *p;
        int r;

        assert(u);

        if (!u->cgroup_path) {
                if (asprintf(&p, "%s/%s", u->manager->cgroup_path, u->name) < 0) {
                        log_error("Out of memory");
                        return -ENOMEM;
                }
        } else
                p = u->cgroup_path;

        r = cg_create(SYSTEMD_CGROUP_CONTROLLER, p);
        if (r < 0) {
                free(p);
                u->cgroup_path = NULL;
                log_error("Failed to create cgroup "SYSTEMD_CGROUP_CONTROLLER":%s: %s", p, strerror(-r));
                return r;
        }

        u->cgroup_path = p;

        STRV_FOREACH(k, u->manager->controllers) {
                r = cg_create(*k, p);
                if (r < 0)
                        log_warning("Failed to create cgroup %s:%s: %s", *k, p, strerror(-r));
        }

        return 0;
}

static int user_start_service(User *u) {
        assert(u);

        return 0;
}

int user_start(User *u) {
        int r;

        assert(u);

        /* Make XDG_RUNTIME_DIR */
        r = user_mkdir_runtime_path(u);
        if (r < 0)
                return r;

        /* Create cgroup */
        r = user_create_cgroup(u);
        if (r < 0)
                return r;

        /* Spawn user systemd */
        r = user_start_service(u);
        if (r < 0)
                return r;

        dual_timestamp_get(&u->timestamp);

        return 0;
}

static int user_stop_service(User *u) {
        assert(u);

        if (!u->service)
                return 0;

        return 0;
}

static int user_shall_kill(User *u) {
        assert(u);

        return u->manager->kill_user_processes;
}

static int user_kill_cgroup(User *u) {
        int r;
        char **k;

        assert(u);

        if (!u->cgroup_path)
                return 0;

        cg_trim(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, false);

        if (user_shall_kill(u)) {

                r = cg_kill_recursive_and_wait(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, true);
                if (r < 0)
                        log_error("Failed to kill user cgroup: %s", strerror(-r));
        } else {

                r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, true);
                if (r < 0)
                        log_error("Failed to check user cgroup: %s", strerror(-r));
                else if (r > 0) {
                        r = cg_delete(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path);
                        if (r < 0)
                                log_error("Failed to delete user cgroup: %s", strerror(-r));
                } else
                        r = -EBUSY;
        }

        STRV_FOREACH(k, u->manager->controllers)
                cg_trim(*k, u->cgroup_path, true);

        free(u->cgroup_path);
        u->cgroup_path = NULL;

        return r;
}

static int user_remove_runtime_path(User *u) {
        int r;

        assert(u);

        if (!u->runtime_path)
                return 0;

        r = rm_rf(u->runtime_path, false, true);
        if (r < 0)
                log_error("Failed to remove runtime directory %s: %s", u->runtime_path, strerror(-r));

        free(u->runtime_path);
        u->runtime_path = NULL;

        return r;
}

int user_stop(User *u) {
        Session *s;
        int r = 0, k;
        assert(u);

        LIST_FOREACH(sessions_by_user, s, u->sessions) {
                k = session_stop(s);
                if (k < 0)
                        r = k;
        }

        /* Kill systemd */
        k = user_stop_service(u);
        if (k < 0)
                r = k;

        /* Kill cgroup */
        k = user_kill_cgroup(u);
        if (k < 0)
                r = k;

        /* Kill XDG_RUNTIME_DIR */
        k = user_remove_runtime_path(u);
        if (k < 0)
                r = k;

        return r;
}

int user_check_gc(User *u) {
        int r;
        char *p;

        assert(u);

        if (u->sessions)
                return 1;

        if (asprintf(&p, "/var/lib/systemd/linger/%s", u->name) < 0)
                return -ENOMEM;

        r = access(p, F_OK) >= 0;
        free(p);

        if (r > 0)
                return 1;

        if (u->cgroup_path) {
                r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, false);
                if (r < 0)
                        return r;

                if (r <= 0)
                        return 1;
        }

        return 0;
}

UserState user_get_state(User *u) {
        Session *i;

        assert(u);

        if (!u->sessions)
                return USER_LINGERING;

        LIST_FOREACH(sessions_by_user, i, u->sessions)
                if (session_is_active(i))
                        return USER_ACTIVE;

        return USER_ONLINE;
}

static const char* const user_state_table[_USER_STATE_MAX] = {
        [USER_OFFLINE] = "offline",
        [USER_LINGERING] = "lingering",
        [USER_ONLINE] = "online",
        [USER_ACTIVE] = "active"
};

DEFINE_STRING_TABLE_LOOKUP(user_state, UserState);
Commit	Line	Data
20263082 LP	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 General Public License as published by
	10	the Free Software Foundation; either version 2 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	General Public License for more details.
	17
	18	You should have received a copy of the GNU General Public License
	19	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	20	***/
	21
	22	#include <string.h>
	23	#include <unistd.h>
	24	#include <errno.h>
	25
	26	#include "logind.h"
	27	#include "util.h"
	28	#include "cgroup-util.h"
	29	#include "hashmap.h"
	30	#include "strv.h"
	31
	32	User* user_new(Manager m, uid_t uid, gid_t gid, const char name) {
	33	User *u;
	34
	35	assert(m);
	36	assert(name);
	37
	38	u = new(User, 1);
	39	if (!u)
	40	return NULL;
	41
	42	u->name = strdup(name);
	43	if (!u->name) {
	44	free(u);
	45	return NULL;
	46	}
	47
	48	if (asprintf(&u->state_file, "/run/systemd/user/%lu", (unsigned long) uid) < 0) {
	49	free(u->name);
	50	free(u);
	51	return NULL;
	52	}
	53
	54	if (hashmap_put(m->users, ULONG_TO_PTR((unsigned long) uid), u) < 0) {
	55	free(u->state_file);
	56	free(u->name);
	57	free(u);
	58	return NULL;
	59	}
	60
	61	u->manager = m;
	62	u->uid = uid;
	63	u->gid = gid;
	64
65	return u;
66	}
67
68	void user_free(User *u) {
69	assert(u);
70
71	while (u->sessions)
72	session_free(u->sessions);
73
74	free(u->cgroup_path);
75
76	free(u->service);
77	free(u->runtime_path);
78
79	hashmap_remove(u->manager->users, ULONG_TO_PTR((unsigned long) u->uid));
80
81	free(u->name);
82	free(u->state_file);
83	free(u);
84	}
85
86	int user_save(User *u) {
87	FILE *f;
88	int r;
89
90	assert(u);
91	assert(u->state_file);
92
93	r = safe_mkdir("/run/systemd/user", 0755, 0, 0);
94	if (r < 0)
95	return r;
96
97	f = fopen(u->state_file, "we");
98	if (!f)
99	return -errno;
100
101	fprintf(f,
102	"NAME=%s\n"
103	"STATE=%s\n",
104	u->name,
105	user_state_to_string(user_get_state(u)));
106
107	if (u->cgroup_path)
108	fprintf(f,
109	"CGROUP=%s\n",
110	u->cgroup_path);
111
112	if (u->runtime_path)
113	fprintf(f,
114	"RUNTIME=%s\n",
115	u->runtime_path);
116
117	if (u->service)
118	fprintf(f,
119	"SERVICE=%s\n",
120	u->service);
121
122	if (u->display)
123	fprintf(f,
124	"DISPLAY=%s\n",
125	u->display->id);
126
127	fflush(f);
128	if (ferror(f)) {
129	r = -errno;
130	unlink(u->state_file);
131	}
132
133	fclose(f);
134	return r;
135	}
136
137	int user_load(User *u) {
138	int r;
139	char *display = NULL;
140	Session *s;
141
142	assert(u);
143
144	r = parse_env_file(u->state_file, "r",
145	"CGROUP", &u->cgroup_path,
146	"RUNTIME", &u->runtime_path,
147	"SERVICE", &u->service,
148	"DISPLAY", &display,
149	NULL);
150	if (r < 0) {
151	free(display);
152
153	if (r == -ENOENT)
154	return 0;
155
156	log_error("Failed to read %s: %s", u->state_file, strerror(-r));
157	return r;
158	}
159
160	s = hashmap_get(u->manager->sessions, display);
161	free(display);
162
163	if (s && s->display && x11_display_is_local(s->display))
164	u->display = s;
165
166	return r;
167	}
168
169	static int user_mkdir_runtime_path(User *u) {
170	char *p;
171	int r;
172
173	assert(u);
174
175	r = safe_mkdir("/run/user", 0755, 0, 0);
176	if (r < 0) {
177	log_error("Failed to create /run/user: %s", strerror(-r));
178	return r;
179	}
180
181	if (!u->runtime_path) {
182	p = strappend("/run/user/", u->name);
183
184	if (!p) {
185	log_error("Out of memory");
186	return -ENOMEM;
187	}
188	} else
189	p = u->runtime_path;
190
191	r = safe_mkdir(p, 0700, u->uid, u->gid);
192	if (r < 0) {
193	log_error("Failed to create runtime directory %s: %s", p, strerror(-r));
194	free(p);
195	u->runtime_path = NULL;
196	return r;
197	}
198
199	u->runtime_path = p;
200	return 0;
201	}
202
203	static int user_create_cgroup(User *u) {
204	char **k;
205	char *p;
206	int r;
207
208	assert(u);
209
210	if (!u->cgroup_path) {
211	if (asprintf(&p, "%s/%s", u->manager->cgroup_path, u->name) < 0) {
212	log_error("Out of memory");
213	return -ENOMEM;
214	}
215	} else
216	p = u->cgroup_path;
217
218	r = cg_create(SYSTEMD_CGROUP_CONTROLLER, p);
219	if (r < 0) {
220	free(p);
221	u->cgroup_path = NULL;
222	log_error("Failed to create cgroup "SYSTEMD_CGROUP_CONTROLLER":%s: %s", p, strerror(-r));
223	return r;
224	}
225
226	u->cgroup_path = p;
227
228	STRV_FOREACH(k, u->manager->controllers) {
229	r = cg_create(*k, p);
230	if (r < 0)
231	log_warning("Failed to create cgroup %s:%s: %s", *k, p, strerror(-r));
232	}
233
234	return 0;
235	}
236
237	static int user_start_service(User *u) {
238	assert(u);
239
240	return 0;
241	}
242
243	int user_start(User *u) {
244	int r;
245
246	assert(u);
247
248	/* Make XDG_RUNTIME_DIR */
249	r = user_mkdir_runtime_path(u);
250	if (r < 0)
251	return r;
252
253	/* Create cgroup */
254	r = user_create_cgroup(u);
255	if (r < 0)
256	return r;
257
258	/* Spawn user systemd */
259	r = user_start_service(u);
260	if (r < 0)
261	return r;
262
263	dual_timestamp_get(&u->timestamp);
264
265	return 0;
266	}
267
268	static int user_stop_service(User *u) {
269	assert(u);
270
271	if (!u->service)
272	return 0;
273
274	return 0;
275	}
276
277	static int user_shall_kill(User *u) {
278	assert(u);
279
280	return u->manager->kill_user_processes;
281	}
282
283	static int user_kill_cgroup(User *u) {
284	int r;
285	char **k;
286
287	assert(u);
288
289	if (!u->cgroup_path)
290	return 0;
291
292	cg_trim(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, false);
293
294	if (user_shall_kill(u)) {
295
296	r = cg_kill_recursive_and_wait(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, true);
297	if (r < 0)
298	log_error("Failed to kill user cgroup: %s", strerror(-r));
299	} else {
300
301	r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, true);
302	if (r < 0)
303	log_error("Failed to check user cgroup: %s", strerror(-r));
304	else if (r > 0) {
305	r = cg_delete(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path);
306	if (r < 0)
307	log_error("Failed to delete user cgroup: %s", strerror(-r));
308	} else
309	r = -EBUSY;
310	}
311
312	STRV_FOREACH(k, u->manager->controllers)
313	cg_trim(*k, u->cgroup_path, true);
314
315	free(u->cgroup_path);
316	u->cgroup_path = NULL;
317
318	return r;
319	}
320
321	static int user_remove_runtime_path(User *u) {
322	int r;
323
324	assert(u);
325
326	if (!u->runtime_path)
327	return 0;
328
329	r = rm_rf(u->runtime_path, false, true);
330	if (r < 0)
331	log_error("Failed to remove runtime directory %s: %s", u->runtime_path, strerror(-r));
332
333	free(u->runtime_path);
334	u->runtime_path = NULL;
335
336	return r;
337	}
338
339	int user_stop(User *u) {
340	Session *s;
341	int r = 0, k;
342	assert(u);
343
344	LIST_FOREACH(sessions_by_user, s, u->sessions) {
345	k = session_stop(s);
346	if (k < 0)
347	r = k;
348	}
349
350	/* Kill systemd */
351	k = user_stop_service(u);
352	if (k < 0)
353	r = k;
354
355	/* Kill cgroup */
356	k = user_kill_cgroup(u);
357	if (k < 0)
358	r = k;
359
360	/* Kill XDG_RUNTIME_DIR */
361	k = user_remove_runtime_path(u);
362	if (k < 0)
363	r = k;
364
365	return r;
366	}
367
368	int user_check_gc(User *u) {
369	int r;
370	char *p;
371
372	assert(u);
373
374	if (u->sessions)
375	return 1;
376
377	if (asprintf(&p, "/var/lib/systemd/linger/%s", u->name) < 0)
378	return -ENOMEM;
379
380	r = access(p, F_OK) >= 0;
381	free(p);
382
383	if (r > 0)
384	return 1;
385
386	if (u->cgroup_path) {
387	r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, false);
388	if (r < 0)
389	return r;
390
391	if (r <= 0)
392	return 1;
393	}
394
395	return 0;
396	}
397
398	UserState user_get_state(User *u) {
399	Session *i;
400
401	assert(u);
402
403	if (!u->sessions)
404	return USER_LINGERING;
405
406	LIST_FOREACH(sessions_by_user, i, u->sessions)
407	if (session_is_active(i))
408	return USER_ACTIVE;
409
410	return USER_ONLINE;
411	}
412
413	static const char* const user_state_table[_USER_STATE_MAX] = {
414	[USER_OFFLINE] = "offline",
415	[USER_LINGERING] = "lingering",
416	[USER_ONLINE] = "online",
417	[USER_ACTIVE] = "active"
418	};
419
420	DEFINE_STRING_TABLE_LOOKUP(user_state, UserState);