HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/shared/userdb.c

80,802 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: e3487fbb628e9f94d4adf0cac82759ccad3094db

Lines 2001–2224 of 2,224

        assert(ret);
 
        iterator = userdb_iterator_new(LOOKUP_MEMBERSHIP, flags);
        if (!iterator)
                return -ENOMEM;
 
        qr = userdb_start_query(
                        iterator,
                        "io.systemd.UserDatabase.GetMemberships",
                        /* more= */ true,
                        /* query= */ NULL,
                        /* sfilter= */ NULL,
                        flags);
 
        if (!FLAGS_SET(flags, USERDB_EXCLUDE_NSS) && (qr < 0 || !iterator->nss_covered)) {
                r = userdb_iterator_block_nss_systemd(iterator);
                if (r < 0)
                        return r;
 
                setgrent();
                iterator->nss_iterating = true;
        }
 
        if (!FLAGS_SET(flags, USERDB_EXCLUDE_DROPIN) && (qr < 0 || !iterator->dropin_covered))
                discover_membership_dropins(iterator, flags);
 
        if (qr < 0 &&
            !iterator->nss_iterating &&
            strv_isempty(iterator->dropins))
                return qr;
 
        *ret = TAKE_PTR(iterator);
        return 0;
}
 
int membershipdb_iterator_get(
                UserDBIterator *iterator,
                char **ret_user,
                char **ret_group) {
 
        int r;
 
        assert(iterator);
 
        for (;;) {
                /* If we are iterating through NSS acquire a new group entry if we haven't acquired one yet. */
                if (!iterator->members_of_group) {
                        struct group *g;
 
                        if (!iterator->nss_iterating)
                                break;
 
                        assert(!iterator->found_user_name);
                        do {
                                errno = 0;
                                g = getgrent();
                                if (!g) {
                                        if (errno != 0)
                                                log_debug_errno(errno, "Failure during NSS group iteration, ignoring: %m");
                                        break;
                                }
 
                        } while (iterator->filter_user_name ? !strv_contains(g->gr_mem, iterator->filter_user_name) :
                                                              strv_isempty(g->gr_mem));
 
                        if (g) {
                                r = free_and_strdup(&iterator->found_group_name, g->gr_name);
                                if (r < 0)
                                        return r;
 
                                if (iterator->filter_user_name)
                                        iterator->members_of_group = strv_new(iterator->filter_user_name);
                                else
                                        iterator->members_of_group = strv_copy(g->gr_mem);
                                if (!iterator->members_of_group)
                                        return -ENOMEM;
 
                                iterator->index_members_of_group = 0;
                        } else {
                                iterator->nss_iterating = false;
                                endgrent();
                                break;
                        }
                }
 
                assert(iterator->found_group_name);
                assert(iterator->members_of_group);
                assert(!iterator->found_user_name);
 
                if (iterator->members_of_group[iterator->index_members_of_group]) {
                        _cleanup_free_ char *cu = NULL, *cg = NULL;
 
                        if (ret_user) {
                                cu = strdup(iterator->members_of_group[iterator->index_members_of_group]);
                                if (!cu)
                                        return -ENOMEM;
                        }
 
                        if (ret_group) {
                                cg = strdup(iterator->found_group_name);
                                if (!cg)
                                        return -ENOMEM;
                        }
 
                        if (ret_user)
                                *ret_user = TAKE_PTR(cu);
 
                        if (ret_group)
                                *ret_group = TAKE_PTR(cg);
 
                        iterator->index_members_of_group++;
                        return 0;
                }
 
                iterator->members_of_group = strv_free(iterator->members_of_group);
                iterator->found_group_name = mfree(iterator->found_group_name);
        }
 
        for (; iterator->dropins && iterator->dropins[iterator->current_dropin]; iterator->current_dropin++) {
                const char *i = iterator->dropins[iterator->current_dropin], *e, *c;
                _cleanup_free_ char *un = NULL, *gn = NULL;
 
                e = endswith(i, ".membership");
                if (!e)
                        continue;
 
                c = memchr(i, ':', e - i);
                if (!c)
                        continue;
 
                un = strndup(i, c - i);
                if (!un)
                        return -ENOMEM;
                if (iterator->filter_user_name) {
                        if (!streq(un, iterator->filter_user_name))
                                continue;
                } else if (!valid_user_group_name(un, VALID_USER_RELAX))
                        continue;
 
                c++; /* skip over ':' */
                gn = strndup(c, e - c);
                if (!gn)
                        return -ENOMEM;
                if (iterator->filter_group_name) {
                        if (!streq(gn, iterator->filter_group_name))
                                continue;
                } else if (!valid_user_group_name(gn, VALID_USER_RELAX))
                        continue;
 
                iterator->current_dropin++;
                iterator->n_found++;
 
                if (ret_user)
                        *ret_user = TAKE_PTR(un);
                if (ret_group)
                        *ret_group = TAKE_PTR(gn);
 
                return 0;
        }
 
        r = userdb_process(iterator, NULL, NULL, ret_user, ret_group);
        if (r < 0 && iterator->n_found > 0)
                return -ESRCH;
 
        return r;
}
 
int membershipdb_by_group_strv(const char *name, UserDBFlags flags, char ***ret) {
        _cleanup_(userdb_iterator_freep) UserDBIterator *iterator = NULL;
        _cleanup_strv_free_ char **members = NULL;
        int r;
 
        assert(name);
        assert(ret);
 
        r = membershipdb_by_group(name, flags, &iterator);
        if (r < 0)
                return r;
 
        for (;;) {
                _cleanup_free_ char *user_name = NULL;
 
                r = membershipdb_iterator_get(iterator, &user_name, NULL);
                if (r == -ESRCH)
                        break;
                if (r < 0)
                        return r;
 
                r = strv_consume(&members, TAKE_PTR(user_name));
                if (r < 0)
                        return r;
        }
 
        strv_sort_uniq(members);
 
        *ret = TAKE_PTR(members);
        return 0;
}
 
int userdb_block_nss_systemd(int b) {
        int r;
 
        /* Note that we might be called from libnss_systemd.so.2 itself, but that should be fine, really. */
 
        _cleanup_(dlclosep) void *dl = NULL;
        const char *dle;
        r = dlopen_safe(LIBDIR "/libnss_systemd.so.2", &dl, &dle);
        if (r < 0) {
                /* If the file isn't installed, don't complain loudly */
                log_debug_errno(r, "Failed to dlopen(libnss_systemd.so.2), ignoring: %s", dle ?: STRERROR(r));
                return 0;
        }
 
        log_debug("Loaded '%s' via dlopen()", LIBDIR "/libnss_systemd.so.2");
 
        int (*call)(bool b) = dlsym(dl, "_nss_systemd_block");
        if (!call)
                /* If the file is installed but lacks the symbol we expect, things are weird, let's complain */
                return log_debug_errno(SYNTHETIC_ERRNO(ELIBBAD),
                                       "Unable to find symbol _nss_systemd_block in libnss_systemd.so.2: %s", dlerror());
 
        return call(b);
}