HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/basic/user-util.c

53,306 bytesGit mode 100644Download original fileLGPL-2.1-or-later

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
}