HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/basic/user-util.c
Git blob: fe4c0e6a36858f6b915705f50219a00c104a50f1
Lines 1001–1590 of 1,590
return 0;
}
#if ENABLE_GSHADOW
int putsgent_sane(const struct sgrp *sg, FILE *stream) {
assert(sg);
assert(stream);
errno = 0;
if (putsgent(sg, stream) != 0)
return errno_or_else(EIO);
return 0;
}
#endif
int fgetpwent_sane(FILE *stream, struct passwd **pw) {
assert(stream);
assert(pw);
errno = 0;
struct passwd *p = fgetpwent(stream);
if (!p && !IN_SET(errno, 0, ENOENT))
return -errno;
*pw = p;
return !!p;
}
int fgetspent_sane(FILE *stream, struct spwd **sp) {
assert(stream);
assert(sp);
errno = 0;
struct spwd *s = fgetspent(stream);
if (!s && !IN_SET(errno, 0, ENOENT))
return -errno;
*sp = s;
return !!s;
}
int fgetgrent_sane(FILE *stream, struct group **gr) {
assert(stream);
assert(gr);
errno = 0;
struct group *g = fgetgrent(stream);
if (!g && !IN_SET(errno, 0, ENOENT))
return -errno;
*gr = g;
return !!g;
}
#if ENABLE_GSHADOW
int fgetsgent_sane(FILE *stream, struct sgrp **sg) {
assert(stream);
assert(sg);
errno = 0;
struct sgrp *s = fgetsgent(stream);
if (!s && !IN_SET(errno, 0, ENOENT))
return -errno;
*sg = s;
return !!s;
}
#endif
int is_this_me(const char *username) {
uid_t uid;
int r;
/* Checks if the specified username is our current one. Passed string might be a UID or a user name. */
r = get_user_creds(username, /* flags= */ USER_CREDS_ALLOW_MISSING, NULL, &uid, NULL, NULL, NULL);
if (r < 0)
return r;
return uid == getuid();
}
const char* get_home_root(void) {
/* For debug purposes allow overriding where we look for home dirs */
const char *e = secure_getenv("SYSTEMD_HOME_ROOT");
if (e && path_is_absolute(e) && path_is_normalized(e))
return e;
return "/home";
}
static int copy_struct_passwd(const struct passwd *pw, struct passwd **ret) {
assert(pw);
assert(ret);
size_t need_bytes = sizeof(struct passwd)
+ strlen_ptr(pw->pw_name) + 1
+ strlen_ptr(pw->pw_passwd) + 1
+ strlen_ptr(pw->pw_gecos) + 1
+ strlen_ptr(pw->pw_dir) + 1
+ strlen_ptr(pw->pw_shell) + 1;
char *buf = malloc(need_bytes);
if (!buf)
return -ENOMEM;
struct passwd *newpw = (struct passwd *) buf;
/* The layout in our buffer:
* struct passwd, and then individual strings. */
char *p = buf + sizeof(struct passwd);
newpw->pw_name = p;
p = stpcpy(p, strempty(pw->pw_name)) + 1;
newpw->pw_passwd = p;
p = stpcpy(p, strempty(pw->pw_passwd)) + 1;
newpw->pw_uid = pw->pw_uid;
newpw->pw_gid = pw->pw_gid;
newpw->pw_gecos = p;
p = stpcpy(p, strempty(pw->pw_gecos)) + 1;
newpw->pw_dir = p;
p = stpcpy(p, strempty(pw->pw_dir)) + 1;
newpw->pw_shell = p;
p = stpcpy(p, strempty(pw->pw_shell)) + 1;
*ret = newpw;
return 0;
}
/* Iterate the given list of passwd-format files looking for an entry matching the predicate (by
* name if 'name' is non-NULL and by 'uid' if valid). Returns -ESRCH if no entry is found. */
int lookup_pwent_in_files(
char * const *files,
const char *name,
uid_t uid,
struct passwd **ret) {
int r;
assert(files);
assert(name || uid_is_valid(uid));
STRV_FOREACH(fname, files) {
_cleanup_fclose_ FILE *f = NULL;
struct passwd *pw;
r = fopen_unlocked(*fname, "re", &f);
if (r == -ENOENT)
continue;
if (r < 0)
return r;
while ((r = fgetpwent_sane(f, &pw)) > 0) {
if (name && !streq_ptr(pw->pw_name, name))
continue;
if (uid_is_valid(uid) && pw->pw_uid != uid)
continue;
if (ret)
return copy_struct_passwd(pw, ret);
return 0;
}
if (r < 0)
return r;
}
return -ESRCH;
}
#if !BUILD_STATIC
static size_t getpw_buffer_size(void) {
long bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
return bufsize <= 0 ? 4096U : (size_t) bufsize;
}
static bool errno_is_user_doesnt_exist(int error) {
/* See getpwnam(3) and getgrnam(3): those codes and others can be returned if the user or group are
* not found. */
return IN_SET(abs(error), ENOENT, ESRCH, EBADF, EPERM);
}
#endif
int getpwnam_malloc(const char *name, struct passwd **ret) {
/* For static builds use a very simplistic implementation that looks at 'passwd' in /etc/
* and /usr/lib/, and for non-static builds use NSS. The first matching entry wins. The
* same logic is implemented in getpwnam_malloc, getpwuid_malloc, getgrnam_malloc, and
* getgrgid_malloc. */
if (isempty(name))
return -EINVAL;
#if BUILD_STATIC
return lookup_pwent_in_files(PASSWD_FILES, name, UID_INVALID, ret);
#else
size_t bufsize = getpw_buffer_size();
int r;
/* A wrapper around getpwnam_r() that allocates the necessary buffer on the heap. The caller must
* free() the returned structure! */
for (;;) {
_cleanup_free_ void *buf = NULL;
/* Silence static analyzers */
assert(bufsize <= SIZE_MAX - ALIGN(sizeof(struct passwd)));
buf = malloc0(ALIGN(sizeof(struct passwd)) + bufsize);
if (!buf)
return -ENOMEM;
struct passwd *pw = NULL;
r = getpwnam_r(name, buf, (char*) buf + ALIGN(sizeof(struct passwd)), bufsize, &pw);
if (r == 0) {
if (pw) {
if (ret)
*ret = TAKE_PTR(buf);
return 0;
}
return -ESRCH;
}
assert(r > 0);
/* getpwnam() may fail with ENOENT if /etc/passwd is missing. For us that is equivalent to
* the name not being defined. */
if (errno_is_user_doesnt_exist(r))
return -ESRCH;
if (r != ERANGE)
return -r;
if (bufsize > SIZE_MAX/2 - ALIGN(sizeof(struct passwd)))
return -ENOMEM;
bufsize *= 2;
}
#endif
}
int getpwuid_malloc(uid_t uid, struct passwd **ret) {
if (!uid_is_valid(uid))
return -EINVAL;
#if BUILD_STATIC
return lookup_pwent_in_files(PASSWD_FILES, /* name= */ NULL, uid, ret);
#else
size_t bufsize = getpw_buffer_size();
int r;
for (;;) {
_cleanup_free_ void *buf = NULL;
/* Silence static analyzers */
assert(bufsize <= SIZE_MAX - ALIGN(sizeof(struct passwd)));
buf = malloc0(ALIGN(sizeof(struct passwd)) + bufsize);
if (!buf)
return -ENOMEM;
struct passwd *pw = NULL;
r = getpwuid_r(uid, buf, (char*) buf + ALIGN(sizeof(struct passwd)), bufsize, &pw);
if (r == 0) {
if (pw) {
if (ret)
*ret = TAKE_PTR(buf);
return 0;
}
return -ESRCH;
}
assert(r > 0);
if (errno_is_user_doesnt_exist(r))
return -ESRCH;
if (r != ERANGE)
return -r;
if (bufsize > SIZE_MAX/2 - ALIGN(sizeof(struct passwd)))
return -ENOMEM;
bufsize *= 2;
}
#endif
}
static int copy_struct_group(const struct group *gr, struct group **ret) {
assert(gr);
assert(ret);
size_t need_bytes = sizeof(struct group)
+ strlen_ptr(gr->gr_name) + 1
+ strlen_ptr(gr->gr_passwd) + 1,
n_mem = 0;
STRV_FOREACH(s, gr->gr_mem) {
need_bytes += sizeof(char*) + strlen(*s) + 1;
n_mem++;
}
need_bytes += sizeof(char*); /* NULL terminator for gr_mem */
char *buf = malloc(need_bytes);
if (!buf)
return -ENOMEM;
struct group *newgr = (struct group *) buf;
/* The layout in our buffer:
* struct group, ->gr_mem pointers terminated by NULL, ->gr_name, ->gr_passwd, ->gr_mem items */
/* The ->gr_mem array is first, because it needs alignment. */
assert_cc(sizeof(struct group) % alignof(char*) == 0);
char *p = buf + sizeof(struct group) + (n_mem + 1) * sizeof(char*);
newgr->gr_name = p;
p = stpcpy(p, strempty(gr->gr_name)) + 1;
newgr->gr_passwd = p;
p = stpcpy(p, strempty(gr->gr_passwd)) + 1;
newgr->gr_gid = gr->gr_gid;
newgr->gr_mem = (char**) (buf + sizeof(struct group));
for (size_t i = 0; i < n_mem; i++) {
newgr->gr_mem[i] = p;
p = stpcpy(p, gr->gr_mem[i]) + 1;
}
newgr->gr_mem[n_mem] = NULL;
*ret = newgr;
return 0;
}
/* See lookup_pwent_in_files() for the analogous passwd-file version. */
int lookup_grent_in_files(
char * const *files,
const char *name,
gid_t gid,
struct group **ret) {
int r;
assert(files);
assert(name || gid_is_valid(gid));
STRV_FOREACH(fname, files) {
_cleanup_fclose_ FILE *f = NULL;
struct group *gr;
r = fopen_unlocked(*fname, "re", &f);
if (r == -ENOENT)
continue;
if (r < 0)
return r;
while ((r = fgetgrent_sane(f, &gr)) > 0) {
if (name && !streq_ptr(gr->gr_name, name))
continue;
if (gid_is_valid(gid) && gr->gr_gid != gid)
continue;
if (ret)
return copy_struct_group(gr, ret);
return 0;
}
if (r < 0)
return r;
}
return -ESRCH;
}
int sysconf_ngroups_max(void) {
/* Query sysconf _SC_NGROUPS_MAX. Returns an int because the expected value is 64k
* and later on this is used as an int with various glibc consumers. */
errno = 0;
long ngroups_max = sysconf(_SC_NGROUPS_MAX);
if (ngroups_max <= 0)
return errno_or_else(EOPNOTSUPP);
if (ngroups_max > INT_MAX)
return -ERANGE;
return ngroups_max;
}
ssize_t lookup_groups_in_files(
char * const *files,
const char *name,
gid_t gid,
gid_t **ret) {
_cleanup_free_ gid_t *arr = NULL;
ssize_t n_arr = 0;
int r;
assert(files);
assert(name);
assert(gid_is_valid(gid));
int ngroups_max = sysconf_ngroups_max();
if (ngroups_max < 0)
return ngroups_max;
if (!GREEDY_REALLOC(arr, n_arr + 1))
return -ENOMEM;
arr[n_arr++] = gid;
STRV_FOREACH(fname, files) {
_cleanup_fclose_ FILE *f = NULL;
struct group *gr;
r = fopen_unlocked(*fname, "re", &f);
if (r == -ENOENT)
continue;
if (r < 0)
return r;
while ((r = fgetgrent_sane(f, &gr)) > 0) {
if (gid == gr->gr_gid)
continue;
/* Deduplicate groups, in case the group is doubly defined in the same or
* different files. */
if (gid_list_has(arr, n_arr, gr->gr_gid))
continue;
if (!strv_contains(gr->gr_mem, name))
continue;
/* Do not allow more than _SC_NGROUPS_MAX. */
if (n_arr >= ngroups_max)
return -ENOBUFS;
if (!GREEDY_REALLOC(arr, n_arr + 1))
return -ENOMEM;
arr[n_arr++] = gr->gr_gid;
}
if (r < 0)
return r;
}
if (ret)
*ret = TAKE_PTR(arr);
return n_arr;
}
int getgrouplist_malloc(const char *user, gid_t gid, gid_t **ret) {
#if BUILD_STATIC
return lookup_groups_in_files(GROUP_FILES, user, gid, ret);
#else
int ngroups_max = sysconf_ngroups_max();
if (ngroups_max < 0)
return ngroups_max;
_cleanup_free_ gid_t *gids = new(gid_t, ngroups_max);
if (!gids)
return -ENOMEM;
int k = ngroups_max;
if (getgrouplist(user, gid, gids, &k) < 0)
return -EIO; /* getgrouplist does not set errno */
if (ret)
*ret = TAKE_PTR(gids);
return k;
#endif
}
int initgroups_wrapper(const char *user, gid_t gid) {
#if BUILD_STATIC
_cleanup_free_ gid_t *groups = NULL;
int r, n_groups;
n_groups = getgrouplist_malloc(user, gid, &groups);
if (n_groups <= 0)
return n_groups;
/* Try to set the maximum number of groups the kernel can handle. This is what glibc does. */
for (; n_groups > 0; n_groups--) {
r = RET_NERRNO(setgroups(n_groups, groups));
if (r != -EINVAL)
break;
}
return r;
#else
return RET_NERRNO(initgroups(user, gid));
#endif
}
#if !BUILD_STATIC
static size_t getgr_buffer_size(void) {
long bufsize = sysconf(_SC_GETGR_R_SIZE_MAX);
return bufsize <= 0 ? 4096U : (size_t) bufsize;
}
#endif
int getgrnam_malloc(const char *name, struct group **ret) {
if (isempty(name))
return -EINVAL;
#if BUILD_STATIC
return lookup_grent_in_files(GROUP_FILES, name, GID_INVALID, ret);
#else
size_t bufsize = getgr_buffer_size();
int r;
for (;;) {
_cleanup_free_ void *buf = NULL;
/* Silence static analyzers */
assert(bufsize <= SIZE_MAX - ALIGN(sizeof(struct group)));
buf = malloc0(ALIGN(sizeof(struct group)) + bufsize);
if (!buf)
return -ENOMEM;
struct group *gr = NULL;
r = getgrnam_r(name, buf, (char*) buf + ALIGN(sizeof(struct group)), bufsize, &gr);
if (r == 0) {
if (gr) {
if (ret)
*ret = TAKE_PTR(buf);
return 0;
}
return -ESRCH;
}
assert(r > 0);
if (errno_is_user_doesnt_exist(r))
return -ESRCH;
if (r != ERANGE)
return -r;
if (bufsize > SIZE_MAX/2 - ALIGN(sizeof(struct group)))
return -ENOMEM;
bufsize *= 2;
}
#endif
}
int getgrgid_malloc(gid_t gid, struct group **ret) {
if (!gid_is_valid(gid))
return -EINVAL;
#if BUILD_STATIC
return lookup_grent_in_files(GROUP_FILES, /* name= */ NULL, gid, ret);
#else
size_t bufsize = getgr_buffer_size();
int r;
for (;;) {
_cleanup_free_ void *buf = NULL;
/* Silence static analyzers */
assert(bufsize <= SIZE_MAX - ALIGN(sizeof(struct group)));
buf = malloc0(ALIGN(sizeof(struct group)) + bufsize);
if (!buf)
return -ENOMEM;
struct group *gr = NULL;
r = getgrgid_r(gid, buf, (char*) buf + ALIGN(sizeof(struct group)), bufsize, &gr);
if (r == 0) {
if (gr) {
if (ret)
*ret = TAKE_PTR(buf);
return 0;
}
return -ESRCH;
}
assert(r > 0);
if (errno_is_user_doesnt_exist(r))
return -ESRCH;
if (r != ERANGE)
return -r;
if (bufsize > SIZE_MAX/2 - ALIGN(sizeof(struct group)))
return -ENOMEM;
bufsize *= 2;
}
#endif
}