2 This file is part of systemd.
4 Copyright 2010 Lennart Poettering
6 systemd is free software; you can redistribute it and/or modify it
7 under the terms of the GNU Lesser General Public License as published by
8 the Free Software Foundation; either version 2.1 of the License, or
9 (at your option) any later version.
11 systemd is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public License
17 along with systemd; If not, see <http://www.gnu.org/licenses/>.
34 #include "alloc-util.h"
36 #include "formats-util.h"
38 #include "parse-util.h"
39 #include "path-util.h"
40 #include "string-util.h"
41 #include "user-util.h"
43 bool uid_is_valid(uid_t uid) {
45 /* Some libc APIs use UID_INVALID as special placeholder */
46 if (uid == (uid_t) UINT32_C(0xFFFFFFFF))
49 /* A long time ago UIDs where 16bit, hence explicitly avoid the 16bit -1 too */
50 if (uid == (uid_t) UINT32_C(0xFFFF))
56 int parse_uid(const char *s, uid_t *ret) {
62 assert_cc(sizeof(uid_t) == sizeof(uint32_t));
63 r = safe_atou32(s, &uid);
67 if (!uid_is_valid(uid))
68 return -ENXIO; /* we return ENXIO instead of EINVAL
69 * here, to make it easy to distuingish
70 * invalid numeric uids from invalid
79 char* getlogname_malloc(void) {
83 if (isatty(STDIN_FILENO) && fstat(STDIN_FILENO, &st) >= 0)
88 return uid_to_name(uid);
91 #if 0 /// UNNEEDED by elogind
92 char *getusername_malloc(void) {
99 return uid_to_name(getuid());
104 const char **username,
105 uid_t *uid, gid_t *gid,
107 const char **shell) {
115 /* We enforce some special rules for uid=0: in order to avoid
116 * NSS lookups for root we hardcode its data. */
118 if (streq(*username, "root") || streq(*username, "0")) {
136 if (parse_uid(*username, &u) >= 0) {
140 /* If there are multiple users with the same id, make
141 * sure to leave $USER to the configured value instead
142 * of the first occurrence in the database. However if
143 * the uid was configured by a numeric uid, then let's
144 * pick the real username from /etc/passwd. */
146 *username = p->pw_name;
149 p = getpwnam(*username);
153 return errno > 0 ? -errno : -ESRCH;
156 if (!uid_is_valid(p->pw_uid))
163 if (!gid_is_valid(p->pw_gid))
173 *shell = p->pw_shell;
178 int get_group_creds(const char **groupname, gid_t *gid) {
184 /* We enforce some special rules for gid=0: in order to avoid
185 * NSS lookups for root we hardcode its data. */
187 if (streq(*groupname, "root") || streq(*groupname, "0")) {
196 if (parse_gid(*groupname, &id) >= 0) {
201 *groupname = g->gr_name;
204 g = getgrnam(*groupname);
208 return errno > 0 ? -errno : -ESRCH;
211 if (!gid_is_valid(g->gr_gid))
220 char* uid_to_name(uid_t uid) {
224 /* Shortcut things to avoid NSS lookups */
226 return strdup("root");
228 if (uid_is_valid(uid)) {
231 bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
236 struct passwd pwbuf, *pw = NULL;
237 _cleanup_free_ char *buf = NULL;
239 buf = malloc(bufsize);
243 r = getpwuid_r(uid, &pwbuf, buf, (size_t) bufsize, &pw);
245 return strdup(pw->pw_name);
253 if (asprintf(&ret, UID_FMT, uid) < 0)
259 char* gid_to_name(gid_t gid) {
264 return strdup("root");
266 if (gid_is_valid(gid)) {
269 bufsize = sysconf(_SC_GETGR_R_SIZE_MAX);
274 struct group grbuf, *gr = NULL;
275 _cleanup_free_ char *buf = NULL;
277 buf = malloc(bufsize);
281 r = getgrgid_r(gid, &grbuf, buf, (size_t) bufsize, &gr);
283 return strdup(gr->gr_name);
291 if (asprintf(&ret, GID_FMT, gid) < 0)
297 #if 0 /// UNNEEDED by elogind
298 int in_gid(gid_t gid) {
300 int ngroups_max, r, i;
305 if (getegid() == gid)
308 if (!gid_is_valid(gid))
311 ngroups_max = sysconf(_SC_NGROUPS_MAX);
312 assert(ngroups_max > 0);
314 gids = alloca(sizeof(gid_t) * ngroups_max);
316 r = getgroups(ngroups_max, gids);
320 for (i = 0; i < r; i++)
327 int in_group(const char *name) {
331 r = get_group_creds(&name, &gid);
338 int get_home_dir(char **_h) {
346 /* Take the user specified one */
347 e = secure_getenv("HOME");
348 if (e && path_is_absolute(e)) {
357 /* Hardcode home directory for root to avoid NSS */
368 /* Check the database... */
372 return errno > 0 ? -errno : -ESRCH;
374 if (!path_is_absolute(p->pw_dir))
377 h = strdup(p->pw_dir);
385 int get_shell(char **_s) {
393 /* Take the user specified one */
404 /* Hardcode home directory for root to avoid NSS */
407 s = strdup("/bin/sh");
415 /* Check the database... */
419 return errno > 0 ? -errno : -ESRCH;
421 if (!path_is_absolute(p->pw_shell))
424 s = strdup(p->pw_shell);
433 int reset_uid_gid(void) {
435 if (setgroups(0, NULL) < 0)
438 if (setresgid(0, 0, 0) < 0)
441 if (setresuid(0, 0, 0) < 0)
447 #if 0 /// UNNEEDED by elogind
448 int take_etc_passwd_lock(const char *root) {
450 struct flock flock = {
452 .l_whence = SEEK_SET,
460 /* This is roughly the same as lckpwdf(), but not as awful. We
461 * don't want to use alarm() and signals, hence we implement
462 * our own trivial version of this.
464 * Note that shadow-utils also takes per-database locks in
465 * addition to lckpwdf(). However, we don't given that they
466 * are redundant as they they invoke lckpwdf() first and keep
467 * it during everything they do. The per-database locks are
468 * awfully racy, and thus we just won't do them. */
471 path = prefix_roota(root, "/etc/.pwd.lock");
473 path = "/etc/.pwd.lock";
475 fd = open(path, O_WRONLY|O_CREAT|O_CLOEXEC|O_NOCTTY|O_NOFOLLOW, 0600);
479 r = fcntl(fd, F_SETLKW, &flock);